diff --git a/.github/workflows/pr-jobs.yml b/.github/workflows/pr-jobs.yml index d008b43363..674d712f12 100644 --- a/.github/workflows/pr-jobs.yml +++ b/.github/workflows/pr-jobs.yml @@ -314,6 +314,23 @@ jobs: - run: CC=clang-21 CXX=clang++-21 USE_CLANG=1 make -j32 all microbench - run: make clean - run: CC=clang-21 CXX=clang++-21 USE_CLANG=1 DEBUG_LEVEL=0 make -j32 release + - name: Install clang-format-21 for C API gen checks + run: apt-get update && apt-get install -y clang-format-21 + - name: Check C API codegen (link-complete, backward-compatible, up to date) + # Run the make target in STRICT mode so this core CI job HARD-FAILS rather + # than silently skipping if a prerequisite (clang++, clang-format, or the + # compat baseline ref) is ever missing. See `make check-c-api-gen`. + run: | + # The container checkout is owned by a different user, so git refuses to + # operate on it ("dubious ownership") -- mark it safe for the `git fetch` + # and the `git show` the compat checker runs. + git config --global --add safe.directory "$GITHUB_WORKSPACE" + git config --global --add safe.directory '*' + git fetch --no-tags --depth=1 origin main + CXX=clang++-21 make check-c-api-gen \ + CHECK_C_API_GEN_STRICT=1 \ + API_COMPAT_REF=FETCH_HEAD \ + CLANG_FORMAT_BINARY=clang-format-21 - uses: "./.github/actions/teardown-ccache" if: always() - uses: "./.github/actions/post-steps" diff --git a/.gitignore b/.gitignore index e89fd59b92..11bb1b194f 100644 --- a/.gitignore +++ b/.gitignore @@ -88,6 +88,8 @@ fbcode/ fbcode buckifier/*.pyc buckifier/__pycache__ +tools/__pycache__/ +tools/c_api_gen/__pycache__/ .arcconfig compile_commands.json diff --git a/Makefile b/Makefile index 08e56e2c83..d2d69150dc 100644 --- a/Makefile +++ b/Makefile @@ -764,7 +764,6 @@ util/build_version.cc: $(filter-out $(OBJ_DIR)/util/build_version.o, $(LIB_OBJEC $(AM_V_at)$(gen_build_version) > $@ endif CLEAN_FILES += util/build_version.cc - default: all #----------------------------------------------- @@ -809,7 +808,8 @@ endif # PLATFORM_SHARED_EXT .PHONY: check clean coverage ldb_tests package dbg gen-pc build_size \ release tags tags0 valgrind_check format static_lib shared_lib all \ rocksdbjavastatic rocksdbjava install install-static install-shared \ - uninstall analyze tools tools_lib check-headers checkout_folly clang-tidy + uninstall analyze tools tools_lib check-headers checkout_folly clang-tidy \ + check-c-api-c_test # Auto-configure git hooks on first build so developers do not need to run # "make install-hooks" manually. This is a no-op if already set. @@ -1127,8 +1127,89 @@ ifndef SKIP_FORMAT_BUCK_CHECKS $(MAKE) check-buck-targets $(MAKE) check-sources $(MAKE) check-workflow-yaml + $(MAKE) check-c-api-gen endif +# Check that the auto-generated C API files are up to date. It regenerates the +# fragments and the inlined c.h/c.cc and compares them against a snapshot of the +# checked-in copies (no net change when everything is up to date). It requires +# clang++ (libclang, used to parse the C++ headers) and clang-format. When those +# are unavailable the staleness/compat sub-checks are SKIPPED with a message so +# `make check` still works without the codegen toolchain; the link-completeness +# sub-check always runs (it needs no toolchain). +# +# Pin the formatter to match CI by setting CLANG_FORMAT_BINARY, e.g.: +# make check-c-api-gen CLANG_FORMAT_BINARY=clang-format-21 +# This target is part of `make check` and is skipped by SKIP_FORMAT_BUCK_CHECKS. +# +# Set CHECK_C_API_GEN_STRICT=1 to turn every "skip" below into a hard error, so a +# core CI job that runs this target cannot silently regress to a no-op if a +# prerequisite (clang++, or the compat baseline ref) goes missing. The dedicated +# build-linux-clang-21-no_test_run CI job runs this target with the flag set. +# Any non-empty value other than 0/no/false enables strict mode. +CLANG_FORMAT_BINARY ?= +# Backward-compatibility baseline for the C API (signature-level) check. CI +# overrides this with the PR's merge target; locally it falls back to main / +# origin/main and is skipped if neither resolves. +API_COMPAT_REF ?= main +CHECK_C_API_GEN_STRICT ?= +check-c-api-gen: + # Link-completeness is a property of the checked-in c.h/c.cc and needs no + # clang toolchain, so it always runs: every declared public C API function + # must have exactly one definition (guards against dropped wrappers that + # would break downstream language bindings at link time). + $(PYTHON) tools/c_api_gen/check_api_completeness.py + # Backward-compatibility: no public C function may be removed or have its + # signature changed vs the baseline. Skipped if the baseline ref is not + # resolvable locally (CI passes an explicit ref), unless CHECK_C_API_GEN_STRICT. + @strict=""; case "$(CHECK_C_API_GEN_STRICT)" in ""|0|no|NO|false|FALSE) ;; *) strict=1 ;; esac; \ + ref=""; \ + if git rev-parse --verify --quiet "$(API_COMPAT_REF)^{commit}" >/dev/null; then ref="$(API_COMPAT_REF)"; \ + elif git rev-parse --verify --quiet "origin/$(API_COMPAT_REF)^{commit}" >/dev/null; then ref="origin/$(API_COMPAT_REF)"; fi; \ + if [ -n "$$ref" ]; then \ + $(PYTHON) tools/c_api_gen/check_api_compatibility.py --ref "$$ref"; \ + elif [ -n "$$strict" ]; then \ + echo "ERROR: C API compat baseline '$(API_COMPAT_REF)' not resolvable and CHECK_C_API_GEN_STRICT is set" >&2; exit 1; \ + else \ + echo "Skipping C API backward-compatibility check ($(API_COMPAT_REF) not found; set API_COMPAT_REF)"; \ + fi + # Staleness: regenerate and confirm the checked-in output is current. Needs a + # clang++ (the generator parses C++ ASTs); detect one the way the generator + # does (a clang in $(CXX) -- which may be ccache-prefixed/versioned -- else a + # bare/versioned clang++ on PATH) rather than testing $(CXX) verbatim. + @strict=""; case "$(CHECK_C_API_GEN_STRICT)" in ""|0|no|NO|false|FALSE) ;; *) strict=1 ;; esac; \ + cf_arg=""; \ + if [ -n "$(CLANG_FORMAT_BINARY)" ]; then cf_arg="--clang-format $(CLANG_FORMAT_BINARY)"; fi; \ + have_clang=""; \ + for c in $$(printf '%s\n' $(CXX) | grep -i clang) clang++ clang++-21 clang++-20 clang++-19 clang++-18 clang++-17 clang++-16 clang++-15 clang++-14 clang++-13; do \ + if command -v "$$c" >/dev/null 2>&1; then have_clang=1; break; fi; \ + done; \ + if [ -n "$$have_clang" ]; then \ + $(PYTHON) tools/c_api_gen/verify_generated_up_to_date.py $$cf_arg; \ + elif [ -n "$$strict" ]; then \ + echo "ERROR: no clang++ found and CHECK_C_API_GEN_STRICT is set; cannot run the C API staleness check" >&2; exit 1; \ + else \ + echo "Skipping C API codegen staleness check (no clang++ found; install clang++ or set CXX to a clang to enable)"; \ + fi + +# Quick local validation for C API generation plus the focused C API test. +# This verifies the checked-in generated fragments as well as the inlined +# include/rocksdb/c.h and db/c.cc outputs, then runs c_test in an isolated +# TEST_TMPDIR to avoid stale-state failures. +check-c-api-c_test: + $(PYTHON) tools/c_api_gen/verify_generated_up_to_date.py + $(MAKE) c_test + @tmpdir=$$(mktemp -d); \ + trap 'rm -rf "$$tmpdir"' EXIT; \ + echo "===== Running c_test with TEST_TMPDIR=$$tmpdir"; \ + if command -v timeout >/dev/null 2>&1; then \ + TEST_TMPDIR="$$tmpdir" timeout 60 ./c_test; \ + elif command -v gtimeout >/dev/null 2>&1; then \ + TEST_TMPDIR="$$tmpdir" gtimeout 60 ./c_test; \ + else \ + TEST_TMPDIR="$$tmpdir" ./c_test; \ + fi + # TODO add ldb_tests check_some: $(ROCKSDBTESTS_SUBSET) for t in $(ROCKSDBTESTS_SUBSET); do echo "===== Running $$t (`date`)"; ./$$t || exit 1; done diff --git a/buckifier/targets_builder.py b/buckifier/targets_builder.py index 1f0f412e18..9682828d9f 100644 --- a/buckifier/targets_builder.py +++ b/buckifier/targets_builder.py @@ -118,6 +118,12 @@ class TARGETSBuilder: self.total_bin = self.total_bin + 1 def add_c_test(self): + # The actual c_test_bin target is defined by add_c_test_wrapper in the + # internal //rocks/buckifier:defs.bzl (not in this OSS repo). db/c_test.c + # #includes the generated c_api_gen/*.inc fragments, so under Buck's + # hermetic sandbox that wrapper must expose them as headers, e.g. + # headers = native.glob(["c_api_gen/**/*.inc"]) + # (Make/CMake resolve the include via -I. / PROJECT_SOURCE_DIR.) with open(self.path, "ab") as targets_file: targets_file.write( b""" diff --git a/c_api_gen/c_generated_block_based_options_subset.cc.inc b/c_api_gen/c_generated_block_based_options_subset.cc.inc new file mode 100644 index 0000000000..a2ed0faba7 --- /dev/null +++ b/c_api_gen/c_generated_block_based_options_subset.cc.inc @@ -0,0 +1,39 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'BlockBasedOptions simple' +// --header-out +// c_api_gen/c_generated_block_based_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_block_based_options_subset.cc.inc + +/* BlockBasedOptions simple */ + +void rocksdb_block_based_options_set_data_block_hash_ratio( + rocksdb_block_based_table_options_t* options, double v) { + options->rep.data_block_hash_table_util_ratio = v; +} + +void rocksdb_block_based_options_set_top_level_index_pinning_tier( + rocksdb_block_based_table_options_t* options, int v) { + options->rep.metadata_cache_options.top_level_index_pinning = + static_cast(v); +} + +void rocksdb_block_based_options_set_partition_pinning_tier( + rocksdb_block_based_table_options_t* options, int v) { + options->rep.metadata_cache_options.partition_pinning = + static_cast(v); +} + +void rocksdb_block_based_options_set_unpartitioned_pinning_tier( + rocksdb_block_based_table_options_t* options, int v) { + options->rep.metadata_cache_options.unpartitioned_pinning = + static_cast(v); +} diff --git a/c_api_gen/c_generated_block_based_options_subset.h.inc b/c_api_gen/c_generated_block_based_options_subset.h.inc new file mode 100644 index 0000000000..8c69f13ed1 --- /dev/null +++ b/c_api_gen/c_generated_block_based_options_subset.h.inc @@ -0,0 +1,32 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'BlockBasedOptions simple' +// --header-out +// c_api_gen/c_generated_block_based_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_block_based_options_subset.cc.inc + +/* BlockBasedOptions simple */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_data_block_hash_ratio( + rocksdb_block_based_table_options_t* options, double v); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_top_level_index_pinning_tier( + rocksdb_block_based_table_options_t* options, int v); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_partition_pinning_tier( + rocksdb_block_based_table_options_t* options, int v); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_unpartitioned_pinning_tier( + rocksdb_block_based_table_options_t* options, int v); diff --git a/c_api_gen/c_generated_cuckoo_options_subset.cc.inc b/c_api_gen/c_generated_cuckoo_options_subset.cc.inc new file mode 100644 index 0000000000..7c73d5f2ed --- /dev/null +++ b/c_api_gen/c_generated_cuckoo_options_subset.cc.inc @@ -0,0 +1,21 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'CuckooOptions simple' +// --header-out +// c_api_gen/c_generated_cuckoo_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_cuckoo_options_subset.cc.inc + +/* CuckooOptions simple */ + +void rocksdb_cuckoo_options_set_hash_ratio( + rocksdb_cuckoo_table_options_t* options, double v) { + options->rep.hash_table_ratio = v; +} diff --git a/c_api_gen/c_generated_cuckoo_options_subset.h.inc b/c_api_gen/c_generated_cuckoo_options_subset.h.inc new file mode 100644 index 0000000000..c690fcd69c --- /dev/null +++ b/c_api_gen/c_generated_cuckoo_options_subset.h.inc @@ -0,0 +1,19 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'CuckooOptions simple' +// --header-out +// c_api_gen/c_generated_cuckoo_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_cuckoo_options_subset.cc.inc + +/* CuckooOptions simple */ + +extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_hash_ratio( + rocksdb_cuckoo_table_options_t* options, double v); diff --git a/c_api_gen/c_generated_db_simple_subset.cc.inc b/c_api_gen/c_generated_db_simple_subset.cc.inc new file mode 100644 index 0000000000..42a5c7d6ec --- /dev/null +++ b/c_api_gen/c_generated_db_simple_subset.cc.inc @@ -0,0 +1,189 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'DB data operations' +// --header-out +// c_api_gen/c_generated_db_simple_subset.h.inc +// --source-out +// c_api_gen/c_generated_db_simple_subset.cc.inc + +/* DB data operations */ + +void rocksdb_put(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, + db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_put_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, const char* val, + size_t vallen, char** errptr) { + SaveError(errptr, db->rep->Put(options->rep, column_family->rep, + Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_delete(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, char** errptr) { + SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen))); +} + +void rocksdb_delete_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, char** errptr) { + SaveError(errptr, db->rep->Delete(options->rep, column_family->rep, + Slice(key, keylen))); +} + +void rocksdb_merge(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, const char* val, + size_t vallen, char** errptr) { + SaveError(errptr, db->rep->Merge(options->rep, Slice(key, keylen), + Slice(val, vallen))); +} + +void rocksdb_merge_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, const char* val, + size_t vallen, char** errptr) { + SaveError(errptr, db->rep->Merge(options->rep, column_family->rep, + Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_write(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr) { + SaveError(errptr, db->rep->Write(options->rep, &batch->rep)); +} + +void rocksdb_put_with_ts(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, const char* ts, + size_t tslen, const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, db->rep->Put(options->rep, Slice(key, keylen), + Slice(ts, tslen), Slice(val, vallen))); +} + +void rocksdb_put_cf_with_ts(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, const char* ts, + size_t tslen, const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, + db->rep->Put(options->rep, column_family->rep, Slice(key, keylen), + Slice(ts, tslen), Slice(val, vallen))); +} + +void rocksdb_delete_with_ts(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, const char* ts, + size_t tslen, char** errptr) { + SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen), + Slice(ts, tslen))); +} + +void rocksdb_delete_cf_with_ts(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, const char* ts, + size_t tslen, char** errptr) { + SaveError(errptr, db->rep->Delete(options->rep, column_family->rep, + Slice(key, keylen), Slice(ts, tslen))); +} + +void rocksdb_singledelete(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, char** errptr) { + SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen))); +} + +void rocksdb_singledelete_cf(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, char** errptr) { + SaveError(errptr, db->rep->SingleDelete(options->rep, column_family->rep, + Slice(key, keylen))); +} + +void rocksdb_singledelete_with_ts(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, + const char* ts, size_t tslen, char** errptr) { + SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen), + Slice(ts, tslen))); +} + +void rocksdb_singledelete_cf_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* ts, size_t tslen, char** errptr) { + SaveError(errptr, + db->rep->SingleDelete(options->rep, column_family->rep, + Slice(key, keylen), Slice(ts, tslen))); +} + +void rocksdb_delete_range_cf(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, + const char* end_key, size_t end_key_len, + char** errptr) { + SaveError(errptr, db->rep->DeleteRange(options->rep, column_family->rep, + Slice(start_key, start_key_len), + Slice(end_key, end_key_len))); +} + +void rocksdb_flush(rocksdb_t* db, const rocksdb_flushoptions_t* options, + char** errptr) { + SaveError(errptr, db->rep->Flush(options->rep)); +} + +void rocksdb_flush_cf(rocksdb_t* db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, + char** errptr) { + SaveError(errptr, db->rep->Flush(options->rep, column_family->rep)); +} + +void rocksdb_flush_wal(rocksdb_t* db, unsigned char sync, char** errptr) { + SaveError(errptr, db->rep->FlushWAL(sync)); +} + +void rocksdb_pause_background_work(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->PauseBackgroundWork()); +} + +void rocksdb_continue_background_work(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->ContinueBackgroundWork()); +} + +void rocksdb_disable_file_deletions(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->DisableFileDeletions()); +} + +void rocksdb_enable_file_deletions(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->EnableFileDeletions()); +} + +void rocksdb_verify_checksum(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->VerifyChecksum()); +} + +void rocksdb_verify_file_checksums(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->VerifyFileChecksums(ReadOptions())); +} + +void rocksdb_destroy_db(const rocksdb_options_t* options, const char* name, + char** errptr) { + SaveError(errptr, DestroyDB(name, options->rep)); +} + +void rocksdb_repair_db(const rocksdb_options_t* options, const char* name, + char** errptr) { + SaveError(errptr, RepairDB(name, options->rep)); +} diff --git a/c_api_gen/c_generated_db_simple_subset.h.inc b/c_api_gen/c_generated_db_simple_subset.h.inc new file mode 100644 index 0000000000..b8a50874b3 --- /dev/null +++ b/c_api_gen/c_generated_db_simple_subset.h.inc @@ -0,0 +1,126 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'DB data operations' +// --header-out +// c_api_gen/c_generated_db_simple_subset.h.inc +// --source-out +// c_api_gen/c_generated_db_simple_subset.cc.inc + +/* DB data operations */ + +extern ROCKSDB_LIBRARY_API void rocksdb_put( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_put_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_merge( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_merge_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_write( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_put_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* ts, size_t tslen, const char* val, size_t vallen, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_put_cf_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* ts, size_t tslen, const char* val, size_t vallen, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* ts, size_t tslen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_cf_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* ts, size_t tslen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_singledelete( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* ts, size_t tslen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_cf_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* ts, size_t tslen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_range_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* start_key, + size_t start_key_len, const char* end_key, size_t end_key_len, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_flush( + rocksdb_t* db, const rocksdb_flushoptions_t* options, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_flush_cf( + rocksdb_t* db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_flush_wal(rocksdb_t* db, + unsigned char sync, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_pause_background_work(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_continue_background_work(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_disable_file_deletions(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_enable_file_deletions(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_verify_checksum(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_verify_file_checksums(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_destroy_db( + const rocksdb_options_t* options, const char* name, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_repair_db( + const rocksdb_options_t* options, const char* name, char** errptr); diff --git a/c_api_gen/c_generated_jobinfo_auto.cc.inc b/c_api_gen/c_generated_jobinfo_auto.cc.inc new file mode 100644 index 0000000000..3f5b63f776 --- /dev/null +++ b/c_api_gen/c_generated_jobinfo_auto.cc.inc @@ -0,0 +1,255 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/listener.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered JobInfo metadata simple + +/* FlushJobInfo */ + +uint32_t rocksdb_flushjobinfo_cf_id(const rocksdb_flushjobinfo_t* info) { + return info->rep.cf_id; +} + +const char* rocksdb_flushjobinfo_cf_name(const rocksdb_flushjobinfo_t* info, + size_t* size) { + *size = info->rep.cf_name.size(); + return info->rep.cf_name.data(); +} + +const char* rocksdb_flushjobinfo_file_path(const rocksdb_flushjobinfo_t* info, + size_t* size) { + *size = info->rep.file_path.size(); + return info->rep.file_path.data(); +} + +uint64_t rocksdb_flushjobinfo_file_number(const rocksdb_flushjobinfo_t* info) { + return info->rep.file_number; +} + +uint64_t rocksdb_flushjobinfo_oldest_blob_file_number( + const rocksdb_flushjobinfo_t* info) { + return info->rep.oldest_blob_file_number; +} + +uint64_t rocksdb_flushjobinfo_thread_id(const rocksdb_flushjobinfo_t* info) { + return info->rep.thread_id; +} + +int rocksdb_flushjobinfo_job_id(const rocksdb_flushjobinfo_t* info) { + return info->rep.job_id; +} + +unsigned char rocksdb_flushjobinfo_triggered_writes_slowdown( + const rocksdb_flushjobinfo_t* info) { + return info->rep.triggered_writes_slowdown; +} + +unsigned char rocksdb_flushjobinfo_triggered_writes_stop( + const rocksdb_flushjobinfo_t* info) { + return info->rep.triggered_writes_stop; +} + +uint64_t rocksdb_flushjobinfo_smallest_seqno( + const rocksdb_flushjobinfo_t* info) { + return info->rep.smallest_seqno; +} + +uint64_t rocksdb_flushjobinfo_largest_seqno( + const rocksdb_flushjobinfo_t* info) { + return info->rep.largest_seqno; +} + +uint32_t rocksdb_flushjobinfo_flush_reason(const rocksdb_flushjobinfo_t* info) { + return static_cast(info->rep.flush_reason); +} + +uint32_t rocksdb_flushjobinfo_blob_compression_type( + const rocksdb_flushjobinfo_t* info) { + return static_cast(info->rep.blob_compression_type); +} + +/* CompactionJobInfo */ + +uint32_t rocksdb_compactionjobinfo_cf_id( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.cf_id; +} + +const char* rocksdb_compactionjobinfo_cf_name( + const rocksdb_compactionjobinfo_t* info, size_t* size) { + *size = info->rep.cf_name.size(); + return info->rep.cf_name.data(); +} + +void rocksdb_compactionjobinfo_status(const rocksdb_compactionjobinfo_t* info, + char** errptr) { + SaveError(errptr, info->rep.status); +} + +uint64_t rocksdb_compactionjobinfo_thread_id( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.thread_id; +} + +int rocksdb_compactionjobinfo_job_id(const rocksdb_compactionjobinfo_t* info) { + return info->rep.job_id; +} + +int rocksdb_compactionjobinfo_num_l0_files( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.num_l0_files; +} + +int rocksdb_compactionjobinfo_base_input_level( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.base_input_level; +} + +int rocksdb_compactionjobinfo_output_level( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.output_level; +} + +uint32_t rocksdb_compactionjobinfo_compaction_reason( + const rocksdb_compactionjobinfo_t* info) { + return static_cast(info->rep.compaction_reason); +} + +uint32_t rocksdb_compactionjobinfo_compression( + const rocksdb_compactionjobinfo_t* info) { + return static_cast(info->rep.compression); +} + +uint32_t rocksdb_compactionjobinfo_blob_compression_type( + const rocksdb_compactionjobinfo_t* info) { + return static_cast(info->rep.blob_compression_type); +} + +unsigned char rocksdb_compactionjobinfo_aborted( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.aborted; +} + +/* SubcompactionJobInfo */ + +uint32_t rocksdb_subcompactionjobinfo_cf_id( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.cf_id; +} + +const char* rocksdb_subcompactionjobinfo_cf_name( + const rocksdb_subcompactionjobinfo_t* info, size_t* size) { + *size = info->rep.cf_name.size(); + return info->rep.cf_name.data(); +} + +void rocksdb_subcompactionjobinfo_status( + const rocksdb_subcompactionjobinfo_t* info, char** errptr) { + SaveError(errptr, info->rep.status); +} + +uint64_t rocksdb_subcompactionjobinfo_thread_id( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.thread_id; +} + +int rocksdb_subcompactionjobinfo_job_id( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.job_id; +} + +int rocksdb_subcompactionjobinfo_subcompaction_job_id( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.subcompaction_job_id; +} + +int rocksdb_subcompactionjobinfo_base_input_level( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.base_input_level; +} + +int rocksdb_subcompactionjobinfo_output_level( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.output_level; +} + +uint32_t rocksdb_subcompactionjobinfo_compaction_reason( + const rocksdb_subcompactionjobinfo_t* info) { + return static_cast(info->rep.compaction_reason); +} + +uint32_t rocksdb_subcompactionjobinfo_compression( + const rocksdb_subcompactionjobinfo_t* info) { + return static_cast(info->rep.compression); +} + +uint32_t rocksdb_subcompactionjobinfo_blob_compression_type( + const rocksdb_subcompactionjobinfo_t* info) { + return static_cast(info->rep.blob_compression_type); +} + +/* ExternalFileIngestionInfo */ + +const char* rocksdb_externalfileingestioninfo_cf_name( + const rocksdb_externalfileingestioninfo_t* info, size_t* size) { + *size = info->rep.cf_name.size(); + return info->rep.cf_name.data(); +} + +const char* rocksdb_externalfileingestioninfo_external_file_path( + const rocksdb_externalfileingestioninfo_t* info, size_t* size) { + *size = info->rep.external_file_path.size(); + return info->rep.external_file_path.data(); +} + +const char* rocksdb_externalfileingestioninfo_internal_file_path( + const rocksdb_externalfileingestioninfo_t* info, size_t* size) { + *size = info->rep.internal_file_path.size(); + return info->rep.internal_file_path.data(); +} + +uint64_t rocksdb_externalfileingestioninfo_global_seqno( + const rocksdb_externalfileingestioninfo_t* info) { + return info->rep.global_seqno; +} + +/* MemTableInfo */ + +const char* rocksdb_memtableinfo_cf_name(const rocksdb_memtableinfo_t* info, + size_t* size) { + *size = info->rep.cf_name.size(); + return info->rep.cf_name.data(); +} + +uint64_t rocksdb_memtableinfo_first_seqno(const rocksdb_memtableinfo_t* info) { + return info->rep.first_seqno; +} + +uint64_t rocksdb_memtableinfo_earliest_seqno( + const rocksdb_memtableinfo_t* info) { + return info->rep.earliest_seqno; +} + +uint64_t rocksdb_memtableinfo_num_entries(const rocksdb_memtableinfo_t* info) { + return info->rep.num_entries; +} + +uint64_t rocksdb_memtableinfo_num_deletes(const rocksdb_memtableinfo_t* info) { + return info->rep.num_deletes; +} + +const char* rocksdb_memtableinfo_newest_udt(const rocksdb_memtableinfo_t* info, + size_t* size) { + *size = info->rep.newest_udt.size(); + return info->rep.newest_udt.data(); +} diff --git a/c_api_gen/c_generated_jobinfo_auto.h.inc b/c_api_gen/c_generated_jobinfo_auto.h.inc new file mode 100644 index 0000000000..6a292ba18b --- /dev/null +++ b/c_api_gen/c_generated_jobinfo_auto.h.inc @@ -0,0 +1,173 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/listener.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered JobInfo metadata simple + +/* FlushJobInfo */ + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_flushjobinfo_cf_id(const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_flushjobinfo_cf_name( + const rocksdb_flushjobinfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_flushjobinfo_file_path( + const rocksdb_flushjobinfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_flushjobinfo_file_number(const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_flushjobinfo_oldest_blob_file_number( + const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_flushjobinfo_thread_id(const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_flushjobinfo_job_id( + const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_flushjobinfo_triggered_writes_slowdown( + const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_flushjobinfo_triggered_writes_stop(const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_flushjobinfo_smallest_seqno(const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_flushjobinfo_largest_seqno(const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_flushjobinfo_flush_reason(const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_flushjobinfo_blob_compression_type(const rocksdb_flushjobinfo_t* info); + +/* CompactionJobInfo */ + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_compactionjobinfo_cf_id(const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_compactionjobinfo_cf_name( + const rocksdb_compactionjobinfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API void rocksdb_compactionjobinfo_status( + const rocksdb_compactionjobinfo_t* info, char** errptr); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compactionjobinfo_thread_id(const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_job_id( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_num_l0_files( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_base_input_level( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_output_level( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t rocksdb_compactionjobinfo_compaction_reason( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_compactionjobinfo_compression(const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_compactionjobinfo_blob_compression_type( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_compactionjobinfo_aborted( + const rocksdb_compactionjobinfo_t* info); + +/* SubcompactionJobInfo */ + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_subcompactionjobinfo_cf_id(const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_subcompactionjobinfo_cf_name( + const rocksdb_subcompactionjobinfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API void rocksdb_subcompactionjobinfo_status( + const rocksdb_subcompactionjobinfo_t* info, char** errptr); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_subcompactionjobinfo_thread_id( + const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_subcompactionjobinfo_job_id( + const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int +rocksdb_subcompactionjobinfo_subcompaction_job_id( + const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_subcompactionjobinfo_base_input_level( + const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_subcompactionjobinfo_output_level( + const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_subcompactionjobinfo_compaction_reason( + const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t rocksdb_subcompactionjobinfo_compression( + const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_subcompactionjobinfo_blob_compression_type( + const rocksdb_subcompactionjobinfo_t* info); + +/* ExternalFileIngestionInfo */ + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_externalfileingestioninfo_cf_name( + const rocksdb_externalfileingestioninfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_externalfileingestioninfo_external_file_path( + const rocksdb_externalfileingestioninfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_externalfileingestioninfo_internal_file_path( + const rocksdb_externalfileingestioninfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_externalfileingestioninfo_global_seqno( + const rocksdb_externalfileingestioninfo_t* info); + +/* MemTableInfo */ + +extern ROCKSDB_LIBRARY_API const char* rocksdb_memtableinfo_cf_name( + const rocksdb_memtableinfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_memtableinfo_first_seqno(const rocksdb_memtableinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_memtableinfo_earliest_seqno(const rocksdb_memtableinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_memtableinfo_num_entries(const rocksdb_memtableinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_memtableinfo_num_deletes(const rocksdb_memtableinfo_t* info); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_memtableinfo_newest_udt( + const rocksdb_memtableinfo_t* info, size_t* size); diff --git a/c_api_gen/c_generated_jobinfo_metadata_subset.cc.inc b/c_api_gen/c_generated_jobinfo_metadata_subset.cc.inc new file mode 100644 index 0000000000..31209c1865 --- /dev/null +++ b/c_api_gen/c_generated_jobinfo_metadata_subset.cc.inc @@ -0,0 +1,84 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'JobInfo metadata simple' +// --header-out +// c_api_gen/c_generated_jobinfo_metadata_subset.h.inc +// --source-out +// c_api_gen/c_generated_jobinfo_metadata_subset.cc.inc + +/* JobInfo metadata simple */ + +size_t rocksdb_compactionjobinfo_input_files_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.input_files.size(); +} + +size_t rocksdb_compactionjobinfo_output_files_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.output_files.size(); +} + +uint64_t rocksdb_compactionjobinfo_elapsed_micros( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.elapsed_micros; +} + +uint64_t rocksdb_compactionjobinfo_num_corrupt_keys( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.num_corrupt_keys; +} + +uint64_t rocksdb_compactionjobinfo_input_records( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.num_input_records; +} + +uint64_t rocksdb_compactionjobinfo_output_records( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.num_output_records; +} + +uint64_t rocksdb_compactionjobinfo_total_input_bytes( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.total_input_bytes; +} + +uint64_t rocksdb_compactionjobinfo_total_output_bytes( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.total_output_bytes; +} + +size_t rocksdb_compactionjobinfo_num_input_files( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.num_input_files; +} + +size_t rocksdb_compactionjobinfo_num_input_files_at_output_level( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.num_input_files_at_output_level; +} + +const char* rocksdb_writestallinfo_cf_name(const rocksdb_writestallinfo_t* info, + size_t* size) { + *size = info->rep.cf_name.size(); + return info->rep.cf_name.data(); +} + +const rocksdb_writestallcondition_t* rocksdb_writestallinfo_cur( + const rocksdb_writestallinfo_t* info) { + return reinterpret_cast( + &info->rep.condition.cur); +} + +const rocksdb_writestallcondition_t* rocksdb_writestallinfo_prev( + const rocksdb_writestallinfo_t* info) { + return reinterpret_cast( + &info->rep.condition.prev); +} diff --git a/c_api_gen/c_generated_jobinfo_metadata_subset.h.inc b/c_api_gen/c_generated_jobinfo_metadata_subset.h.inc new file mode 100644 index 0000000000..c789772bd3 --- /dev/null +++ b/c_api_gen/c_generated_jobinfo_metadata_subset.h.inc @@ -0,0 +1,57 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'JobInfo metadata simple' +// --header-out +// c_api_gen/c_generated_jobinfo_metadata_subset.h.inc +// --source-out +// c_api_gen/c_generated_jobinfo_metadata_subset.cc.inc + +/* JobInfo metadata simple */ + +extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_input_files_count( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_output_files_count( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_elapsed_micros( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_num_corrupt_keys( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_input_records( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_output_records( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_total_input_bytes( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compactionjobinfo_total_output_bytes( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_num_input_files( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_num_input_files_at_output_level( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_writestallinfo_cf_name( + const rocksdb_writestallinfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API const rocksdb_writestallcondition_t* +rocksdb_writestallinfo_cur(const rocksdb_writestallinfo_t* info); + +extern ROCKSDB_LIBRARY_API const rocksdb_writestallcondition_t* +rocksdb_writestallinfo_prev(const rocksdb_writestallinfo_t* info); diff --git a/c_api_gen/c_generated_metadata_structs_auto.cc.inc b/c_api_gen/c_generated_metadata_structs_auto.cc.inc new file mode 100644 index 0000000000..e94d76b5da --- /dev/null +++ b/c_api_gen/c_generated_metadata_structs_auto.cc.inc @@ -0,0 +1,501 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/compaction_job_stats.h +// - include/rocksdb/listener.h +// - include/rocksdb/table_properties.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered metadata view structs simple + +/* TableProperties */ + +uint64_t rocksdb_table_properties_orig_file_number( + const rocksdb_table_properties_t* props) { + return props->rep.orig_file_number; +} + +uint64_t rocksdb_table_properties_data_size( + const rocksdb_table_properties_t* props) { + return props->rep.data_size; +} + +uint64_t rocksdb_table_properties_uncompressed_data_size( + const rocksdb_table_properties_t* props) { + return props->rep.uncompressed_data_size; +} + +uint64_t rocksdb_table_properties_index_size( + const rocksdb_table_properties_t* props) { + return props->rep.index_size; +} + +uint64_t rocksdb_table_properties_index_partitions( + const rocksdb_table_properties_t* props) { + return props->rep.index_partitions; +} + +uint64_t rocksdb_table_properties_top_level_index_size( + const rocksdb_table_properties_t* props) { + return props->rep.top_level_index_size; +} + +uint64_t rocksdb_table_properties_index_key_is_user_key( + const rocksdb_table_properties_t* props) { + return props->rep.index_key_is_user_key; +} + +uint64_t rocksdb_table_properties_index_value_is_delta_encoded( + const rocksdb_table_properties_t* props) { + return props->rep.index_value_is_delta_encoded; +} + +uint64_t rocksdb_table_properties_udi_is_primary_index( + const rocksdb_table_properties_t* props) { + return props->rep.udi_is_primary_index; +} + +uint64_t rocksdb_table_properties_filter_size( + const rocksdb_table_properties_t* props) { + return props->rep.filter_size; +} + +uint64_t rocksdb_table_properties_raw_key_size( + const rocksdb_table_properties_t* props) { + return props->rep.raw_key_size; +} + +uint64_t rocksdb_table_properties_raw_value_size( + const rocksdb_table_properties_t* props) { + return props->rep.raw_value_size; +} + +uint64_t rocksdb_table_properties_num_data_blocks( + const rocksdb_table_properties_t* props) { + return props->rep.num_data_blocks; +} + +uint64_t rocksdb_table_properties_num_data_blocks_compression_rejected( + const rocksdb_table_properties_t* props) { + return props->rep.num_data_blocks_compression_rejected; +} + +uint64_t rocksdb_table_properties_num_data_blocks_compression_bypassed( + const rocksdb_table_properties_t* props) { + return props->rep.num_data_blocks_compression_bypassed; +} + +uint64_t rocksdb_table_properties_num_uniform_blocks( + const rocksdb_table_properties_t* props) { + return props->rep.num_uniform_blocks; +} + +uint64_t rocksdb_table_properties_num_entries( + const rocksdb_table_properties_t* props) { + return props->rep.num_entries; +} + +uint64_t rocksdb_table_properties_num_filter_entries( + const rocksdb_table_properties_t* props) { + return props->rep.num_filter_entries; +} + +uint64_t rocksdb_table_properties_num_deletions( + const rocksdb_table_properties_t* props) { + return props->rep.num_deletions; +} + +uint64_t rocksdb_table_properties_num_merge_operands( + const rocksdb_table_properties_t* props) { + return props->rep.num_merge_operands; +} + +uint64_t rocksdb_table_properties_num_range_deletions( + const rocksdb_table_properties_t* props) { + return props->rep.num_range_deletions; +} + +uint64_t rocksdb_table_properties_format_version( + const rocksdb_table_properties_t* props) { + return props->rep.format_version; +} + +uint64_t rocksdb_table_properties_fixed_key_len( + const rocksdb_table_properties_t* props) { + return props->rep.fixed_key_len; +} + +uint64_t rocksdb_table_properties_column_family_id( + const rocksdb_table_properties_t* props) { + return props->rep.column_family_id; +} + +uint64_t rocksdb_table_properties_creation_time( + const rocksdb_table_properties_t* props) { + return props->rep.creation_time; +} + +uint64_t rocksdb_table_properties_oldest_key_time( + const rocksdb_table_properties_t* props) { + return props->rep.oldest_key_time; +} + +uint64_t rocksdb_table_properties_newest_key_time( + const rocksdb_table_properties_t* props) { + return props->rep.newest_key_time; +} + +uint64_t rocksdb_table_properties_file_creation_time( + const rocksdb_table_properties_t* props) { + return props->rep.file_creation_time; +} + +uint64_t rocksdb_table_properties_slow_compression_estimated_data_size( + const rocksdb_table_properties_t* props) { + return props->rep.slow_compression_estimated_data_size; +} + +uint64_t rocksdb_table_properties_fast_compression_estimated_data_size( + const rocksdb_table_properties_t* props) { + return props->rep.fast_compression_estimated_data_size; +} + +uint64_t rocksdb_table_properties_external_sst_file_global_seqno_offset( + const rocksdb_table_properties_t* props) { + return props->rep.external_sst_file_global_seqno_offset; +} + +uint64_t rocksdb_table_properties_tail_start_offset( + const rocksdb_table_properties_t* props) { + return props->rep.tail_start_offset; +} + +uint64_t rocksdb_table_properties_user_defined_timestamps_persisted( + const rocksdb_table_properties_t* props) { + return props->rep.user_defined_timestamps_persisted; +} + +uint64_t rocksdb_table_properties_key_largest_seqno( + const rocksdb_table_properties_t* props) { + return props->rep.key_largest_seqno; +} + +uint64_t rocksdb_table_properties_key_smallest_seqno( + const rocksdb_table_properties_t* props) { + return props->rep.key_smallest_seqno; +} + +uint64_t rocksdb_table_properties_data_block_restart_interval( + const rocksdb_table_properties_t* props) { + return props->rep.data_block_restart_interval; +} + +uint64_t rocksdb_table_properties_index_block_restart_interval( + const rocksdb_table_properties_t* props) { + return props->rep.index_block_restart_interval; +} + +uint64_t rocksdb_table_properties_separate_key_value_in_data_block( + const rocksdb_table_properties_t* props) { + return props->rep.separate_key_value_in_data_block; +} + +const char* rocksdb_table_properties_db_id( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.db_id.size(); + return props->rep.db_id.data(); +} + +const char* rocksdb_table_properties_db_session_id( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.db_session_id.size(); + return props->rep.db_session_id.data(); +} + +const char* rocksdb_table_properties_db_host_id( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.db_host_id.size(); + return props->rep.db_host_id.data(); +} + +const char* rocksdb_table_properties_column_family_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.column_family_name.size(); + return props->rep.column_family_name.data(); +} + +const char* rocksdb_table_properties_filter_policy_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.filter_policy_name.size(); + return props->rep.filter_policy_name.data(); +} + +const char* rocksdb_table_properties_comparator_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.comparator_name.size(); + return props->rep.comparator_name.data(); +} + +const char* rocksdb_table_properties_merge_operator_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.merge_operator_name.size(); + return props->rep.merge_operator_name.data(); +} + +const char* rocksdb_table_properties_prefix_extractor_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.prefix_extractor_name.size(); + return props->rep.prefix_extractor_name.data(); +} + +const char* rocksdb_table_properties_property_collectors_names( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.property_collectors_names.size(); + return props->rep.property_collectors_names.data(); +} + +const char* rocksdb_table_properties_compression_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.compression_name.size(); + return props->rep.compression_name.data(); +} + +const char* rocksdb_table_properties_compression_options( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.compression_options.size(); + return props->rep.compression_options.data(); +} + +const char* rocksdb_table_properties_seqno_to_time_mapping( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.seqno_to_time_mapping.size(); + return props->rep.seqno_to_time_mapping.data(); +} + +/* CompactionJobStats */ + +uint64_t rocksdb_compaction_job_stats_elapsed_micros( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.elapsed_micros; +} + +uint64_t rocksdb_compaction_job_stats_cpu_micros( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.cpu_micros; +} + +unsigned char rocksdb_compaction_job_stats_has_accurate_num_input_records( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.has_accurate_num_input_records; +} + +uint64_t rocksdb_compaction_job_stats_num_input_records( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_input_records; +} + +uint64_t rocksdb_compaction_job_stats_num_blobs_read( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_blobs_read; +} + +size_t rocksdb_compaction_job_stats_num_input_files( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_input_files; +} + +size_t rocksdb_compaction_job_stats_num_input_files_trivially_moved( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_input_files_trivially_moved; +} + +size_t rocksdb_compaction_job_stats_num_input_files_at_output_level( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_input_files_at_output_level; +} + +size_t rocksdb_compaction_job_stats_num_filtered_input_files( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_filtered_input_files; +} + +size_t rocksdb_compaction_job_stats_num_filtered_input_files_at_output_level( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_filtered_input_files_at_output_level; +} + +uint64_t rocksdb_compaction_job_stats_num_output_records( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_output_records; +} + +size_t rocksdb_compaction_job_stats_num_output_files( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_output_files; +} + +size_t rocksdb_compaction_job_stats_num_output_files_blob( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_output_files_blob; +} + +unsigned char rocksdb_compaction_job_stats_is_full_compaction( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.is_full_compaction; +} + +unsigned char rocksdb_compaction_job_stats_is_manual_compaction( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.is_manual_compaction; +} + +unsigned char rocksdb_compaction_job_stats_is_remote_compaction( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.is_remote_compaction; +} + +uint64_t rocksdb_compaction_job_stats_total_input_bytes( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_input_bytes; +} + +uint64_t rocksdb_compaction_job_stats_total_blob_bytes_read( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_blob_bytes_read; +} + +uint64_t rocksdb_compaction_job_stats_total_output_bytes( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_output_bytes; +} + +uint64_t rocksdb_compaction_job_stats_total_output_bytes_blob( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_output_bytes_blob; +} + +uint64_t rocksdb_compaction_job_stats_total_skipped_input_bytes( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_skipped_input_bytes; +} + +uint64_t rocksdb_compaction_job_stats_num_records_replaced( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_records_replaced; +} + +uint64_t rocksdb_compaction_job_stats_total_input_raw_key_bytes( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_input_raw_key_bytes; +} + +uint64_t rocksdb_compaction_job_stats_total_input_raw_value_bytes( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_input_raw_value_bytes; +} + +uint64_t rocksdb_compaction_job_stats_num_input_deletion_records( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_input_deletion_records; +} + +uint64_t rocksdb_compaction_job_stats_num_expired_deletion_records( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_expired_deletion_records; +} + +uint64_t rocksdb_compaction_job_stats_num_corrupt_keys( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_corrupt_keys; +} + +uint64_t rocksdb_compaction_job_stats_file_write_nanos( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.file_write_nanos; +} + +uint64_t rocksdb_compaction_job_stats_file_range_sync_nanos( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.file_range_sync_nanos; +} + +uint64_t rocksdb_compaction_job_stats_file_fsync_nanos( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.file_fsync_nanos; +} + +uint64_t rocksdb_compaction_job_stats_file_prepare_write_nanos( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.file_prepare_write_nanos; +} + +const char* rocksdb_compaction_job_stats_smallest_output_key_prefix( + const rocksdb_compaction_job_stats_t* stats, size_t* size) { + *size = stats->rep.smallest_output_key_prefix.size(); + return stats->rep.smallest_output_key_prefix.data(); +} + +const char* rocksdb_compaction_job_stats_largest_output_key_prefix( + const rocksdb_compaction_job_stats_t* stats, size_t* size) { + *size = stats->rep.largest_output_key_prefix.size(); + return stats->rep.largest_output_key_prefix.data(); +} + +uint64_t rocksdb_compaction_job_stats_num_single_del_fallthru( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_single_del_fallthru; +} + +uint64_t rocksdb_compaction_job_stats_num_single_del_mismatch( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_single_del_mismatch; +} + +/* CompactionFileInfo */ + +int rocksdb_compaction_file_info_level( + const rocksdb_compaction_file_info_t* info) { + return info->rep.level; +} + +uint64_t rocksdb_compaction_file_info_file_number( + const rocksdb_compaction_file_info_t* info) { + return info->rep.file_number; +} + +uint64_t rocksdb_compaction_file_info_oldest_blob_file_number( + const rocksdb_compaction_file_info_t* info) { + return info->rep.oldest_blob_file_number; +} + +/* BlobFileAdditionInfo */ + +uint64_t rocksdb_blob_file_addition_info_total_blob_count( + const rocksdb_blob_file_addition_info_t* info) { + return info->rep.total_blob_count; +} + +uint64_t rocksdb_blob_file_addition_info_total_blob_bytes( + const rocksdb_blob_file_addition_info_t* info) { + return info->rep.total_blob_bytes; +} + +/* BlobFileGarbageInfo */ + +uint64_t rocksdb_blob_file_garbage_info_garbage_blob_count( + const rocksdb_blob_file_garbage_info_t* info) { + return info->rep.garbage_blob_count; +} + +uint64_t rocksdb_blob_file_garbage_info_garbage_blob_bytes( + const rocksdb_blob_file_garbage_info_t* info) { + return info->rep.garbage_blob_bytes; +} diff --git a/c_api_gen/c_generated_metadata_structs_auto.h.inc b/c_api_gen/c_generated_metadata_structs_auto.h.inc new file mode 100644 index 0000000000..838c26ab96 --- /dev/null +++ b/c_api_gen/c_generated_metadata_structs_auto.h.inc @@ -0,0 +1,361 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/compaction_job_stats.h +// - include/rocksdb/listener.h +// - include/rocksdb/table_properties.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered metadata view structs simple + +/* TableProperties */ + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_orig_file_number( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_data_size(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_uncompressed_data_size( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_index_size(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_index_partitions( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_top_level_index_size( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_index_key_is_user_key( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_index_value_is_delta_encoded( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_udi_is_primary_index( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_filter_size(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_raw_key_size(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_raw_value_size( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_data_blocks( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_num_data_blocks_compression_rejected( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_num_data_blocks_compression_bypassed( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_uniform_blocks( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_num_entries(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_filter_entries( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_num_deletions(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_merge_operands( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_num_range_deletions( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_format_version( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_fixed_key_len(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_column_family_id( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_creation_time(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_oldest_key_time( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_newest_key_time( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_file_creation_time( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_slow_compression_estimated_data_size( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_fast_compression_estimated_data_size( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_external_sst_file_global_seqno_offset( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_tail_start_offset( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_user_defined_timestamps_persisted( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_key_largest_seqno( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_key_smallest_seqno( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_data_block_restart_interval( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_index_block_restart_interval( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_separate_key_value_in_data_block( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_db_id( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_db_session_id( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_db_host_id( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_column_family_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_filter_policy_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_comparator_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_merge_operator_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_prefix_extractor_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_property_collectors_names( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_compression_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_compression_options( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_seqno_to_time_mapping( + const rocksdb_table_properties_t* props, size_t* size); + +/* CompactionJobStats */ + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_job_stats_elapsed_micros( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_job_stats_cpu_micros( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compaction_job_stats_has_accurate_num_input_records( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_input_records( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_job_stats_num_blobs_read( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_compaction_job_stats_num_input_files( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compaction_job_stats_num_input_files_trivially_moved( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compaction_job_stats_num_input_files_at_output_level( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compaction_job_stats_num_filtered_input_files( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compaction_job_stats_num_filtered_input_files_at_output_level( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_output_records( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_compaction_job_stats_num_output_files( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compaction_job_stats_num_output_files_blob( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compaction_job_stats_is_full_compaction( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compaction_job_stats_is_manual_compaction( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compaction_job_stats_is_remote_compaction( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_input_bytes( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_blob_bytes_read( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_output_bytes( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_output_bytes_blob( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_skipped_input_bytes( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_records_replaced( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_input_raw_key_bytes( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_input_raw_value_bytes( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_input_deletion_records( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_expired_deletion_records( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_corrupt_keys( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_file_write_nanos( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_file_range_sync_nanos( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_file_fsync_nanos( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_file_prepare_write_nanos( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compaction_job_stats_smallest_output_key_prefix( + const rocksdb_compaction_job_stats_t* stats, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compaction_job_stats_largest_output_key_prefix( + const rocksdb_compaction_job_stats_t* stats, size_t* size); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_single_del_fallthru( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_single_del_mismatch( + const rocksdb_compaction_job_stats_t* stats); + +/* CompactionFileInfo */ + +extern ROCKSDB_LIBRARY_API int rocksdb_compaction_file_info_level( + const rocksdb_compaction_file_info_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_file_info_file_number( + const rocksdb_compaction_file_info_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_file_info_oldest_blob_file_number( + const rocksdb_compaction_file_info_t* info); + +/* BlobFileAdditionInfo */ + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_blob_file_addition_info_total_blob_count( + const rocksdb_blob_file_addition_info_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_blob_file_addition_info_total_blob_bytes( + const rocksdb_blob_file_addition_info_t* info); + +/* BlobFileGarbageInfo */ + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_blob_file_garbage_info_garbage_blob_count( + const rocksdb_blob_file_garbage_info_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_blob_file_garbage_info_garbage_blob_bytes( + const rocksdb_blob_file_garbage_info_t* info); diff --git a/c_api_gen/c_generated_option_structs_auto.cc.inc b/c_api_gen/c_generated_option_structs_auto.cc.inc new file mode 100644 index 0000000000..366f5415ee --- /dev/null +++ b/c_api_gen/c_generated_option_structs_auto.cc.inc @@ -0,0 +1,3231 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/advanced_options.h +// - include/rocksdb/block_cache_trace_writer.h +// - include/rocksdb/env.h +// - include/rocksdb/metadata.h +// - include/rocksdb/options.h +// - include/rocksdb/table.h +// - include/rocksdb/universal_compaction.h +// - include/rocksdb/utilities/backup_engine.h +// - include/rocksdb/utilities/optimistic_transaction_db.h +// - include/rocksdb/utilities/transaction_db.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered option structs simple + +/* DBOptions */ + +void rocksdb_options_set_create_if_missing(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.create_if_missing = v; +} + +unsigned char rocksdb_options_get_create_if_missing(rocksdb_options_t* opt) { + return opt->rep.create_if_missing; +} + +void rocksdb_options_set_create_missing_column_families(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.create_missing_column_families = v; +} + +unsigned char rocksdb_options_get_create_missing_column_families( + rocksdb_options_t* opt) { + return opt->rep.create_missing_column_families; +} + +void rocksdb_options_set_error_if_exists(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.error_if_exists = v; +} + +unsigned char rocksdb_options_get_error_if_exists(rocksdb_options_t* opt) { + return opt->rep.error_if_exists; +} + +void rocksdb_options_set_paranoid_checks(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.paranoid_checks = v; +} + +unsigned char rocksdb_options_get_paranoid_checks(rocksdb_options_t* opt) { + return opt->rep.paranoid_checks; +} + +void rocksdb_options_set_flush_verify_memtable_count(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.flush_verify_memtable_count = v; +} + +unsigned char rocksdb_options_get_flush_verify_memtable_count( + rocksdb_options_t* opt) { + return opt->rep.flush_verify_memtable_count; +} + +void rocksdb_options_set_compaction_verify_record_count(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.compaction_verify_record_count = v; +} + +unsigned char rocksdb_options_get_compaction_verify_record_count( + rocksdb_options_t* opt) { + return opt->rep.compaction_verify_record_count; +} + +void rocksdb_options_set_track_and_verify_wals_in_manifest( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.track_and_verify_wals_in_manifest = v; +} + +unsigned char rocksdb_options_get_track_and_verify_wals_in_manifest( + rocksdb_options_t* opt) { + return opt->rep.track_and_verify_wals_in_manifest; +} + +void rocksdb_options_set_track_and_verify_wals(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.track_and_verify_wals = v; +} + +unsigned char rocksdb_options_get_track_and_verify_wals( + rocksdb_options_t* opt) { + return opt->rep.track_and_verify_wals; +} + +void rocksdb_options_set_verify_sst_unique_id_in_manifest( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.verify_sst_unique_id_in_manifest = v; +} + +unsigned char rocksdb_options_get_verify_sst_unique_id_in_manifest( + rocksdb_options_t* opt) { + return opt->rep.verify_sst_unique_id_in_manifest; +} + +void rocksdb_options_set_info_log_level(rocksdb_options_t* opt, int v) { + opt->rep.info_log_level = static_castrep.info_log_level)>(v); +} + +int rocksdb_options_get_info_log_level(rocksdb_options_t* opt) { + return static_cast(opt->rep.info_log_level); +} + +void rocksdb_options_set_max_open_files(rocksdb_options_t* opt, int v) { + opt->rep.max_open_files = v; +} + +int rocksdb_options_get_max_open_files(rocksdb_options_t* opt) { + return opt->rep.max_open_files; +} + +void rocksdb_options_set_max_file_opening_threads(rocksdb_options_t* opt, + int v) { + opt->rep.max_file_opening_threads = v; +} + +int rocksdb_options_get_max_file_opening_threads(rocksdb_options_t* opt) { + return opt->rep.max_file_opening_threads; +} + +void rocksdb_options_set_open_files_async(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.open_files_async = v; +} + +unsigned char rocksdb_options_get_open_files_async(rocksdb_options_t* opt) { + return opt->rep.open_files_async; +} + +void rocksdb_options_set_max_total_wal_size(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.max_total_wal_size = v; +} + +uint64_t rocksdb_options_get_max_total_wal_size(rocksdb_options_t* opt) { + return opt->rep.max_total_wal_size; +} + +void rocksdb_options_set_db_log_dir(rocksdb_options_t* opt, const char* v) { + opt->rep.db_log_dir = v; +} + +const char* rocksdb_options_get_db_log_dir(rocksdb_options_t* opt, + size_t* size) { + *size = opt->rep.db_log_dir.size(); + return opt->rep.db_log_dir.data(); +} + +void rocksdb_options_set_wal_dir(rocksdb_options_t* opt, const char* v) { + opt->rep.wal_dir = v; +} + +const char* rocksdb_options_get_wal_dir(rocksdb_options_t* opt, size_t* size) { + *size = opt->rep.wal_dir.size(); + return opt->rep.wal_dir.data(); +} + +void rocksdb_options_set_delete_obsolete_files_period_micros( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.delete_obsolete_files_period_micros = v; +} + +uint64_t rocksdb_options_get_delete_obsolete_files_period_micros( + rocksdb_options_t* opt) { + return opt->rep.delete_obsolete_files_period_micros; +} + +void rocksdb_options_set_max_background_jobs(rocksdb_options_t* opt, int v) { + opt->rep.max_background_jobs = v; +} + +int rocksdb_options_get_max_background_jobs(rocksdb_options_t* opt) { + return opt->rep.max_background_jobs; +} + +void rocksdb_options_set_max_background_compactions(rocksdb_options_t* opt, + int v) { + opt->rep.max_background_compactions = v; +} + +int rocksdb_options_get_max_background_compactions(rocksdb_options_t* opt) { + return opt->rep.max_background_compactions; +} + +void rocksdb_options_set_max_subcompactions(rocksdb_options_t* opt, + uint32_t v) { + opt->rep.max_subcompactions = v; +} + +uint32_t rocksdb_options_get_max_subcompactions(rocksdb_options_t* opt) { + return opt->rep.max_subcompactions; +} + +void rocksdb_options_set_max_background_flushes(rocksdb_options_t* opt, int v) { + opt->rep.max_background_flushes = v; +} + +int rocksdb_options_get_max_background_flushes(rocksdb_options_t* opt) { + return opt->rep.max_background_flushes; +} + +void rocksdb_options_set_max_log_file_size(rocksdb_options_t* opt, size_t v) { + opt->rep.max_log_file_size = v; +} + +size_t rocksdb_options_get_max_log_file_size(rocksdb_options_t* opt) { + return opt->rep.max_log_file_size; +} + +void rocksdb_options_set_log_file_time_to_roll(rocksdb_options_t* opt, + size_t v) { + opt->rep.log_file_time_to_roll = v; +} + +size_t rocksdb_options_get_log_file_time_to_roll(rocksdb_options_t* opt) { + return opt->rep.log_file_time_to_roll; +} + +void rocksdb_options_set_keep_log_file_num(rocksdb_options_t* opt, size_t v) { + opt->rep.keep_log_file_num = v; +} + +size_t rocksdb_options_get_keep_log_file_num(rocksdb_options_t* opt) { + return opt->rep.keep_log_file_num; +} + +void rocksdb_options_set_recycle_log_file_num(rocksdb_options_t* opt, + size_t v) { + opt->rep.recycle_log_file_num = v; +} + +size_t rocksdb_options_get_recycle_log_file_num(rocksdb_options_t* opt) { + return opt->rep.recycle_log_file_num; +} + +void rocksdb_options_set_async_wal_precreate(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.async_wal_precreate = v; +} + +unsigned char rocksdb_options_get_async_wal_precreate(rocksdb_options_t* opt) { + return opt->rep.async_wal_precreate; +} + +void rocksdb_options_set_verify_manifest_content_on_close( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.verify_manifest_content_on_close = v; +} + +unsigned char rocksdb_options_get_verify_manifest_content_on_close( + rocksdb_options_t* opt) { + return opt->rep.verify_manifest_content_on_close; +} + +void rocksdb_options_set_optimize_manifest_for_recovery(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.optimize_manifest_for_recovery = v; +} + +unsigned char rocksdb_options_get_optimize_manifest_for_recovery( + rocksdb_options_t* opt) { + return opt->rep.optimize_manifest_for_recovery; +} + +void rocksdb_options_set_reuse_manifest_on_open(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.reuse_manifest_on_open = v; +} + +unsigned char rocksdb_options_get_reuse_manifest_on_open( + rocksdb_options_t* opt) { + return opt->rep.reuse_manifest_on_open; +} + +void rocksdb_options_set_max_manifest_space_amp_pct(rocksdb_options_t* opt, + int v) { + opt->rep.max_manifest_space_amp_pct = v; +} + +int rocksdb_options_get_max_manifest_space_amp_pct(rocksdb_options_t* opt) { + return opt->rep.max_manifest_space_amp_pct; +} + +void rocksdb_options_set_table_cache_numshardbits(rocksdb_options_t* opt, + int v) { + opt->rep.table_cache_numshardbits = v; +} + +int rocksdb_options_get_table_cache_numshardbits(rocksdb_options_t* opt) { + return opt->rep.table_cache_numshardbits; +} + +void rocksdb_options_set_WAL_ttl_seconds(rocksdb_options_t* opt, uint64_t v) { + opt->rep.WAL_ttl_seconds = v; +} + +uint64_t rocksdb_options_get_WAL_ttl_seconds(rocksdb_options_t* opt) { + return opt->rep.WAL_ttl_seconds; +} + +void rocksdb_options_set_WAL_size_limit_MB(rocksdb_options_t* opt, uint64_t v) { + opt->rep.WAL_size_limit_MB = v; +} + +uint64_t rocksdb_options_get_WAL_size_limit_MB(rocksdb_options_t* opt) { + return opt->rep.WAL_size_limit_MB; +} + +void rocksdb_options_set_manifest_preallocation_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.manifest_preallocation_size = v; +} + +size_t rocksdb_options_get_manifest_preallocation_size(rocksdb_options_t* opt) { + return opt->rep.manifest_preallocation_size; +} + +void rocksdb_options_set_allow_mmap_reads(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_mmap_reads = v; +} + +unsigned char rocksdb_options_get_allow_mmap_reads(rocksdb_options_t* opt) { + return opt->rep.allow_mmap_reads; +} + +void rocksdb_options_set_allow_mmap_writes(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_mmap_writes = v; +} + +unsigned char rocksdb_options_get_allow_mmap_writes(rocksdb_options_t* opt) { + return opt->rep.allow_mmap_writes; +} + +void rocksdb_options_set_use_direct_reads(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.use_direct_reads = v; +} + +unsigned char rocksdb_options_get_use_direct_reads(rocksdb_options_t* opt) { + return opt->rep.use_direct_reads; +} + +void rocksdb_options_set_use_direct_io_for_compaction_reads( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.use_direct_io_for_compaction_reads = v; +} + +unsigned char rocksdb_options_get_use_direct_io_for_compaction_reads( + rocksdb_options_t* opt) { + return opt->rep.use_direct_io_for_compaction_reads; +} + +void rocksdb_options_set_use_direct_io_for_flush_and_compaction( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.use_direct_io_for_flush_and_compaction = v; +} + +unsigned char rocksdb_options_get_use_direct_io_for_flush_and_compaction( + rocksdb_options_t* opt) { + return opt->rep.use_direct_io_for_flush_and_compaction; +} + +void rocksdb_options_set_allow_fallocate(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_fallocate = v; +} + +unsigned char rocksdb_options_get_allow_fallocate(rocksdb_options_t* opt) { + return opt->rep.allow_fallocate; +} + +void rocksdb_options_set_is_fd_close_on_exec(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.is_fd_close_on_exec = v; +} + +unsigned char rocksdb_options_get_is_fd_close_on_exec(rocksdb_options_t* opt) { + return opt->rep.is_fd_close_on_exec; +} + +void rocksdb_options_set_stats_dump_period_sec(rocksdb_options_t* opt, + unsigned int v) { + opt->rep.stats_dump_period_sec = v; +} + +unsigned int rocksdb_options_get_stats_dump_period_sec(rocksdb_options_t* opt) { + return opt->rep.stats_dump_period_sec; +} + +void rocksdb_options_set_stats_persist_period_sec(rocksdb_options_t* opt, + unsigned int v) { + opt->rep.stats_persist_period_sec = v; +} + +unsigned int rocksdb_options_get_stats_persist_period_sec( + rocksdb_options_t* opt) { + return opt->rep.stats_persist_period_sec; +} + +void rocksdb_options_set_persist_stats_to_disk(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.persist_stats_to_disk = v; +} + +unsigned char rocksdb_options_get_persist_stats_to_disk( + rocksdb_options_t* opt) { + return opt->rep.persist_stats_to_disk; +} + +void rocksdb_options_set_stats_history_buffer_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.stats_history_buffer_size = v; +} + +size_t rocksdb_options_get_stats_history_buffer_size(rocksdb_options_t* opt) { + return opt->rep.stats_history_buffer_size; +} + +void rocksdb_options_set_advise_random_on_open(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.advise_random_on_open = v; +} + +unsigned char rocksdb_options_get_advise_random_on_open( + rocksdb_options_t* opt) { + return opt->rep.advise_random_on_open; +} + +void rocksdb_options_set_db_write_buffer_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.db_write_buffer_size = v; +} + +size_t rocksdb_options_get_db_write_buffer_size(rocksdb_options_t* opt) { + return opt->rep.db_write_buffer_size; +} + +void rocksdb_options_compaction_readahead_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.compaction_readahead_size = v; +} + +size_t rocksdb_options_get_compaction_readahead_size(rocksdb_options_t* opt) { + return opt->rep.compaction_readahead_size; +} + +void rocksdb_options_set_use_adaptive_mutex(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.use_adaptive_mutex = v; +} + +unsigned char rocksdb_options_get_use_adaptive_mutex(rocksdb_options_t* opt) { + return opt->rep.use_adaptive_mutex; +} + +void rocksdb_options_set_bytes_per_sync(rocksdb_options_t* opt, uint64_t v) { + opt->rep.bytes_per_sync = v; +} + +uint64_t rocksdb_options_get_bytes_per_sync(rocksdb_options_t* opt) { + return opt->rep.bytes_per_sync; +} + +void rocksdb_options_set_wal_bytes_per_sync(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.wal_bytes_per_sync = v; +} + +uint64_t rocksdb_options_get_wal_bytes_per_sync(rocksdb_options_t* opt) { + return opt->rep.wal_bytes_per_sync; +} + +void rocksdb_options_set_strict_bytes_per_sync(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.strict_bytes_per_sync = v; +} + +unsigned char rocksdb_options_get_strict_bytes_per_sync( + rocksdb_options_t* opt) { + return opt->rep.strict_bytes_per_sync; +} + +void rocksdb_options_set_enable_thread_tracking(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enable_thread_tracking = v; +} + +unsigned char rocksdb_options_get_enable_thread_tracking( + rocksdb_options_t* opt) { + return opt->rep.enable_thread_tracking; +} + +void rocksdb_options_set_delayed_write_rate(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.delayed_write_rate = v; +} + +uint64_t rocksdb_options_get_delayed_write_rate(rocksdb_options_t* opt) { + return opt->rep.delayed_write_rate; +} + +void rocksdb_options_set_enable_pipelined_write(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enable_pipelined_write = v; +} + +unsigned char rocksdb_options_get_enable_pipelined_write( + rocksdb_options_t* opt) { + return opt->rep.enable_pipelined_write; +} + +void rocksdb_options_set_unordered_write(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.unordered_write = v; +} + +unsigned char rocksdb_options_get_unordered_write(rocksdb_options_t* opt) { + return opt->rep.unordered_write; +} + +void rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_concurrent_memtable_write = v; +} + +unsigned char rocksdb_options_get_allow_concurrent_memtable_write( + rocksdb_options_t* opt) { + return opt->rep.allow_concurrent_memtable_write; +} + +void rocksdb_options_set_enable_write_thread_adaptive_yield( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.enable_write_thread_adaptive_yield = v; +} + +unsigned char rocksdb_options_get_enable_write_thread_adaptive_yield( + rocksdb_options_t* opt) { + return opt->rep.enable_write_thread_adaptive_yield; +} + +void rocksdb_options_set_max_write_batch_group_size_bytes( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.max_write_batch_group_size_bytes = v; +} + +uint64_t rocksdb_options_get_max_write_batch_group_size_bytes( + rocksdb_options_t* opt) { + return opt->rep.max_write_batch_group_size_bytes; +} + +void rocksdb_options_set_write_thread_max_yield_usec(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.write_thread_max_yield_usec = v; +} + +uint64_t rocksdb_options_get_write_thread_max_yield_usec( + rocksdb_options_t* opt) { + return opt->rep.write_thread_max_yield_usec; +} + +void rocksdb_options_set_write_thread_slow_yield_usec(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.write_thread_slow_yield_usec = v; +} + +uint64_t rocksdb_options_get_write_thread_slow_yield_usec( + rocksdb_options_t* opt) { + return opt->rep.write_thread_slow_yield_usec; +} + +void rocksdb_options_set_skip_stats_update_on_db_open(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.skip_stats_update_on_db_open = v; +} + +unsigned char rocksdb_options_get_skip_stats_update_on_db_open( + rocksdb_options_t* opt) { + return opt->rep.skip_stats_update_on_db_open; +} + +void rocksdb_options_set_wal_recovery_mode(rocksdb_options_t* opt, int v) { + opt->rep.wal_recovery_mode = + static_castrep.wal_recovery_mode)>(v); +} + +int rocksdb_options_get_wal_recovery_mode(rocksdb_options_t* opt) { + return static_cast(opt->rep.wal_recovery_mode); +} + +void rocksdb_options_set_allow_2pc(rocksdb_options_t* opt, unsigned char v) { + opt->rep.allow_2pc = v; +} + +unsigned char rocksdb_options_get_allow_2pc(rocksdb_options_t* opt) { + return opt->rep.allow_2pc; +} + +void rocksdb_options_set_dump_malloc_stats(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.dump_malloc_stats = v; +} + +unsigned char rocksdb_options_get_dump_malloc_stats(rocksdb_options_t* opt) { + return opt->rep.dump_malloc_stats; +} + +void rocksdb_options_set_avoid_flush_during_recovery(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.avoid_flush_during_recovery = v; +} + +unsigned char rocksdb_options_get_avoid_flush_during_recovery( + rocksdb_options_t* opt) { + return opt->rep.avoid_flush_during_recovery; +} + +void rocksdb_options_set_enforce_write_buffer_manager_during_recovery( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.enforce_write_buffer_manager_during_recovery = v; +} + +unsigned char rocksdb_options_get_enforce_write_buffer_manager_during_recovery( + rocksdb_options_t* opt) { + return opt->rep.enforce_write_buffer_manager_during_recovery; +} + +void rocksdb_options_set_avoid_flush_during_shutdown(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.avoid_flush_during_shutdown = v; +} + +unsigned char rocksdb_options_get_avoid_flush_during_shutdown( + rocksdb_options_t* opt) { + return opt->rep.avoid_flush_during_shutdown; +} + +void rocksdb_options_set_allow_ingest_behind(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_ingest_behind = v; +} + +unsigned char rocksdb_options_get_allow_ingest_behind(rocksdb_options_t* opt) { + return opt->rep.allow_ingest_behind; +} + +void rocksdb_options_set_two_write_queues(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.two_write_queues = v; +} + +unsigned char rocksdb_options_get_two_write_queues(rocksdb_options_t* opt) { + return opt->rep.two_write_queues; +} + +void rocksdb_options_set_manual_wal_flush(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.manual_wal_flush = v; +} + +unsigned char rocksdb_options_get_manual_wal_flush(rocksdb_options_t* opt) { + return opt->rep.manual_wal_flush; +} + +void rocksdb_options_set_wal_compression(rocksdb_options_t* opt, int v) { + opt->rep.wal_compression = static_castrep.wal_compression)>(v); +} + +int rocksdb_options_get_wal_compression(rocksdb_options_t* opt) { + return static_cast(opt->rep.wal_compression); +} + +void rocksdb_options_set_background_close_inactive_wals(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.background_close_inactive_wals = v; +} + +unsigned char rocksdb_options_get_background_close_inactive_wals( + rocksdb_options_t* opt) { + return opt->rep.background_close_inactive_wals; +} + +void rocksdb_options_set_atomic_flush(rocksdb_options_t* opt, unsigned char v) { + opt->rep.atomic_flush = v; +} + +unsigned char rocksdb_options_get_atomic_flush(rocksdb_options_t* opt) { + return opt->rep.atomic_flush; +} + +void rocksdb_options_set_avoid_unnecessary_blocking_io(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.avoid_unnecessary_blocking_io = v; +} + +unsigned char rocksdb_options_get_avoid_unnecessary_blocking_io( + rocksdb_options_t* opt) { + return opt->rep.avoid_unnecessary_blocking_io; +} + +void rocksdb_options_set_write_dbid_to_manifest(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.write_dbid_to_manifest = v; +} + +unsigned char rocksdb_options_get_write_dbid_to_manifest( + rocksdb_options_t* opt) { + return opt->rep.write_dbid_to_manifest; +} + +void rocksdb_options_set_write_identity_file(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.write_identity_file = v; +} + +unsigned char rocksdb_options_get_write_identity_file(rocksdb_options_t* opt) { + return opt->rep.write_identity_file; +} + +void rocksdb_options_set_prefix_seek_opt_in_only(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.prefix_seek_opt_in_only = v; +} + +unsigned char rocksdb_options_get_prefix_seek_opt_in_only( + rocksdb_options_t* opt) { + return opt->rep.prefix_seek_opt_in_only; +} + +void rocksdb_options_set_log_readahead_size(rocksdb_options_t* opt, size_t v) { + opt->rep.log_readahead_size = v; +} + +size_t rocksdb_options_get_log_readahead_size(rocksdb_options_t* opt) { + return opt->rep.log_readahead_size; +} + +void rocksdb_options_set_best_efforts_recovery(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.best_efforts_recovery = v; +} + +unsigned char rocksdb_options_get_best_efforts_recovery( + rocksdb_options_t* opt) { + return opt->rep.best_efforts_recovery; +} + +void rocksdb_options_set_max_bgerror_resume_count(rocksdb_options_t* opt, + int v) { + opt->rep.max_bgerror_resume_count = v; +} + +int rocksdb_options_get_max_bgerror_resume_count(rocksdb_options_t* opt) { + return opt->rep.max_bgerror_resume_count; +} + +void rocksdb_options_set_bgerror_resume_retry_interval(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.bgerror_resume_retry_interval = v; +} + +uint64_t rocksdb_options_get_bgerror_resume_retry_interval( + rocksdb_options_t* opt) { + return opt->rep.bgerror_resume_retry_interval; +} + +void rocksdb_options_set_allow_data_in_errors(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_data_in_errors = v; +} + +unsigned char rocksdb_options_get_allow_data_in_errors(rocksdb_options_t* opt) { + return opt->rep.allow_data_in_errors; +} + +void rocksdb_options_set_db_host_id(rocksdb_options_t* opt, const char* v) { + opt->rep.db_host_id = v; +} + +const char* rocksdb_options_get_db_host_id(rocksdb_options_t* opt, + size_t* size) { + *size = opt->rep.db_host_id.size(); + return opt->rep.db_host_id.data(); +} + +void rocksdb_options_set_lowest_used_cache_tier(rocksdb_options_t* opt, int v) { + opt->rep.lowest_used_cache_tier = + static_castrep.lowest_used_cache_tier)>(v); +} + +int rocksdb_options_get_lowest_used_cache_tier(rocksdb_options_t* opt) { + return static_cast(opt->rep.lowest_used_cache_tier); +} + +void rocksdb_options_set_enforce_single_del_contracts(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enforce_single_del_contracts = v; +} + +unsigned char rocksdb_options_get_enforce_single_del_contracts( + rocksdb_options_t* opt) { + return opt->rep.enforce_single_del_contracts; +} + +void rocksdb_options_set_daily_offpeak_time_utc(rocksdb_options_t* opt, + const char* v) { + opt->rep.daily_offpeak_time_utc = v; +} + +const char* rocksdb_options_get_daily_offpeak_time_utc(rocksdb_options_t* opt, + size_t* size) { + *size = opt->rep.daily_offpeak_time_utc.size(); + return opt->rep.daily_offpeak_time_utc.data(); +} + +void rocksdb_options_set_max_compaction_trigger_wakeup_seconds( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.max_compaction_trigger_wakeup_seconds = v; +} + +uint64_t rocksdb_options_get_max_compaction_trigger_wakeup_seconds( + rocksdb_options_t* opt) { + return opt->rep.max_compaction_trigger_wakeup_seconds; +} + +void rocksdb_options_set_follower_refresh_catchup_period_ms( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.follower_refresh_catchup_period_ms = v; +} + +uint64_t rocksdb_options_get_follower_refresh_catchup_period_ms( + rocksdb_options_t* opt) { + return opt->rep.follower_refresh_catchup_period_ms; +} + +void rocksdb_options_set_follower_catchup_retry_count(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.follower_catchup_retry_count = v; +} + +uint64_t rocksdb_options_get_follower_catchup_retry_count( + rocksdb_options_t* opt) { + return opt->rep.follower_catchup_retry_count; +} + +void rocksdb_options_set_follower_catchup_retry_wait_ms(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.follower_catchup_retry_wait_ms = v; +} + +uint64_t rocksdb_options_get_follower_catchup_retry_wait_ms( + rocksdb_options_t* opt) { + return opt->rep.follower_catchup_retry_wait_ms; +} + +void rocksdb_options_set_metadata_write_temperature(rocksdb_options_t* opt, + int v) { + opt->rep.metadata_write_temperature = + static_castrep.metadata_write_temperature)>(v); +} + +int rocksdb_options_get_metadata_write_temperature(rocksdb_options_t* opt) { + return static_cast(opt->rep.metadata_write_temperature); +} + +void rocksdb_options_set_wal_write_temperature(rocksdb_options_t* opt, int v) { + opt->rep.wal_write_temperature = + static_castrep.wal_write_temperature)>(v); +} + +int rocksdb_options_get_wal_write_temperature(rocksdb_options_t* opt) { + return static_cast(opt->rep.wal_write_temperature); +} + +void rocksdb_options_set_fast_sst_open(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.fast_sst_open = v; +} + +unsigned char rocksdb_options_get_fast_sst_open(rocksdb_options_t* opt) { + return opt->rep.fast_sst_open; +} + +/* AdvancedColumnFamilyOptions */ + +void rocksdb_options_set_max_write_buffer_number(rocksdb_options_t* opt, + int v) { + opt->rep.max_write_buffer_number = v; +} + +int rocksdb_options_get_max_write_buffer_number(rocksdb_options_t* opt) { + return opt->rep.max_write_buffer_number; +} + +void rocksdb_options_set_min_write_buffer_number_to_merge( + rocksdb_options_t* opt, int v) { + opt->rep.min_write_buffer_number_to_merge = v; +} + +int rocksdb_options_get_min_write_buffer_number_to_merge( + rocksdb_options_t* opt) { + return opt->rep.min_write_buffer_number_to_merge; +} + +void rocksdb_options_set_max_write_buffer_size_to_maintain( + rocksdb_options_t* opt, int64_t v) { + opt->rep.max_write_buffer_size_to_maintain = v; +} + +int64_t rocksdb_options_get_max_write_buffer_size_to_maintain( + rocksdb_options_t* opt) { + return opt->rep.max_write_buffer_size_to_maintain; +} + +void rocksdb_options_set_inplace_update_support(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.inplace_update_support = v; +} + +unsigned char rocksdb_options_get_inplace_update_support( + rocksdb_options_t* opt) { + return opt->rep.inplace_update_support; +} + +void rocksdb_options_set_inplace_update_num_locks(rocksdb_options_t* opt, + size_t v) { + opt->rep.inplace_update_num_locks = v; +} + +size_t rocksdb_options_get_inplace_update_num_locks(rocksdb_options_t* opt) { + return opt->rep.inplace_update_num_locks; +} + +void rocksdb_options_set_experimental_mempurge_threshold(rocksdb_options_t* opt, + double v) { + opt->rep.experimental_mempurge_threshold = v; +} + +double rocksdb_options_get_experimental_mempurge_threshold( + rocksdb_options_t* opt) { + return opt->rep.experimental_mempurge_threshold; +} + +void rocksdb_options_set_memtable_prefix_bloom_size_ratio( + rocksdb_options_t* opt, double v) { + opt->rep.memtable_prefix_bloom_size_ratio = v; +} + +double rocksdb_options_get_memtable_prefix_bloom_size_ratio( + rocksdb_options_t* opt) { + return opt->rep.memtable_prefix_bloom_size_ratio; +} + +void rocksdb_options_set_memtable_whole_key_filtering(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.memtable_whole_key_filtering = v; +} + +unsigned char rocksdb_options_get_memtable_whole_key_filtering( + rocksdb_options_t* opt) { + return opt->rep.memtable_whole_key_filtering; +} + +void rocksdb_options_set_memtable_huge_page_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.memtable_huge_page_size = v; +} + +size_t rocksdb_options_get_memtable_huge_page_size(rocksdb_options_t* opt) { + return opt->rep.memtable_huge_page_size; +} + +void rocksdb_options_set_bloom_locality(rocksdb_options_t* opt, uint32_t v) { + opt->rep.bloom_locality = v; +} + +uint32_t rocksdb_options_get_bloom_locality(rocksdb_options_t* opt) { + return opt->rep.bloom_locality; +} + +void rocksdb_options_set_arena_block_size(rocksdb_options_t* opt, size_t v) { + opt->rep.arena_block_size = v; +} + +size_t rocksdb_options_get_arena_block_size(rocksdb_options_t* opt) { + return opt->rep.arena_block_size; +} + +void rocksdb_options_set_num_levels(rocksdb_options_t* opt, int v) { + opt->rep.num_levels = v; +} + +int rocksdb_options_get_num_levels(rocksdb_options_t* opt) { + return opt->rep.num_levels; +} + +void rocksdb_options_set_level0_slowdown_writes_trigger(rocksdb_options_t* opt, + int v) { + opt->rep.level0_slowdown_writes_trigger = v; +} + +int rocksdb_options_get_level0_slowdown_writes_trigger(rocksdb_options_t* opt) { + return opt->rep.level0_slowdown_writes_trigger; +} + +void rocksdb_options_set_level0_stop_writes_trigger(rocksdb_options_t* opt, + int v) { + opt->rep.level0_stop_writes_trigger = v; +} + +int rocksdb_options_get_level0_stop_writes_trigger(rocksdb_options_t* opt) { + return opt->rep.level0_stop_writes_trigger; +} + +void rocksdb_options_set_target_file_size_base(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.target_file_size_base = v; +} + +uint64_t rocksdb_options_get_target_file_size_base(rocksdb_options_t* opt) { + return opt->rep.target_file_size_base; +} + +void rocksdb_options_set_target_file_size_multiplier(rocksdb_options_t* opt, + int v) { + opt->rep.target_file_size_multiplier = v; +} + +int rocksdb_options_get_target_file_size_multiplier(rocksdb_options_t* opt) { + return opt->rep.target_file_size_multiplier; +} + +void rocksdb_options_set_target_file_size_is_upper_bound(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.target_file_size_is_upper_bound = v; +} + +unsigned char rocksdb_options_get_target_file_size_is_upper_bound( + rocksdb_options_t* opt) { + return opt->rep.target_file_size_is_upper_bound; +} + +void rocksdb_options_set_level_compaction_dynamic_level_bytes( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.level_compaction_dynamic_level_bytes = v; +} + +unsigned char rocksdb_options_get_level_compaction_dynamic_level_bytes( + rocksdb_options_t* opt) { + return opt->rep.level_compaction_dynamic_level_bytes; +} + +void rocksdb_options_set_max_bytes_for_level_multiplier(rocksdb_options_t* opt, + double v) { + opt->rep.max_bytes_for_level_multiplier = v; +} + +double rocksdb_options_get_max_bytes_for_level_multiplier( + rocksdb_options_t* opt) { + return opt->rep.max_bytes_for_level_multiplier; +} + +void rocksdb_options_set_max_compaction_bytes(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.max_compaction_bytes = v; +} + +uint64_t rocksdb_options_get_max_compaction_bytes(rocksdb_options_t* opt) { + return opt->rep.max_compaction_bytes; +} + +void rocksdb_options_set_compaction_style(rocksdb_options_t* opt, int v) { + opt->rep.compaction_style = + static_castrep.compaction_style)>(v); +} + +int rocksdb_options_get_compaction_style(rocksdb_options_t* opt) { + return static_cast(opt->rep.compaction_style); +} + +void rocksdb_options_set_compaction_pri(rocksdb_options_t* opt, int v) { + opt->rep.compaction_pri = static_castrep.compaction_pri)>(v); +} + +int rocksdb_options_get_compaction_pri(rocksdb_options_t* opt) { + return static_cast(opt->rep.compaction_pri); +} + +void rocksdb_options_set_max_sequential_skip_in_iterations( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.max_sequential_skip_in_iterations = v; +} + +uint64_t rocksdb_options_get_max_sequential_skip_in_iterations( + rocksdb_options_t* opt) { + return opt->rep.max_sequential_skip_in_iterations; +} + +void rocksdb_options_set_max_successive_merges(rocksdb_options_t* opt, + size_t v) { + opt->rep.max_successive_merges = v; +} + +size_t rocksdb_options_get_max_successive_merges(rocksdb_options_t* opt) { + return opt->rep.max_successive_merges; +} + +void rocksdb_options_set_strict_max_successive_merges(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.strict_max_successive_merges = v; +} + +unsigned char rocksdb_options_get_strict_max_successive_merges( + rocksdb_options_t* opt) { + return opt->rep.strict_max_successive_merges; +} + +unsigned char rocksdb_options_get_optimize_filters_for_hits( + rocksdb_options_t* opt) { + return opt->rep.optimize_filters_for_hits; +} + +void rocksdb_options_set_paranoid_file_checks(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.paranoid_file_checks = v; +} + +unsigned char rocksdb_options_get_paranoid_file_checks(rocksdb_options_t* opt) { + return opt->rep.paranoid_file_checks; +} + +void rocksdb_options_set_verify_output_flags(rocksdb_options_t* opt, int v) { + opt->rep.verify_output_flags = + static_castrep.verify_output_flags)>(v); +} + +int rocksdb_options_get_verify_output_flags(rocksdb_options_t* opt) { + return static_cast(opt->rep.verify_output_flags); +} + +void rocksdb_options_set_force_consistency_checks(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.force_consistency_checks = v; +} + +unsigned char rocksdb_options_get_force_consistency_checks( + rocksdb_options_t* opt) { + return opt->rep.force_consistency_checks; +} + +unsigned char rocksdb_options_get_report_bg_io_stats(rocksdb_options_t* opt) { + return opt->rep.report_bg_io_stats; +} + +void rocksdb_options_set_disallow_memtable_writes(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.disallow_memtable_writes = v; +} + +unsigned char rocksdb_options_get_disallow_memtable_writes( + rocksdb_options_t* opt) { + return opt->rep.disallow_memtable_writes; +} + +void rocksdb_options_set_ttl(rocksdb_options_t* opt, uint64_t v) { + opt->rep.ttl = v; +} + +uint64_t rocksdb_options_get_ttl(rocksdb_options_t* opt) { + return opt->rep.ttl; +} + +void rocksdb_options_set_periodic_compaction_seconds(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.periodic_compaction_seconds = v; +} + +uint64_t rocksdb_options_get_periodic_compaction_seconds( + rocksdb_options_t* opt) { + return opt->rep.periodic_compaction_seconds; +} + +void rocksdb_options_set_read_triggered_compaction_threshold( + rocksdb_options_t* opt, double v) { + opt->rep.read_triggered_compaction_threshold = v; +} + +double rocksdb_options_get_read_triggered_compaction_threshold( + rocksdb_options_t* opt) { + return opt->rep.read_triggered_compaction_threshold; +} + +void rocksdb_options_set_sample_for_compression(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.sample_for_compression = v; +} + +uint64_t rocksdb_options_get_sample_for_compression(rocksdb_options_t* opt) { + return opt->rep.sample_for_compression; +} + +void rocksdb_options_set_last_level_temperature(rocksdb_options_t* opt, int v) { + opt->rep.last_level_temperature = + static_castrep.last_level_temperature)>(v); +} + +int rocksdb_options_get_last_level_temperature(rocksdb_options_t* opt) { + return static_cast(opt->rep.last_level_temperature); +} + +void rocksdb_options_set_default_write_temperature(rocksdb_options_t* opt, + int v) { + opt->rep.default_write_temperature = + static_castrep.default_write_temperature)>(v); +} + +int rocksdb_options_get_default_write_temperature(rocksdb_options_t* opt) { + return static_cast(opt->rep.default_write_temperature); +} + +void rocksdb_options_set_default_temperature(rocksdb_options_t* opt, int v) { + opt->rep.default_temperature = + static_castrep.default_temperature)>(v); +} + +int rocksdb_options_get_default_temperature(rocksdb_options_t* opt) { + return static_cast(opt->rep.default_temperature); +} + +void rocksdb_options_set_preclude_last_level_data_seconds( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.preclude_last_level_data_seconds = v; +} + +uint64_t rocksdb_options_get_preclude_last_level_data_seconds( + rocksdb_options_t* opt) { + return opt->rep.preclude_last_level_data_seconds; +} + +void rocksdb_options_set_preserve_internal_time_seconds(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.preserve_internal_time_seconds = v; +} + +uint64_t rocksdb_options_get_preserve_internal_time_seconds( + rocksdb_options_t* opt) { + return opt->rep.preserve_internal_time_seconds; +} + +void rocksdb_options_set_enable_blob_files(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enable_blob_files = v; +} + +unsigned char rocksdb_options_get_enable_blob_files(rocksdb_options_t* opt) { + return opt->rep.enable_blob_files; +} + +void rocksdb_options_set_min_blob_size(rocksdb_options_t* opt, uint64_t v) { + opt->rep.min_blob_size = v; +} + +uint64_t rocksdb_options_get_min_blob_size(rocksdb_options_t* opt) { + return opt->rep.min_blob_size; +} + +void rocksdb_options_set_blob_file_size(rocksdb_options_t* opt, uint64_t v) { + opt->rep.blob_file_size = v; +} + +uint64_t rocksdb_options_get_blob_file_size(rocksdb_options_t* opt) { + return opt->rep.blob_file_size; +} + +void rocksdb_options_set_blob_compression_type(rocksdb_options_t* opt, int v) { + opt->rep.blob_compression_type = + static_castrep.blob_compression_type)>(v); +} + +int rocksdb_options_get_blob_compression_type(rocksdb_options_t* opt) { + return static_cast(opt->rep.blob_compression_type); +} + +void rocksdb_options_set_enable_blob_gc(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enable_blob_garbage_collection = v; +} + +unsigned char rocksdb_options_get_enable_blob_gc(rocksdb_options_t* opt) { + return opt->rep.enable_blob_garbage_collection; +} + +void rocksdb_options_set_blob_gc_age_cutoff(rocksdb_options_t* opt, double v) { + opt->rep.blob_garbage_collection_age_cutoff = v; +} + +double rocksdb_options_get_blob_gc_age_cutoff(rocksdb_options_t* opt) { + return opt->rep.blob_garbage_collection_age_cutoff; +} + +void rocksdb_options_set_blob_gc_force_threshold(rocksdb_options_t* opt, + double v) { + opt->rep.blob_garbage_collection_force_threshold = v; +} + +double rocksdb_options_get_blob_gc_force_threshold(rocksdb_options_t* opt) { + return opt->rep.blob_garbage_collection_force_threshold; +} + +void rocksdb_options_set_blob_compaction_readahead_size(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.blob_compaction_readahead_size = v; +} + +uint64_t rocksdb_options_get_blob_compaction_readahead_size( + rocksdb_options_t* opt) { + return opt->rep.blob_compaction_readahead_size; +} + +void rocksdb_options_set_blob_file_starting_level(rocksdb_options_t* opt, + int v) { + opt->rep.blob_file_starting_level = v; +} + +int rocksdb_options_get_blob_file_starting_level(rocksdb_options_t* opt) { + return opt->rep.blob_file_starting_level; +} + +void rocksdb_options_set_prepopulate_blob_cache(rocksdb_options_t* opt, int v) { + opt->rep.prepopulate_blob_cache = + static_castrep.prepopulate_blob_cache)>(v); +} + +int rocksdb_options_get_prepopulate_blob_cache(rocksdb_options_t* opt) { + return static_cast(opt->rep.prepopulate_blob_cache); +} + +void rocksdb_options_set_enable_blob_direct_write(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enable_blob_direct_write = v; +} + +unsigned char rocksdb_options_get_enable_blob_direct_write( + rocksdb_options_t* opt) { + return opt->rep.enable_blob_direct_write; +} + +void rocksdb_options_set_blob_direct_write_partitions(rocksdb_options_t* opt, + uint32_t v) { + opt->rep.blob_direct_write_partitions = v; +} + +uint32_t rocksdb_options_get_blob_direct_write_partitions( + rocksdb_options_t* opt) { + return opt->rep.blob_direct_write_partitions; +} + +void rocksdb_options_set_memtable_protection_bytes_per_key( + rocksdb_options_t* opt, uint32_t v) { + opt->rep.memtable_protection_bytes_per_key = v; +} + +uint32_t rocksdb_options_get_memtable_protection_bytes_per_key( + rocksdb_options_t* opt) { + return opt->rep.memtable_protection_bytes_per_key; +} + +void rocksdb_options_set_persist_user_defined_timestamps(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.persist_user_defined_timestamps = v; +} + +unsigned char rocksdb_options_get_persist_user_defined_timestamps( + rocksdb_options_t* opt) { + return opt->rep.persist_user_defined_timestamps; +} + +void rocksdb_options_set_block_protection_bytes_per_key(rocksdb_options_t* opt, + uint8_t v) { + opt->rep.block_protection_bytes_per_key = v; +} + +uint8_t rocksdb_options_get_block_protection_bytes_per_key( + rocksdb_options_t* opt) { + return opt->rep.block_protection_bytes_per_key; +} + +void rocksdb_options_set_bottommost_file_compaction_delay( + rocksdb_options_t* opt, uint32_t v) { + opt->rep.bottommost_file_compaction_delay = v; +} + +uint32_t rocksdb_options_get_bottommost_file_compaction_delay( + rocksdb_options_t* opt) { + return opt->rep.bottommost_file_compaction_delay; +} + +void rocksdb_options_set_paranoid_memory_checks(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.paranoid_memory_checks = v; +} + +unsigned char rocksdb_options_get_paranoid_memory_checks( + rocksdb_options_t* opt) { + return opt->rep.paranoid_memory_checks; +} + +void rocksdb_options_set_memtable_verify_per_key_checksum_on_seek( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.memtable_verify_per_key_checksum_on_seek = v; +} + +unsigned char rocksdb_options_get_memtable_verify_per_key_checksum_on_seek( + rocksdb_options_t* opt) { + return opt->rep.memtable_verify_per_key_checksum_on_seek; +} + +void rocksdb_options_set_memtable_op_scan_flush_trigger(rocksdb_options_t* opt, + uint32_t v) { + opt->rep.memtable_op_scan_flush_trigger = v; +} + +uint32_t rocksdb_options_get_memtable_op_scan_flush_trigger( + rocksdb_options_t* opt) { + return opt->rep.memtable_op_scan_flush_trigger; +} + +void rocksdb_options_set_memtable_avg_op_scan_flush_trigger( + rocksdb_options_t* opt, uint32_t v) { + opt->rep.memtable_avg_op_scan_flush_trigger = v; +} + +uint32_t rocksdb_options_get_memtable_avg_op_scan_flush_trigger( + rocksdb_options_t* opt) { + return opt->rep.memtable_avg_op_scan_flush_trigger; +} + +void rocksdb_options_set_min_tombstones_for_range_conversion( + rocksdb_options_t* opt, uint32_t v) { + opt->rep.min_tombstones_for_range_conversion = v; +} + +uint32_t rocksdb_options_get_min_tombstones_for_range_conversion( + rocksdb_options_t* opt) { + return opt->rep.min_tombstones_for_range_conversion; +} + +void rocksdb_options_set_cf_allow_ingest_behind(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.cf_allow_ingest_behind = v; +} + +unsigned char rocksdb_options_get_cf_allow_ingest_behind( + rocksdb_options_t* opt) { + return opt->rep.cf_allow_ingest_behind; +} + +void rocksdb_options_set_memtable_batch_lookup_optimization( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.memtable_batch_lookup_optimization = v; +} + +unsigned char rocksdb_options_get_memtable_batch_lookup_optimization( + rocksdb_options_t* opt) { + return opt->rep.memtable_batch_lookup_optimization; +} + +/* ColumnFamilyOptions */ + +void rocksdb_options_set_write_buffer_size(rocksdb_options_t* opt, size_t v) { + opt->rep.write_buffer_size = v; +} + +size_t rocksdb_options_get_write_buffer_size(rocksdb_options_t* opt) { + return opt->rep.write_buffer_size; +} + +void rocksdb_options_set_compression(rocksdb_options_t* opt, int v) { + opt->rep.compression = static_castrep.compression)>(v); +} + +int rocksdb_options_get_compression(rocksdb_options_t* opt) { + return static_cast(opt->rep.compression); +} + +void rocksdb_options_set_bottommost_compression(rocksdb_options_t* opt, int v) { + opt->rep.bottommost_compression = + static_castrep.bottommost_compression)>(v); +} + +int rocksdb_options_get_bottommost_compression(rocksdb_options_t* opt) { + return static_cast(opt->rep.bottommost_compression); +} + +void rocksdb_options_set_level0_file_num_compaction_trigger( + rocksdb_options_t* opt, int v) { + opt->rep.level0_file_num_compaction_trigger = v; +} + +int rocksdb_options_get_level0_file_num_compaction_trigger( + rocksdb_options_t* opt) { + return opt->rep.level0_file_num_compaction_trigger; +} + +void rocksdb_options_set_max_bytes_for_level_base(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.max_bytes_for_level_base = v; +} + +uint64_t rocksdb_options_get_max_bytes_for_level_base(rocksdb_options_t* opt) { + return opt->rep.max_bytes_for_level_base; +} + +unsigned char rocksdb_options_get_disable_auto_compactions( + rocksdb_options_t* opt) { + return opt->rep.disable_auto_compactions; +} + +void rocksdb_options_set_memtable_max_range_deletions(rocksdb_options_t* opt, + uint32_t v) { + opt->rep.memtable_max_range_deletions = v; +} + +uint32_t rocksdb_options_get_memtable_max_range_deletions( + rocksdb_options_t* opt) { + return opt->rep.memtable_max_range_deletions; +} + +void rocksdb_options_set_uncache_aggressiveness(rocksdb_options_t* opt, + uint32_t v) { + opt->rep.uncache_aggressiveness = v; +} + +uint32_t rocksdb_options_get_uncache_aggressiveness(rocksdb_options_t* opt) { + return opt->rep.uncache_aggressiveness; +} + +/* WriteOptions */ + +void rocksdb_writeoptions_set_sync(rocksdb_writeoptions_t* opt, + unsigned char v) { + opt->rep.sync = v; +} + +unsigned char rocksdb_writeoptions_get_sync(rocksdb_writeoptions_t* opt) { + return opt->rep.sync; +} + +void rocksdb_writeoptions_disable_WAL(rocksdb_writeoptions_t* opt, int v) { + opt->rep.disableWAL = static_castrep.disableWAL)>(v); +} + +unsigned char rocksdb_writeoptions_get_disable_WAL( + rocksdb_writeoptions_t* opt) { + return opt->rep.disableWAL; +} + +void rocksdb_writeoptions_set_ignore_missing_column_families( + rocksdb_writeoptions_t* opt, unsigned char v) { + opt->rep.ignore_missing_column_families = v; +} + +unsigned char rocksdb_writeoptions_get_ignore_missing_column_families( + rocksdb_writeoptions_t* opt) { + return opt->rep.ignore_missing_column_families; +} + +void rocksdb_writeoptions_set_no_slowdown(rocksdb_writeoptions_t* opt, + unsigned char v) { + opt->rep.no_slowdown = v; +} + +unsigned char rocksdb_writeoptions_get_no_slowdown( + rocksdb_writeoptions_t* opt) { + return opt->rep.no_slowdown; +} + +void rocksdb_writeoptions_set_low_pri(rocksdb_writeoptions_t* opt, + unsigned char v) { + opt->rep.low_pri = v; +} + +unsigned char rocksdb_writeoptions_get_low_pri(rocksdb_writeoptions_t* opt) { + return opt->rep.low_pri; +} + +void rocksdb_writeoptions_set_memtable_insert_hint_per_batch( + rocksdb_writeoptions_t* opt, unsigned char v) { + opt->rep.memtable_insert_hint_per_batch = v; +} + +unsigned char rocksdb_writeoptions_get_memtable_insert_hint_per_batch( + rocksdb_writeoptions_t* opt) { + return opt->rep.memtable_insert_hint_per_batch; +} + +void rocksdb_writeoptions_set_rate_limiter_priority(rocksdb_writeoptions_t* opt, + int v) { + opt->rep.rate_limiter_priority = + static_castrep.rate_limiter_priority)>(v); +} + +int rocksdb_writeoptions_get_rate_limiter_priority( + rocksdb_writeoptions_t* opt) { + return static_cast(opt->rep.rate_limiter_priority); +} + +void rocksdb_writeoptions_set_protection_bytes_per_key( + rocksdb_writeoptions_t* opt, size_t v) { + opt->rep.protection_bytes_per_key = v; +} + +size_t rocksdb_writeoptions_get_protection_bytes_per_key( + rocksdb_writeoptions_t* opt) { + return opt->rep.protection_bytes_per_key; +} + +void rocksdb_writeoptions_set_io_activity(rocksdb_writeoptions_t* opt, int v) { + opt->rep.io_activity = static_castrep.io_activity)>(v); +} + +int rocksdb_writeoptions_get_io_activity(rocksdb_writeoptions_t* opt) { + return static_cast(opt->rep.io_activity); +} + +/* FlushOptions */ + +void rocksdb_flushoptions_set_wait(rocksdb_flushoptions_t* opt, + unsigned char v) { + opt->rep.wait = v; +} + +unsigned char rocksdb_flushoptions_get_wait(rocksdb_flushoptions_t* opt) { + return opt->rep.wait; +} + +void rocksdb_flushoptions_set_allow_write_stall(rocksdb_flushoptions_t* opt, + unsigned char v) { + opt->rep.allow_write_stall = v; +} + +unsigned char rocksdb_flushoptions_get_allow_write_stall( + rocksdb_flushoptions_t* opt) { + return opt->rep.allow_write_stall; +} + +void rocksdb_flushoptions_set_force_atomic_flush(rocksdb_flushoptions_t* opt, + unsigned char v) { + opt->rep.force_atomic_flush = v; +} + +unsigned char rocksdb_flushoptions_get_force_atomic_flush( + rocksdb_flushoptions_t* opt) { + return opt->rep.force_atomic_flush; +} + +/* FlushWALOptions */ + +void rocksdb_flushwaloptions_set_sync(rocksdb_flushwaloptions_t* opt, + unsigned char v) { + opt->rep.sync = v; +} + +unsigned char rocksdb_flushwaloptions_get_sync(rocksdb_flushwaloptions_t* opt) { + return opt->rep.sync; +} + +void rocksdb_flushwaloptions_set_rate_limiter_priority( + rocksdb_flushwaloptions_t* opt, int v) { + opt->rep.rate_limiter_priority = + static_castrep.rate_limiter_priority)>(v); +} + +int rocksdb_flushwaloptions_get_rate_limiter_priority( + rocksdb_flushwaloptions_t* opt) { + return static_cast(opt->rep.rate_limiter_priority); +} + +/* EnvOptions */ + +void rocksdb_envoptions_set_use_mmap_reads(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.use_mmap_reads = v; +} + +unsigned char rocksdb_envoptions_get_use_mmap_reads(rocksdb_envoptions_t* opt) { + return opt->rep.use_mmap_reads; +} + +void rocksdb_envoptions_set_use_mmap_writes(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.use_mmap_writes = v; +} + +unsigned char rocksdb_envoptions_get_use_mmap_writes( + rocksdb_envoptions_t* opt) { + return opt->rep.use_mmap_writes; +} + +void rocksdb_envoptions_set_use_direct_reads(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.use_direct_reads = v; +} + +unsigned char rocksdb_envoptions_get_use_direct_reads( + rocksdb_envoptions_t* opt) { + return opt->rep.use_direct_reads; +} + +void rocksdb_envoptions_set_use_direct_writes(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.use_direct_writes = v; +} + +unsigned char rocksdb_envoptions_get_use_direct_writes( + rocksdb_envoptions_t* opt) { + return opt->rep.use_direct_writes; +} + +void rocksdb_envoptions_set_allow_fallocate(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.allow_fallocate = v; +} + +unsigned char rocksdb_envoptions_get_allow_fallocate( + rocksdb_envoptions_t* opt) { + return opt->rep.allow_fallocate; +} + +void rocksdb_envoptions_set_fd_cloexec(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.set_fd_cloexec = v; +} + +unsigned char rocksdb_envoptions_get_fd_cloexec(rocksdb_envoptions_t* opt) { + return opt->rep.set_fd_cloexec; +} + +void rocksdb_envoptions_set_bytes_per_sync(rocksdb_envoptions_t* opt, + uint64_t v) { + opt->rep.bytes_per_sync = v; +} + +uint64_t rocksdb_envoptions_get_bytes_per_sync(rocksdb_envoptions_t* opt) { + return opt->rep.bytes_per_sync; +} + +void rocksdb_envoptions_set_strict_bytes_per_sync(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.strict_bytes_per_sync = v; +} + +unsigned char rocksdb_envoptions_get_strict_bytes_per_sync( + rocksdb_envoptions_t* opt) { + return opt->rep.strict_bytes_per_sync; +} + +void rocksdb_envoptions_set_fallocate_with_keep_size(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.fallocate_with_keep_size = v; +} + +unsigned char rocksdb_envoptions_get_fallocate_with_keep_size( + rocksdb_envoptions_t* opt) { + return opt->rep.fallocate_with_keep_size; +} + +void rocksdb_envoptions_set_compaction_readahead_size(rocksdb_envoptions_t* opt, + size_t v) { + opt->rep.compaction_readahead_size = v; +} + +size_t rocksdb_envoptions_get_compaction_readahead_size( + rocksdb_envoptions_t* opt) { + return opt->rep.compaction_readahead_size; +} + +void rocksdb_envoptions_set_writable_file_max_buffer_size( + rocksdb_envoptions_t* opt, size_t v) { + opt->rep.writable_file_max_buffer_size = v; +} + +size_t rocksdb_envoptions_get_writable_file_max_buffer_size( + rocksdb_envoptions_t* opt) { + return opt->rep.writable_file_max_buffer_size; +} + +/* TraceOptions */ + +void rocksdb_trace_options_set_max_trace_file_size(rocksdb_trace_options_t* opt, + uint64_t v) { + opt->rep.max_trace_file_size = v; +} + +uint64_t rocksdb_trace_options_get_max_trace_file_size( + rocksdb_trace_options_t* opt) { + return opt->rep.max_trace_file_size; +} + +void rocksdb_trace_options_set_sampling_frequency(rocksdb_trace_options_t* opt, + uint64_t v) { + opt->rep.sampling_frequency = v; +} + +uint64_t rocksdb_trace_options_get_sampling_frequency( + rocksdb_trace_options_t* opt) { + return opt->rep.sampling_frequency; +} + +void rocksdb_trace_options_set_filter(rocksdb_trace_options_t* opt, + uint64_t v) { + opt->rep.filter = v; +} + +uint64_t rocksdb_trace_options_get_filter(rocksdb_trace_options_t* opt) { + return opt->rep.filter; +} + +void rocksdb_trace_options_set_preserve_write_order( + rocksdb_trace_options_t* opt, unsigned char v) { + opt->rep.preserve_write_order = v; +} + +unsigned char rocksdb_trace_options_get_preserve_write_order( + rocksdb_trace_options_t* opt) { + return opt->rep.preserve_write_order; +} + +/* BlockCacheTraceOptions */ + +void rocksdb_block_cache_trace_options_set_sampling_frequency( + rocksdb_block_cache_trace_options_t* opt, uint64_t v) { + opt->rep.sampling_frequency = v; +} + +uint64_t rocksdb_block_cache_trace_options_get_sampling_frequency( + rocksdb_block_cache_trace_options_t* opt) { + return opt->rep.sampling_frequency; +} + +/* BlockCacheTraceWriterOptions */ + +void rocksdb_block_cache_trace_writer_options_set_max_trace_file_size( + rocksdb_block_cache_trace_writer_options_t* opt, uint64_t v) { + opt->rep.max_trace_file_size = v; +} + +uint64_t rocksdb_block_cache_trace_writer_options_get_max_trace_file_size( + rocksdb_block_cache_trace_writer_options_t* opt) { + return opt->rep.max_trace_file_size; +} + +/* CompactionOptions */ + +void rocksdb_compaction_options_set_compression( + rocksdb_compaction_options_t* opt, int v) { + opt->rep.compression = static_castrep.compression)>(v); +} + +int rocksdb_compaction_options_get_compression( + rocksdb_compaction_options_t* opt) { + return static_cast(opt->rep.compression); +} + +void rocksdb_compaction_options_set_output_file_size_limit( + rocksdb_compaction_options_t* opt, uint64_t v) { + opt->rep.output_file_size_limit = v; +} + +uint64_t rocksdb_compaction_options_get_output_file_size_limit( + rocksdb_compaction_options_t* opt) { + return opt->rep.output_file_size_limit; +} + +void rocksdb_compaction_options_set_max_subcompactions( + rocksdb_compaction_options_t* opt, uint32_t v) { + opt->rep.max_subcompactions = v; +} + +uint32_t rocksdb_compaction_options_get_max_subcompactions( + rocksdb_compaction_options_t* opt) { + return opt->rep.max_subcompactions; +} + +void rocksdb_compaction_options_set_output_temperature_override( + rocksdb_compaction_options_t* opt, int v) { + opt->rep.output_temperature_override = + static_castrep.output_temperature_override)>(v); +} + +int rocksdb_compaction_options_get_output_temperature_override( + rocksdb_compaction_options_t* opt) { + return static_cast(opt->rep.output_temperature_override); +} + +void rocksdb_compaction_options_set_allow_trivial_move( + rocksdb_compaction_options_t* opt, unsigned char v) { + opt->rep.allow_trivial_move = v; +} + +unsigned char rocksdb_compaction_options_get_allow_trivial_move( + rocksdb_compaction_options_t* opt) { + return opt->rep.allow_trivial_move; +} + +/* CompactRangeOptions */ + +void rocksdb_compactoptions_set_blob_garbage_collection_policy( + rocksdb_compactoptions_t* opt, int v) { + opt->rep.blob_garbage_collection_policy = + static_castrep.blob_garbage_collection_policy)>(v); +} + +int rocksdb_compactoptions_get_blob_garbage_collection_policy( + rocksdb_compactoptions_t* opt) { + return static_cast(opt->rep.blob_garbage_collection_policy); +} + +void rocksdb_compactoptions_set_blob_garbage_collection_age_cutoff( + rocksdb_compactoptions_t* opt, double v) { + opt->rep.blob_garbage_collection_age_cutoff = v; +} + +double rocksdb_compactoptions_get_blob_garbage_collection_age_cutoff( + rocksdb_compactoptions_t* opt) { + return opt->rep.blob_garbage_collection_age_cutoff; +} + +/* IngestExternalFileOptions */ + +unsigned char rocksdb_ingestexternalfileoptions_get_move_files( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.move_files; +} + +void rocksdb_ingestexternalfileoptions_set_link_files( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.link_files = v; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_link_files( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.link_files; +} + +void rocksdb_ingestexternalfileoptions_set_failed_move_fall_back_to_copy( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.failed_move_fall_back_to_copy = v; +} + +unsigned char +rocksdb_ingestexternalfileoptions_get_failed_move_fall_back_to_copy( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.failed_move_fall_back_to_copy; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_snapshot_consistency( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.snapshot_consistency; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_allow_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.allow_global_seqno; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_allow_blocking_flush( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.allow_blocking_flush; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_ingest_behind( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.ingest_behind; +} + +void rocksdb_ingestexternalfileoptions_set_write_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.write_global_seqno = v; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_write_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.write_global_seqno; +} + +void rocksdb_ingestexternalfileoptions_set_verify_checksums_before_ingest( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.verify_checksums_before_ingest = v; +} + +unsigned char +rocksdb_ingestexternalfileoptions_get_verify_checksums_before_ingest( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.verify_checksums_before_ingest; +} + +void rocksdb_ingestexternalfileoptions_set_verify_checksums_readahead_size( + rocksdb_ingestexternalfileoptions_t* opt, size_t v) { + opt->rep.verify_checksums_readahead_size = v; +} + +size_t rocksdb_ingestexternalfileoptions_get_verify_checksums_readahead_size( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.verify_checksums_readahead_size; +} + +void rocksdb_ingestexternalfileoptions_set_verify_file_checksum( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.verify_file_checksum = v; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_verify_file_checksum( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.verify_file_checksum; +} + +unsigned char +rocksdb_ingestexternalfileoptions_get_fail_if_not_bottommost_level( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.fail_if_not_bottommost_level; +} + +void rocksdb_ingestexternalfileoptions_set_allow_db_generated_files( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.allow_db_generated_files = v; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_allow_db_generated_files( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.allow_db_generated_files; +} + +void rocksdb_ingestexternalfileoptions_set_fill_cache( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.fill_cache = v; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_fill_cache( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.fill_cache; +} + +void rocksdb_ingestexternalfileoptions_set_prefetch_lmax_index_and_filter_blocks( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.prefetch_lmax_index_and_filter_blocks = v; +} + +unsigned char +rocksdb_ingestexternalfileoptions_get_prefetch_lmax_index_and_filter_blocks( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.prefetch_lmax_index_and_filter_blocks; +} + +void rocksdb_ingestexternalfileoptions_set_file_opening_threads( + rocksdb_ingestexternalfileoptions_t* opt, int v) { + opt->rep.file_opening_threads = v; +} + +int rocksdb_ingestexternalfileoptions_get_file_opening_threads( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.file_opening_threads; +} + +/* OpenAndCompactOptions */ + +unsigned char rocksdb_open_and_compact_options_get_allow_resumption( + rocksdb_open_and_compact_options_t* opt) { + return opt->rep.allow_resumption; +} + +/* ImportColumnFamilyOptions */ + +unsigned char rocksdb_import_column_family_options_get_move_files( + rocksdb_import_column_family_options_t* opt) { + return opt->rep.move_files; +} + +/* SizeApproximationOptions */ + +void rocksdb_size_approximation_options_set_include_memtables( + rocksdb_size_approximation_options_t* opt, unsigned char v) { + opt->rep.include_memtables = v; +} + +unsigned char rocksdb_size_approximation_options_get_include_memtables( + rocksdb_size_approximation_options_t* opt) { + return opt->rep.include_memtables; +} + +void rocksdb_size_approximation_options_set_include_files( + rocksdb_size_approximation_options_t* opt, unsigned char v) { + opt->rep.include_files = v; +} + +unsigned char rocksdb_size_approximation_options_get_include_files( + rocksdb_size_approximation_options_t* opt) { + return opt->rep.include_files; +} + +void rocksdb_size_approximation_options_set_include_blob_files( + rocksdb_size_approximation_options_t* opt, unsigned char v) { + opt->rep.include_blob_files = v; +} + +unsigned char rocksdb_size_approximation_options_get_include_blob_files( + rocksdb_size_approximation_options_t* opt) { + return opt->rep.include_blob_files; +} + +void rocksdb_size_approximation_options_set_files_size_error_margin( + rocksdb_size_approximation_options_t* opt, double v) { + opt->rep.files_size_error_margin = v; +} + +double rocksdb_size_approximation_options_get_files_size_error_margin( + rocksdb_size_approximation_options_t* opt) { + return opt->rep.files_size_error_margin; +} + +/* LiveFilesStorageInfoOptions */ + +void rocksdb_livefiles_storage_info_options_set_include_checksum_info( + rocksdb_livefiles_storage_info_options_t* opt, unsigned char v) { + opt->rep.include_checksum_info = v; +} + +unsigned char rocksdb_livefiles_storage_info_options_get_include_checksum_info( + rocksdb_livefiles_storage_info_options_t* opt) { + return opt->rep.include_checksum_info; +} + +void rocksdb_livefiles_storage_info_options_set_wal_size_for_flush( + rocksdb_livefiles_storage_info_options_t* opt, uint64_t v) { + opt->rep.wal_size_for_flush = v; +} + +uint64_t rocksdb_livefiles_storage_info_options_get_wal_size_for_flush( + rocksdb_livefiles_storage_info_options_t* opt) { + return opt->rep.wal_size_for_flush; +} + +void rocksdb_livefiles_storage_info_options_set_atomic_flush( + rocksdb_livefiles_storage_info_options_t* opt, unsigned char v) { + opt->rep.atomic_flush = v; +} + +unsigned char rocksdb_livefiles_storage_info_options_get_atomic_flush( + rocksdb_livefiles_storage_info_options_t* opt) { + return opt->rep.atomic_flush; +} + +/* GetColumnFamilyMetaDataOptions */ + +void rocksdb_column_family_metadata_options_set_level( + rocksdb_column_family_metadata_options_t* opt, int v) { + opt->rep.level = v; +} + +int rocksdb_column_family_metadata_options_get_level( + rocksdb_column_family_metadata_options_t* opt) { + return opt->rep.level; +} + +/* WaitForCompactOptions */ + +void rocksdb_wait_for_compact_options_set_wait_for_purge( + rocksdb_wait_for_compact_options_t* opt, unsigned char v) { + opt->rep.wait_for_purge = v; +} + +unsigned char rocksdb_wait_for_compact_options_get_wait_for_purge( + rocksdb_wait_for_compact_options_t* opt) { + return opt->rep.wait_for_purge; +} + +/* BlockBasedTableOptions */ + +void rocksdb_block_based_options_set_cache_index_and_filter_blocks( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.cache_index_and_filter_blocks = v; +} + +unsigned char rocksdb_block_based_options_get_cache_index_and_filter_blocks( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.cache_index_and_filter_blocks; +} + +void rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.cache_index_and_filter_blocks_with_high_priority = v; +} + +unsigned char +rocksdb_block_based_options_get_cache_index_and_filter_blocks_with_high_priority( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.cache_index_and_filter_blocks_with_high_priority; +} + +void rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.pin_l0_filter_and_index_blocks_in_cache = v; +} + +unsigned char +rocksdb_block_based_options_get_pin_l0_filter_and_index_blocks_in_cache( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.pin_l0_filter_and_index_blocks_in_cache; +} + +void rocksdb_block_based_options_set_pin_top_level_index_and_filter( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.pin_top_level_index_and_filter = v; +} + +unsigned char rocksdb_block_based_options_get_pin_top_level_index_and_filter( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.pin_top_level_index_and_filter; +} + +void rocksdb_block_based_options_set_index_type( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.index_type = static_castrep.index_type)>(v); +} + +int rocksdb_block_based_options_get_index_type( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.index_type); +} + +void rocksdb_block_based_options_set_index_block_search_type( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.index_block_search_type = + static_castrep.index_block_search_type)>(v); +} + +int rocksdb_block_based_options_get_index_block_search_type( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.index_block_search_type); +} + +void rocksdb_block_based_options_set_data_block_index_type( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.data_block_index_type = + static_castrep.data_block_index_type)>(v); +} + +int rocksdb_block_based_options_get_data_block_index_type( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.data_block_index_type); +} + +void rocksdb_block_based_options_set_data_block_hash_table_util_ratio( + rocksdb_block_based_table_options_t* opt, double v) { + opt->rep.data_block_hash_table_util_ratio = v; +} + +double rocksdb_block_based_options_get_data_block_hash_table_util_ratio( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.data_block_hash_table_util_ratio; +} + +void rocksdb_block_based_options_set_checksum( + rocksdb_block_based_table_options_t* opt, char v) { + opt->rep.checksum = static_castrep.checksum)>(v); +} + +int rocksdb_block_based_options_get_checksum( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.checksum); +} + +void rocksdb_block_based_options_set_no_block_cache( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.no_block_cache = v; +} + +unsigned char rocksdb_block_based_options_get_no_block_cache( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.no_block_cache; +} + +void rocksdb_block_based_options_set_block_size( + rocksdb_block_based_table_options_t* opt, size_t v) { + opt->rep.block_size = static_castrep.block_size)>(v); +} + +uint64_t rocksdb_block_based_options_get_block_size( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.block_size; +} + +void rocksdb_block_based_options_set_block_size_deviation( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.block_size_deviation = v; +} + +int rocksdb_block_based_options_get_block_size_deviation( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.block_size_deviation; +} + +void rocksdb_block_based_options_set_block_restart_interval( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.block_restart_interval = v; +} + +int rocksdb_block_based_options_get_block_restart_interval( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.block_restart_interval; +} + +void rocksdb_block_based_options_set_index_block_restart_interval( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.index_block_restart_interval = v; +} + +int rocksdb_block_based_options_get_index_block_restart_interval( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.index_block_restart_interval; +} + +void rocksdb_block_based_options_set_metadata_block_size( + rocksdb_block_based_table_options_t* opt, uint64_t v) { + opt->rep.metadata_block_size = v; +} + +uint64_t rocksdb_block_based_options_get_metadata_block_size( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.metadata_block_size; +} + +void rocksdb_block_based_options_set_partition_filters( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.partition_filters = v; +} + +unsigned char rocksdb_block_based_options_get_partition_filters( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.partition_filters; +} + +void rocksdb_block_based_options_set_decouple_partitioned_filters( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.decouple_partitioned_filters = v; +} + +unsigned char rocksdb_block_based_options_get_decouple_partitioned_filters( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.decouple_partitioned_filters; +} + +void rocksdb_block_based_options_set_optimize_filters_for_memory( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.optimize_filters_for_memory = v; +} + +unsigned char rocksdb_block_based_options_get_optimize_filters_for_memory( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.optimize_filters_for_memory; +} + +void rocksdb_block_based_options_set_use_delta_encoding( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.use_delta_encoding = v; +} + +unsigned char rocksdb_block_based_options_get_use_delta_encoding( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.use_delta_encoding; +} + +void rocksdb_block_based_options_set_use_udi_as_primary_index( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.use_udi_as_primary_index = v; +} + +unsigned char rocksdb_block_based_options_get_use_udi_as_primary_index( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.use_udi_as_primary_index; +} + +void rocksdb_block_based_options_set_fail_if_no_udi_on_open( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.fail_if_no_udi_on_open = v; +} + +unsigned char rocksdb_block_based_options_get_fail_if_no_udi_on_open( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.fail_if_no_udi_on_open; +} + +void rocksdb_block_based_options_set_whole_key_filtering( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.whole_key_filtering = v; +} + +unsigned char rocksdb_block_based_options_get_whole_key_filtering( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.whole_key_filtering; +} + +void rocksdb_block_based_options_set_detect_filter_construct_corruption( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.detect_filter_construct_corruption = v; +} + +unsigned char +rocksdb_block_based_options_get_detect_filter_construct_corruption( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.detect_filter_construct_corruption; +} + +void rocksdb_block_based_options_set_verify_compression( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.verify_compression = v; +} + +unsigned char rocksdb_block_based_options_get_verify_compression( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.verify_compression; +} + +void rocksdb_block_based_options_set_read_amp_bytes_per_bit( + rocksdb_block_based_table_options_t* opt, uint32_t v) { + opt->rep.read_amp_bytes_per_bit = v; +} + +uint32_t rocksdb_block_based_options_get_read_amp_bytes_per_bit( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.read_amp_bytes_per_bit; +} + +void rocksdb_block_based_options_set_format_version( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.format_version = static_castrep.format_version)>(v); +} + +uint32_t rocksdb_block_based_options_get_format_version( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.format_version; +} + +void rocksdb_block_based_options_set_separate_key_value_in_data_block( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.separate_key_value_in_data_block = v; +} + +unsigned char rocksdb_block_based_options_get_separate_key_value_in_data_block( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.separate_key_value_in_data_block; +} + +void rocksdb_block_based_options_set_uniform_cv_threshold( + rocksdb_block_based_table_options_t* opt, double v) { + opt->rep.uniform_cv_threshold = v; +} + +double rocksdb_block_based_options_get_uniform_cv_threshold( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.uniform_cv_threshold; +} + +void rocksdb_block_based_options_set_enable_index_compression( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.enable_index_compression = v; +} + +unsigned char rocksdb_block_based_options_get_enable_index_compression( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.enable_index_compression; +} + +void rocksdb_block_based_options_set_block_align( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.block_align = v; +} + +unsigned char rocksdb_block_based_options_get_block_align( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.block_align; +} + +void rocksdb_block_based_options_set_super_block_alignment_size( + rocksdb_block_based_table_options_t* opt, size_t v) { + opt->rep.super_block_alignment_size = v; +} + +size_t rocksdb_block_based_options_get_super_block_alignment_size( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.super_block_alignment_size; +} + +void rocksdb_block_based_options_set_super_block_alignment_space_overhead_ratio( + rocksdb_block_based_table_options_t* opt, size_t v) { + opt->rep.super_block_alignment_space_overhead_ratio = v; +} + +size_t +rocksdb_block_based_options_get_super_block_alignment_space_overhead_ratio( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.super_block_alignment_space_overhead_ratio; +} + +void rocksdb_block_based_options_set_index_shortening( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.index_shortening = + static_castrep.index_shortening)>(v); +} + +int rocksdb_block_based_options_get_index_shortening( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.index_shortening); +} + +void rocksdb_block_based_options_set_max_auto_readahead_size( + rocksdb_block_based_table_options_t* opt, size_t v) { + opt->rep.max_auto_readahead_size = v; +} + +size_t rocksdb_block_based_options_get_max_auto_readahead_size( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.max_auto_readahead_size; +} + +void rocksdb_block_based_options_set_prepopulate_block_cache( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.prepopulate_block_cache = + static_castrep.prepopulate_block_cache)>(v); +} + +int rocksdb_block_based_options_get_prepopulate_block_cache( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.prepopulate_block_cache); +} + +void rocksdb_block_based_options_set_initial_auto_readahead_size( + rocksdb_block_based_table_options_t* opt, size_t v) { + opt->rep.initial_auto_readahead_size = v; +} + +size_t rocksdb_block_based_options_get_initial_auto_readahead_size( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.initial_auto_readahead_size; +} + +void rocksdb_block_based_options_set_num_file_reads_for_auto_readahead( + rocksdb_block_based_table_options_t* opt, uint64_t v) { + opt->rep.num_file_reads_for_auto_readahead = v; +} + +uint64_t rocksdb_block_based_options_get_num_file_reads_for_auto_readahead( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.num_file_reads_for_auto_readahead; +} + +/* CuckooTableOptions */ + +void rocksdb_cuckoo_options_set_hash_table_ratio( + rocksdb_cuckoo_table_options_t* opt, double v) { + opt->rep.hash_table_ratio = v; +} + +double rocksdb_cuckoo_options_get_hash_table_ratio( + rocksdb_cuckoo_table_options_t* opt) { + return opt->rep.hash_table_ratio; +} + +void rocksdb_cuckoo_options_set_max_search_depth( + rocksdb_cuckoo_table_options_t* opt, uint32_t v) { + opt->rep.max_search_depth = v; +} + +uint32_t rocksdb_cuckoo_options_get_max_search_depth( + rocksdb_cuckoo_table_options_t* opt) { + return opt->rep.max_search_depth; +} + +void rocksdb_cuckoo_options_set_cuckoo_block_size( + rocksdb_cuckoo_table_options_t* opt, uint32_t v) { + opt->rep.cuckoo_block_size = v; +} + +uint32_t rocksdb_cuckoo_options_get_cuckoo_block_size( + rocksdb_cuckoo_table_options_t* opt) { + return opt->rep.cuckoo_block_size; +} + +void rocksdb_cuckoo_options_set_identity_as_first_hash( + rocksdb_cuckoo_table_options_t* opt, unsigned char v) { + opt->rep.identity_as_first_hash = v; +} + +unsigned char rocksdb_cuckoo_options_get_identity_as_first_hash( + rocksdb_cuckoo_table_options_t* opt) { + return opt->rep.identity_as_first_hash; +} + +void rocksdb_cuckoo_options_set_use_module_hash( + rocksdb_cuckoo_table_options_t* opt, unsigned char v) { + opt->rep.use_module_hash = v; +} + +unsigned char rocksdb_cuckoo_options_get_use_module_hash( + rocksdb_cuckoo_table_options_t* opt) { + return opt->rep.use_module_hash; +} + +/* CompactionOptionsUniversal */ + +void rocksdb_universal_compaction_options_set_max_read_amp( + rocksdb_universal_compaction_options_t* opt, int v) { + opt->rep->max_read_amp = v; +} + +int rocksdb_universal_compaction_options_get_max_read_amp( + rocksdb_universal_compaction_options_t* opt) { + return opt->rep->max_read_amp; +} + +void rocksdb_universal_compaction_options_set_allow_trivial_move( + rocksdb_universal_compaction_options_t* opt, unsigned char v) { + opt->rep->allow_trivial_move = v; +} + +unsigned char rocksdb_universal_compaction_options_get_allow_trivial_move( + rocksdb_universal_compaction_options_t* opt) { + return opt->rep->allow_trivial_move; +} + +void rocksdb_universal_compaction_options_set_incremental( + rocksdb_universal_compaction_options_t* opt, unsigned char v) { + opt->rep->incremental = v; +} + +unsigned char rocksdb_universal_compaction_options_get_incremental( + rocksdb_universal_compaction_options_t* opt) { + return opt->rep->incremental; +} + +void rocksdb_universal_compaction_options_set_reduce_file_locking( + rocksdb_universal_compaction_options_t* opt, unsigned char v) { + opt->rep->reduce_file_locking = v; +} + +unsigned char rocksdb_universal_compaction_options_get_reduce_file_locking( + rocksdb_universal_compaction_options_t* opt) { + return opt->rep->reduce_file_locking; +} + +/* CompactionOptionsFIFO */ + +void rocksdb_fifo_compaction_options_set_age_for_warm( + rocksdb_fifo_compaction_options_t* opt, uint64_t v) { + opt->rep.age_for_warm = v; +} + +uint64_t rocksdb_fifo_compaction_options_get_age_for_warm( + rocksdb_fifo_compaction_options_t* opt) { + return opt->rep.age_for_warm; +} + +void rocksdb_fifo_compaction_options_set_allow_trivial_copy_when_change_temperature( + rocksdb_fifo_compaction_options_t* opt, unsigned char v) { + opt->rep.allow_trivial_copy_when_change_temperature = v; +} + +unsigned char +rocksdb_fifo_compaction_options_get_allow_trivial_copy_when_change_temperature( + rocksdb_fifo_compaction_options_t* opt) { + return opt->rep.allow_trivial_copy_when_change_temperature; +} + +void rocksdb_fifo_compaction_options_set_trivial_copy_buffer_size( + rocksdb_fifo_compaction_options_t* opt, uint64_t v) { + opt->rep.trivial_copy_buffer_size = v; +} + +uint64_t rocksdb_fifo_compaction_options_get_trivial_copy_buffer_size( + rocksdb_fifo_compaction_options_t* opt) { + return opt->rep.trivial_copy_buffer_size; +} + +/* BackupEngineOptions */ + +void rocksdb_backup_engine_options_set_backup_dir( + rocksdb_backup_engine_options_t* opt, const char* v) { + opt->rep.backup_dir = v; +} + +const char* rocksdb_backup_engine_options_get_backup_dir( + rocksdb_backup_engine_options_t* opt, size_t* size) { + *size = opt->rep.backup_dir.size(); + return opt->rep.backup_dir.data(); +} + +void rocksdb_backup_engine_options_set_share_table_files( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.share_table_files = v; +} + +unsigned char rocksdb_backup_engine_options_get_share_table_files( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.share_table_files; +} + +void rocksdb_backup_engine_options_set_sync( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.sync = v; +} + +unsigned char rocksdb_backup_engine_options_get_sync( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.sync; +} + +void rocksdb_backup_engine_options_set_destroy_old_data( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.destroy_old_data = v; +} + +unsigned char rocksdb_backup_engine_options_get_destroy_old_data( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.destroy_old_data; +} + +void rocksdb_backup_engine_options_set_backup_log_files( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.backup_log_files = v; +} + +unsigned char rocksdb_backup_engine_options_get_backup_log_files( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.backup_log_files; +} + +void rocksdb_backup_engine_options_set_io_buffer_size( + rocksdb_backup_engine_options_t* opt, uint64_t v) { + opt->rep.io_buffer_size = v; +} + +uint64_t rocksdb_backup_engine_options_get_io_buffer_size( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.io_buffer_size; +} + +void rocksdb_backup_engine_options_set_backup_rate_limit( + rocksdb_backup_engine_options_t* opt, uint64_t v) { + opt->rep.backup_rate_limit = v; +} + +uint64_t rocksdb_backup_engine_options_get_backup_rate_limit( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.backup_rate_limit; +} + +void rocksdb_backup_engine_options_set_restore_rate_limit( + rocksdb_backup_engine_options_t* opt, uint64_t v) { + opt->rep.restore_rate_limit = v; +} + +uint64_t rocksdb_backup_engine_options_get_restore_rate_limit( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.restore_rate_limit; +} + +void rocksdb_backup_engine_options_set_share_files_with_checksum( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.share_files_with_checksum = v; +} + +unsigned char rocksdb_backup_engine_options_get_share_files_with_checksum( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.share_files_with_checksum; +} + +void rocksdb_backup_engine_options_set_max_background_operations( + rocksdb_backup_engine_options_t* opt, int v) { + opt->rep.max_background_operations = v; +} + +int rocksdb_backup_engine_options_get_max_background_operations( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.max_background_operations; +} + +void rocksdb_backup_engine_options_set_callback_trigger_interval_size( + rocksdb_backup_engine_options_t* opt, uint64_t v) { + opt->rep.callback_trigger_interval_size = v; +} + +uint64_t rocksdb_backup_engine_options_get_callback_trigger_interval_size( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.callback_trigger_interval_size; +} + +void rocksdb_backup_engine_options_set_max_valid_backups_to_open( + rocksdb_backup_engine_options_t* opt, int v) { + opt->rep.max_valid_backups_to_open = v; +} + +int rocksdb_backup_engine_options_get_max_valid_backups_to_open( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.max_valid_backups_to_open; +} + +void rocksdb_backup_engine_options_set_share_files_with_checksum_naming( + rocksdb_backup_engine_options_t* opt, int v) { + opt->rep.share_files_with_checksum_naming = + static_castrep.share_files_with_checksum_naming)>(v); +} + +int rocksdb_backup_engine_options_get_share_files_with_checksum_naming( + rocksdb_backup_engine_options_t* opt) { + return static_cast(opt->rep.share_files_with_checksum_naming); +} + +void rocksdb_backup_engine_options_set_schema_version( + rocksdb_backup_engine_options_t* opt, int v) { + opt->rep.schema_version = v; +} + +int rocksdb_backup_engine_options_get_schema_version( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.schema_version; +} + +void rocksdb_backup_engine_options_set_current_temperatures_override_manifest( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.current_temperatures_override_manifest = v; +} + +unsigned char +rocksdb_backup_engine_options_get_current_temperatures_override_manifest( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.current_temperatures_override_manifest; +} + +/* CreateBackupOptions */ + +void rocksdb_create_backup_options_set_flush_before_backup( + rocksdb_create_backup_options_t* opt, unsigned char v) { + opt->rep.flush_before_backup = v; +} + +unsigned char rocksdb_create_backup_options_get_flush_before_backup( + rocksdb_create_backup_options_t* opt) { + return opt->rep.flush_before_backup; +} + +void rocksdb_create_backup_options_set_decrease_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt, unsigned char v) { + opt->rep.decrease_background_thread_cpu_priority = v; +} + +unsigned char +rocksdb_create_backup_options_get_decrease_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt) { + return opt->rep.decrease_background_thread_cpu_priority; +} + +void rocksdb_create_backup_options_set_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt, int v) { + opt->rep.background_thread_cpu_priority = + static_castrep.background_thread_cpu_priority)>(v); +} + +int rocksdb_create_backup_options_get_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt) { + return static_cast(opt->rep.background_thread_cpu_priority); +} + +void rocksdb_create_backup_options_set_atomic_flush( + rocksdb_create_backup_options_t* opt, unsigned char v) { + opt->rep.atomic_flush = v; +} + +unsigned char rocksdb_create_backup_options_get_atomic_flush( + rocksdb_create_backup_options_t* opt) { + return opt->rep.atomic_flush; +} + +/* RestoreOptions */ + +void rocksdb_restore_options_set_keep_log_files(rocksdb_restore_options_t* opt, + int v) { + opt->rep.keep_log_files = static_castrep.keep_log_files)>(v); +} + +unsigned char rocksdb_restore_options_get_keep_log_files( + rocksdb_restore_options_t* opt) { + return opt->rep.keep_log_files; +} + +void rocksdb_restore_options_set_mode(rocksdb_restore_options_t* opt, int v) { + opt->rep.mode = static_castrep.mode)>(v); +} + +int rocksdb_restore_options_get_mode(rocksdb_restore_options_t* opt) { + return static_cast(opt->rep.mode); +} + +/* TransactionDBOptions */ + +void rocksdb_transactiondb_options_set_max_num_locks( + rocksdb_transactiondb_options_t* opt, int64_t v) { + opt->rep.max_num_locks = v; +} + +int64_t rocksdb_transactiondb_options_get_max_num_locks( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.max_num_locks; +} + +void rocksdb_transactiondb_options_set_max_num_deadlocks( + rocksdb_transactiondb_options_t* opt, uint32_t v) { + opt->rep.max_num_deadlocks = v; +} + +uint32_t rocksdb_transactiondb_options_get_max_num_deadlocks( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.max_num_deadlocks; +} + +void rocksdb_transactiondb_options_set_num_stripes( + rocksdb_transactiondb_options_t* opt, size_t v) { + opt->rep.num_stripes = v; +} + +size_t rocksdb_transactiondb_options_get_num_stripes( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.num_stripes; +} + +void rocksdb_transactiondb_options_set_transaction_lock_timeout( + rocksdb_transactiondb_options_t* opt, int64_t v) { + opt->rep.transaction_lock_timeout = v; +} + +int64_t rocksdb_transactiondb_options_get_transaction_lock_timeout( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.transaction_lock_timeout; +} + +void rocksdb_transactiondb_options_set_default_lock_timeout( + rocksdb_transactiondb_options_t* opt, int64_t v) { + opt->rep.default_lock_timeout = v; +} + +int64_t rocksdb_transactiondb_options_get_default_lock_timeout( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.default_lock_timeout; +} + +void rocksdb_transactiondb_options_set_write_policy( + rocksdb_transactiondb_options_t* opt, int v) { + opt->rep.write_policy = static_castrep.write_policy)>(v); +} + +int rocksdb_transactiondb_options_get_write_policy( + rocksdb_transactiondb_options_t* opt) { + return static_cast(opt->rep.write_policy); +} + +void rocksdb_transactiondb_options_set_rollback_merge_operands( + rocksdb_transactiondb_options_t* opt, unsigned char v) { + opt->rep.rollback_merge_operands = v; +} + +unsigned char rocksdb_transactiondb_options_get_rollback_merge_operands( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.rollback_merge_operands; +} + +void rocksdb_transactiondb_options_set_use_per_key_point_lock_mgr( + rocksdb_transactiondb_options_t* opt, unsigned char v) { + opt->rep.use_per_key_point_lock_mgr = v; +} + +unsigned char rocksdb_transactiondb_options_get_use_per_key_point_lock_mgr( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.use_per_key_point_lock_mgr; +} + +void rocksdb_transactiondb_options_set_skip_concurrency_control( + rocksdb_transactiondb_options_t* opt, unsigned char v) { + opt->rep.skip_concurrency_control = v; +} + +unsigned char rocksdb_transactiondb_options_get_skip_concurrency_control( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.skip_concurrency_control; +} + +void rocksdb_transactiondb_options_set_default_write_batch_flush_threshold( + rocksdb_transactiondb_options_t* opt, int64_t v) { + opt->rep.default_write_batch_flush_threshold = v; +} + +int64_t rocksdb_transactiondb_options_get_default_write_batch_flush_threshold( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.default_write_batch_flush_threshold; +} + +void rocksdb_transactiondb_options_set_enable_udt_validation( + rocksdb_transactiondb_options_t* opt, unsigned char v) { + opt->rep.enable_udt_validation = v; +} + +unsigned char rocksdb_transactiondb_options_get_enable_udt_validation( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.enable_udt_validation; +} + +void rocksdb_transactiondb_options_set_txn_commit_bypass_memtable_threshold( + rocksdb_transactiondb_options_t* opt, uint32_t v) { + opt->rep.txn_commit_bypass_memtable_threshold = v; +} + +uint32_t rocksdb_transactiondb_options_get_txn_commit_bypass_memtable_threshold( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.txn_commit_bypass_memtable_threshold; +} + +/* TransactionOptions */ + +void rocksdb_transaction_options_set_set_snapshot( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.set_snapshot = v; +} + +unsigned char rocksdb_transaction_options_get_set_snapshot( + rocksdb_transaction_options_t* opt) { + return opt->rep.set_snapshot; +} + +void rocksdb_transaction_options_set_deadlock_detect( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.deadlock_detect = v; +} + +unsigned char rocksdb_transaction_options_get_deadlock_detect( + rocksdb_transaction_options_t* opt) { + return opt->rep.deadlock_detect; +} + +void rocksdb_transaction_options_set_use_only_the_last_commit_time_batch_for_recovery( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.use_only_the_last_commit_time_batch_for_recovery = v; +} + +unsigned char +rocksdb_transaction_options_get_use_only_the_last_commit_time_batch_for_recovery( + rocksdb_transaction_options_t* opt) { + return opt->rep.use_only_the_last_commit_time_batch_for_recovery; +} + +void rocksdb_transaction_options_set_lock_timeout( + rocksdb_transaction_options_t* opt, int64_t v) { + opt->rep.lock_timeout = v; +} + +int64_t rocksdb_transaction_options_get_lock_timeout( + rocksdb_transaction_options_t* opt) { + return opt->rep.lock_timeout; +} + +void rocksdb_transaction_options_set_deadlock_timeout_us( + rocksdb_transaction_options_t* opt, int64_t v) { + opt->rep.deadlock_timeout_us = v; +} + +int64_t rocksdb_transaction_options_get_deadlock_timeout_us( + rocksdb_transaction_options_t* opt) { + return opt->rep.deadlock_timeout_us; +} + +void rocksdb_transaction_options_set_expiration( + rocksdb_transaction_options_t* opt, int64_t v) { + opt->rep.expiration = v; +} + +int64_t rocksdb_transaction_options_get_expiration( + rocksdb_transaction_options_t* opt) { + return opt->rep.expiration; +} + +void rocksdb_transaction_options_set_deadlock_detect_depth( + rocksdb_transaction_options_t* opt, int64_t v) { + opt->rep.deadlock_detect_depth = v; +} + +int64_t rocksdb_transaction_options_get_deadlock_detect_depth( + rocksdb_transaction_options_t* opt) { + return opt->rep.deadlock_detect_depth; +} + +void rocksdb_transaction_options_set_max_write_batch_size( + rocksdb_transaction_options_t* opt, size_t v) { + opt->rep.max_write_batch_size = v; +} + +size_t rocksdb_transaction_options_get_max_write_batch_size( + rocksdb_transaction_options_t* opt) { + return opt->rep.max_write_batch_size; +} + +void rocksdb_transaction_options_set_skip_concurrency_control( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.skip_concurrency_control = v; +} + +unsigned char rocksdb_transaction_options_get_skip_concurrency_control( + rocksdb_transaction_options_t* opt) { + return opt->rep.skip_concurrency_control; +} + +void rocksdb_transaction_options_set_skip_prepare( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.skip_prepare = v; +} + +unsigned char rocksdb_transaction_options_get_skip_prepare( + rocksdb_transaction_options_t* opt) { + return opt->rep.skip_prepare; +} + +void rocksdb_transaction_options_set_write_batch_flush_threshold( + rocksdb_transaction_options_t* opt, int64_t v) { + opt->rep.write_batch_flush_threshold = v; +} + +int64_t rocksdb_transaction_options_get_write_batch_flush_threshold( + rocksdb_transaction_options_t* opt) { + return opt->rep.write_batch_flush_threshold; +} + +void rocksdb_transaction_options_set_write_batch_track_timestamp_size( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.write_batch_track_timestamp_size = v; +} + +unsigned char rocksdb_transaction_options_get_write_batch_track_timestamp_size( + rocksdb_transaction_options_t* opt) { + return opt->rep.write_batch_track_timestamp_size; +} + +void rocksdb_transaction_options_set_commit_bypass_memtable( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.commit_bypass_memtable = v; +} + +unsigned char rocksdb_transaction_options_get_commit_bypass_memtable( + rocksdb_transaction_options_t* opt) { + return opt->rep.commit_bypass_memtable; +} + +void rocksdb_transaction_options_set_large_txn_commit_optimize_threshold( + rocksdb_transaction_options_t* opt, uint32_t v) { + opt->rep.large_txn_commit_optimize_threshold = v; +} + +uint32_t rocksdb_transaction_options_get_large_txn_commit_optimize_threshold( + rocksdb_transaction_options_t* opt) { + return opt->rep.large_txn_commit_optimize_threshold; +} + +void rocksdb_transaction_options_set_large_txn_commit_optimize_byte_threshold( + rocksdb_transaction_options_t* opt, uint64_t v) { + opt->rep.large_txn_commit_optimize_byte_threshold = v; +} + +uint64_t +rocksdb_transaction_options_get_large_txn_commit_optimize_byte_threshold( + rocksdb_transaction_options_t* opt) { + return opt->rep.large_txn_commit_optimize_byte_threshold; +} + +/* OptimisticTransactionOptions */ + +void rocksdb_optimistictransaction_options_set_set_snapshot( + rocksdb_optimistictransaction_options_t* opt, unsigned char v) { + opt->rep.set_snapshot = v; +} + +unsigned char rocksdb_optimistictransaction_options_get_set_snapshot( + rocksdb_optimistictransaction_options_t* opt) { + return opt->rep.set_snapshot; +} + +/* OptimisticTransactionDBOptions */ + +void rocksdb_optimistictransactiondb_options_set_validate_policy( + rocksdb_optimistictransactiondb_options_t* opt, int v) { + opt->rep.validate_policy = static_castrep.validate_policy)>(v); +} + +int rocksdb_optimistictransactiondb_options_get_validate_policy( + rocksdb_optimistictransactiondb_options_t* opt) { + return static_cast(opt->rep.validate_policy); +} + +void rocksdb_optimistictransactiondb_options_set_occ_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt, uint32_t v) { + opt->rep.occ_lock_buckets = v; +} + +uint32_t rocksdb_optimistictransactiondb_options_get_occ_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt) { + return opt->rep.occ_lock_buckets; +} diff --git a/c_api_gen/c_generated_option_structs_auto.h.inc b/c_api_gen/c_generated_option_structs_auto.h.inc new file mode 100644 index 0000000000..1a9ce4abf0 --- /dev/null +++ b/c_api_gen/c_generated_option_structs_auto.h.inc @@ -0,0 +1,1713 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/advanced_options.h +// - include/rocksdb/block_cache_trace_writer.h +// - include/rocksdb/env.h +// - include/rocksdb/metadata.h +// - include/rocksdb/options.h +// - include/rocksdb/table.h +// - include/rocksdb/universal_compaction.h +// - include/rocksdb/utilities/backup_engine.h +// - include/rocksdb/utilities/optimistic_transaction_db.h +// - include/rocksdb/utilities/transaction_db.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered option structs simple + +/* DBOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_flush_verify_memtable_count( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_flush_verify_memtable_count(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_compaction_verify_record_count(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_compaction_verify_record_count(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_track_and_verify_wals( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_track_and_verify_wals(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_verify_sst_unique_id_in_manifest(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_verify_sst_unique_id_in_manifest(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_options_get_db_log_dir( + rocksdb_options_t* opt, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_options_get_wal_dir( + rocksdb_options_t* opt, size_t* size); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_async_wal_precreate( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_async_wal_precreate(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_verify_manifest_content_on_close(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_verify_manifest_content_on_close(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_optimize_manifest_for_recovery(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_optimize_manifest_for_recovery(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_reuse_manifest_on_open( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_reuse_manifest_on_open(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_manifest_space_amp_pct( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_max_manifest_space_amp_pct( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_use_direct_io_for_compaction_reads(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_use_direct_io_for_compaction_reads(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_fallocate( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_allow_fallocate( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_persist_stats_to_disk( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_persist_stats_to_disk(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_stats_history_buffer_size( + rocksdb_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_stats_history_buffer_size(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_strict_bytes_per_sync( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_strict_bytes_per_sync(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_enable_thread_tracking( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_enable_thread_tracking(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_delayed_write_rate( + rocksdb_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_delayed_write_rate(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_max_write_batch_group_size_bytes(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_max_write_batch_group_size_bytes(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_thread_max_yield_usec( + rocksdb_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_write_thread_max_yield_usec(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_write_thread_slow_yield_usec(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_write_thread_slow_yield_usec(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_2pc( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_allow_2pc( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_dump_malloc_stats( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_avoid_flush_during_recovery( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_avoid_flush_during_recovery(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_enforce_write_buffer_manager_during_recovery( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_enforce_write_buffer_manager_during_recovery( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_avoid_flush_during_shutdown( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_avoid_flush_during_shutdown(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_two_write_queues( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_two_write_queues( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_background_close_inactive_wals(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_background_close_inactive_wals(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_prefix_seek_opt_in_only( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_prefix_seek_opt_in_only(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_log_readahead_size( + rocksdb_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_log_readahead_size(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_best_efforts_recovery( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_best_efforts_recovery(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_bgerror_resume_count( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_max_bgerror_resume_count( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_bgerror_resume_retry_interval(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_bgerror_resume_retry_interval(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_data_in_errors( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_allow_data_in_errors(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_db_host_id( + rocksdb_options_t* opt, const char* v); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_options_get_db_host_id( + rocksdb_options_t* opt, size_t* size); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_lowest_used_cache_tier( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_lowest_used_cache_tier( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_enforce_single_del_contracts(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_enforce_single_del_contracts(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_daily_offpeak_time_utc( + rocksdb_options_t* opt, const char* v); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_options_get_daily_offpeak_time_utc(rocksdb_options_t* opt, + size_t* size); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_follower_refresh_catchup_period_ms(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_follower_refresh_catchup_period_ms(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_follower_catchup_retry_count(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_follower_catchup_retry_count(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_follower_catchup_retry_wait_ms(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_follower_catchup_retry_wait_ms(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_metadata_write_temperature( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_metadata_write_temperature( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_wal_write_temperature( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_wal_write_temperature( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_fast_sst_open( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_fast_sst_open( + rocksdb_options_t* opt); + +/* AdvancedColumnFamilyOptions */ + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_memtable_whole_key_filtering(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_target_file_size_is_upper_bound(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_target_file_size_is_upper_bound(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_strict_max_successive_merges(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_strict_max_successive_merges(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_paranoid_file_checks( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_paranoid_file_checks(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_verify_output_flags( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_verify_output_flags( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_force_consistency_checks( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_force_consistency_checks(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_disallow_memtable_writes( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_disallow_memtable_writes(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_sample_for_compression( + rocksdb_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_sample_for_compression(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_last_level_temperature( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_last_level_temperature( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_default_write_temperature( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_default_write_temperature( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_default_temperature( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_default_temperature( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_preclude_last_level_data_seconds(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_preclude_last_level_data_seconds(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_preserve_internal_time_seconds(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_preserve_internal_time_seconds(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_enable_blob_direct_write( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_enable_blob_direct_write(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_blob_direct_write_partitions(rocksdb_options_t* opt, + uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_blob_direct_write_partitions(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_protection_bytes_per_key(rocksdb_options_t* opt, + uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_memtable_protection_bytes_per_key(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_persist_user_defined_timestamps(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_persist_user_defined_timestamps(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_block_protection_bytes_per_key(rocksdb_options_t* opt, + uint8_t v); + +extern ROCKSDB_LIBRARY_API uint8_t +rocksdb_options_get_block_protection_bytes_per_key(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_bottommost_file_compaction_delay(rocksdb_options_t* opt, + uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_bottommost_file_compaction_delay(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_paranoid_memory_checks( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_paranoid_memory_checks(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_verify_per_key_checksum_on_seek( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_memtable_verify_per_key_checksum_on_seek( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_cf_allow_ingest_behind( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_cf_allow_ingest_behind(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_batch_lookup_optimization(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_memtable_batch_lookup_optimization(rocksdb_options_t* opt); + +/* ColumnFamilyOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_max_range_deletions(rocksdb_options_t* opt, + uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_memtable_max_range_deletions(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_uncache_aggressiveness( + rocksdb_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_uncache_aggressiveness(rocksdb_options_t* opt); + +/* WriteOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_sync( + rocksdb_writeoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_sync( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_disable_WAL( + rocksdb_writeoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_disable_WAL( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_writeoptions_set_ignore_missing_column_families( + rocksdb_writeoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_writeoptions_get_ignore_missing_column_families( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_no_slowdown( + rocksdb_writeoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_no_slowdown( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_low_pri( + rocksdb_writeoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_low_pri( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_writeoptions_set_memtable_insert_hint_per_batch( + rocksdb_writeoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_writeoptions_get_memtable_insert_hint_per_batch( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_rate_limiter_priority( + rocksdb_writeoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_writeoptions_get_rate_limiter_priority( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_writeoptions_set_protection_bytes_per_key(rocksdb_writeoptions_t* opt, + size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_writeoptions_get_protection_bytes_per_key(rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_io_activity( + rocksdb_writeoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_writeoptions_get_io_activity( + rocksdb_writeoptions_t* opt); + +/* FlushOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_flushoptions_set_wait( + rocksdb_flushoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_flushoptions_get_wait( + rocksdb_flushoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_flushoptions_set_allow_write_stall( + rocksdb_flushoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_flushoptions_get_allow_write_stall(rocksdb_flushoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_flushoptions_set_force_atomic_flush( + rocksdb_flushoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_flushoptions_get_force_atomic_flush(rocksdb_flushoptions_t* opt); + +/* FlushWALOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_flushwaloptions_set_sync( + rocksdb_flushwaloptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_flushwaloptions_get_sync( + rocksdb_flushwaloptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_flushwaloptions_set_rate_limiter_priority( + rocksdb_flushwaloptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_flushwaloptions_get_rate_limiter_priority( + rocksdb_flushwaloptions_t* opt); + +/* EnvOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_use_mmap_reads( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_envoptions_get_use_mmap_reads( + rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_use_mmap_writes( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_envoptions_get_use_mmap_writes( + rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_use_direct_reads( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_envoptions_get_use_direct_reads(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_use_direct_writes( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_envoptions_get_use_direct_writes(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_allow_fallocate( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_envoptions_get_allow_fallocate( + rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_fd_cloexec( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_envoptions_get_fd_cloexec( + rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_bytes_per_sync( + rocksdb_envoptions_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_envoptions_get_bytes_per_sync(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_strict_bytes_per_sync( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_envoptions_get_strict_bytes_per_sync(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_fallocate_with_keep_size( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_envoptions_get_fallocate_with_keep_size(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_envoptions_set_compaction_readahead_size(rocksdb_envoptions_t* opt, + size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_envoptions_get_compaction_readahead_size(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_envoptions_set_writable_file_max_buffer_size(rocksdb_envoptions_t* opt, + size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_envoptions_get_writable_file_max_buffer_size(rocksdb_envoptions_t* opt); + +/* TraceOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_trace_options_set_max_trace_file_size( + rocksdb_trace_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_trace_options_get_max_trace_file_size(rocksdb_trace_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_trace_options_set_sampling_frequency( + rocksdb_trace_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_trace_options_get_sampling_frequency(rocksdb_trace_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_trace_options_set_filter( + rocksdb_trace_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_trace_options_get_filter(rocksdb_trace_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_trace_options_set_preserve_write_order( + rocksdb_trace_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_trace_options_get_preserve_write_order(rocksdb_trace_options_t* opt); + +/* BlockCacheTraceOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_cache_trace_options_set_sampling_frequency( + rocksdb_block_cache_trace_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_block_cache_trace_options_get_sampling_frequency( + rocksdb_block_cache_trace_options_t* opt); + +/* BlockCacheTraceWriterOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_cache_trace_writer_options_set_max_trace_file_size( + rocksdb_block_cache_trace_writer_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_block_cache_trace_writer_options_get_max_trace_file_size( + rocksdb_block_cache_trace_writer_options_t* opt); + +/* CompactionOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_compaction_options_set_compression( + rocksdb_compaction_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_compaction_options_get_compression( + rocksdb_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_options_set_output_file_size_limit( + rocksdb_compaction_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_options_get_output_file_size_limit( + rocksdb_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_options_set_max_subcompactions( + rocksdb_compaction_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_compaction_options_get_max_subcompactions( + rocksdb_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_options_set_output_temperature_override( + rocksdb_compaction_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_compaction_options_get_output_temperature_override( + rocksdb_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_options_set_allow_trivial_move( + rocksdb_compaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compaction_options_get_allow_trivial_move( + rocksdb_compaction_options_t* opt); + +/* CompactRangeOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_compactoptions_set_blob_garbage_collection_policy( + rocksdb_compactoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_compactoptions_get_blob_garbage_collection_policy( + rocksdb_compactoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compactoptions_set_blob_garbage_collection_age_cutoff( + rocksdb_compactoptions_t* opt, double v); + +extern ROCKSDB_LIBRARY_API double +rocksdb_compactoptions_get_blob_garbage_collection_age_cutoff( + rocksdb_compactoptions_t* opt); + +/* IngestExternalFileOptions */ + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_move_files( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_link_files( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_link_files( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_failed_move_fall_back_to_copy( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_failed_move_fall_back_to_copy( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_snapshot_consistency( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_allow_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_allow_blocking_flush( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_ingest_behind( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_write_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_write_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_verify_checksums_before_ingest( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_verify_checksums_before_ingest( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_verify_checksums_readahead_size( + rocksdb_ingestexternalfileoptions_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_ingestexternalfileoptions_get_verify_checksums_readahead_size( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_verify_file_checksum( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_verify_file_checksum( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_fail_if_not_bottommost_level( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_allow_db_generated_files( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_allow_db_generated_files( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_fill_cache( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_fill_cache( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_prefetch_lmax_index_and_filter_blocks( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_prefetch_lmax_index_and_filter_blocks( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_file_opening_threads( + rocksdb_ingestexternalfileoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_ingestexternalfileoptions_get_file_opening_threads( + rocksdb_ingestexternalfileoptions_t* opt); + +/* OpenAndCompactOptions */ + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_open_and_compact_options_get_allow_resumption( + rocksdb_open_and_compact_options_t* opt); + +/* ImportColumnFamilyOptions */ + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_import_column_family_options_get_move_files( + rocksdb_import_column_family_options_t* opt); + +/* SizeApproximationOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_size_approximation_options_set_include_memtables( + rocksdb_size_approximation_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_size_approximation_options_get_include_memtables( + rocksdb_size_approximation_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_size_approximation_options_set_include_files( + rocksdb_size_approximation_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_size_approximation_options_get_include_files( + rocksdb_size_approximation_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_size_approximation_options_set_include_blob_files( + rocksdb_size_approximation_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_size_approximation_options_get_include_blob_files( + rocksdb_size_approximation_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_size_approximation_options_set_files_size_error_margin( + rocksdb_size_approximation_options_t* opt, double v); + +extern ROCKSDB_LIBRARY_API double +rocksdb_size_approximation_options_get_files_size_error_margin( + rocksdb_size_approximation_options_t* opt); + +/* LiveFilesStorageInfoOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_livefiles_storage_info_options_set_include_checksum_info( + rocksdb_livefiles_storage_info_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_livefiles_storage_info_options_get_include_checksum_info( + rocksdb_livefiles_storage_info_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_livefiles_storage_info_options_set_wal_size_for_flush( + rocksdb_livefiles_storage_info_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_livefiles_storage_info_options_get_wal_size_for_flush( + rocksdb_livefiles_storage_info_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_livefiles_storage_info_options_set_atomic_flush( + rocksdb_livefiles_storage_info_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_livefiles_storage_info_options_get_atomic_flush( + rocksdb_livefiles_storage_info_options_t* opt); + +/* GetColumnFamilyMetaDataOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_column_family_metadata_options_set_level( + rocksdb_column_family_metadata_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_column_family_metadata_options_get_level( + rocksdb_column_family_metadata_options_t* opt); + +/* WaitForCompactOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_wait_for_compact_options_set_wait_for_purge( + rocksdb_wait_for_compact_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_wait_for_compact_options_get_wait_for_purge( + rocksdb_wait_for_compact_options_t* opt); + +/* BlockBasedTableOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_cache_index_and_filter_blocks( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_cache_index_and_filter_blocks( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_cache_index_and_filter_blocks_with_high_priority( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_pin_l0_filter_and_index_blocks_in_cache( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_pin_top_level_index_and_filter( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_pin_top_level_index_and_filter( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_index_type( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_block_based_options_get_index_type( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_index_block_search_type( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_index_block_search_type( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_data_block_index_type( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_data_block_index_type( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_data_block_hash_table_util_ratio( + rocksdb_block_based_table_options_t* opt, double v); + +extern ROCKSDB_LIBRARY_API double +rocksdb_block_based_options_get_data_block_hash_table_util_ratio( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_checksum( + rocksdb_block_based_table_options_t* opt, char v); + +extern ROCKSDB_LIBRARY_API int rocksdb_block_based_options_get_checksum( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_no_block_cache( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_no_block_cache( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_block_size( + rocksdb_block_based_table_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_block_based_options_get_block_size( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_block_size_deviation( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_block_size_deviation( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_block_restart_interval( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_block_restart_interval( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_index_block_restart_interval( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_index_block_restart_interval( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_metadata_block_size( + rocksdb_block_based_table_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_block_based_options_get_metadata_block_size( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_partition_filters( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_partition_filters( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_decouple_partitioned_filters( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_decouple_partitioned_filters( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_optimize_filters_for_memory( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_optimize_filters_for_memory( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_use_delta_encoding( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_use_delta_encoding( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_use_udi_as_primary_index( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_use_udi_as_primary_index( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_fail_if_no_udi_on_open( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_fail_if_no_udi_on_open( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_whole_key_filtering( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_whole_key_filtering( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_detect_filter_construct_corruption( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_detect_filter_construct_corruption( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_verify_compression( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_verify_compression( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_read_amp_bytes_per_bit( + rocksdb_block_based_table_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_block_based_options_get_read_amp_bytes_per_bit( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_format_version( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_block_based_options_get_format_version( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_separate_key_value_in_data_block( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_separate_key_value_in_data_block( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_uniform_cv_threshold( + rocksdb_block_based_table_options_t* opt, double v); + +extern ROCKSDB_LIBRARY_API double +rocksdb_block_based_options_get_uniform_cv_threshold( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_enable_index_compression( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_enable_index_compression( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_block_align( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_block_align( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_super_block_alignment_size( + rocksdb_block_based_table_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_block_based_options_get_super_block_alignment_size( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_super_block_alignment_space_overhead_ratio( + rocksdb_block_based_table_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_block_based_options_get_super_block_alignment_space_overhead_ratio( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_index_shortening( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_block_based_options_get_index_shortening( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_max_auto_readahead_size( + rocksdb_block_based_table_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_block_based_options_get_max_auto_readahead_size( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_prepopulate_block_cache( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_prepopulate_block_cache( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_initial_auto_readahead_size( + rocksdb_block_based_table_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_block_based_options_get_initial_auto_readahead_size( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_num_file_reads_for_auto_readahead( + rocksdb_block_based_table_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_block_based_options_get_num_file_reads_for_auto_readahead( + rocksdb_block_based_table_options_t* opt); + +/* CuckooTableOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_hash_table_ratio( + rocksdb_cuckoo_table_options_t* opt, double v); + +extern ROCKSDB_LIBRARY_API double rocksdb_cuckoo_options_get_hash_table_ratio( + rocksdb_cuckoo_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_max_search_depth( + rocksdb_cuckoo_table_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t rocksdb_cuckoo_options_get_max_search_depth( + rocksdb_cuckoo_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_cuckoo_block_size( + rocksdb_cuckoo_table_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_cuckoo_options_get_cuckoo_block_size( + rocksdb_cuckoo_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_cuckoo_options_set_identity_as_first_hash( + rocksdb_cuckoo_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_cuckoo_options_get_identity_as_first_hash( + rocksdb_cuckoo_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_use_module_hash( + rocksdb_cuckoo_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_cuckoo_options_get_use_module_hash(rocksdb_cuckoo_table_options_t* opt); + +/* CompactionOptionsUniversal */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_max_read_amp( + rocksdb_universal_compaction_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_universal_compaction_options_get_max_read_amp( + rocksdb_universal_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_allow_trivial_move( + rocksdb_universal_compaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_universal_compaction_options_get_allow_trivial_move( + rocksdb_universal_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_incremental( + rocksdb_universal_compaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_universal_compaction_options_get_incremental( + rocksdb_universal_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_reduce_file_locking( + rocksdb_universal_compaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_universal_compaction_options_get_reduce_file_locking( + rocksdb_universal_compaction_options_t* opt); + +/* CompactionOptionsFIFO */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_fifo_compaction_options_set_age_for_warm( + rocksdb_fifo_compaction_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_fifo_compaction_options_get_age_for_warm( + rocksdb_fifo_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_fifo_compaction_options_set_allow_trivial_copy_when_change_temperature( + rocksdb_fifo_compaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_fifo_compaction_options_get_allow_trivial_copy_when_change_temperature( + rocksdb_fifo_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_fifo_compaction_options_set_trivial_copy_buffer_size( + rocksdb_fifo_compaction_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_fifo_compaction_options_get_trivial_copy_buffer_size( + rocksdb_fifo_compaction_options_t* opt); + +/* BackupEngineOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_set_backup_dir( + rocksdb_backup_engine_options_t* opt, const char* v); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_backup_engine_options_get_backup_dir( + rocksdb_backup_engine_options_t* opt, size_t* size); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_share_table_files( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_backup_engine_options_get_share_table_files( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_set_sync( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_backup_engine_options_get_sync( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_destroy_old_data( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_backup_engine_options_get_destroy_old_data( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_backup_log_files( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_backup_engine_options_get_backup_log_files( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_io_buffer_size( + rocksdb_backup_engine_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_backup_engine_options_get_io_buffer_size( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_backup_rate_limit( + rocksdb_backup_engine_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_backup_engine_options_get_backup_rate_limit( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_restore_rate_limit( + rocksdb_backup_engine_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_backup_engine_options_get_restore_rate_limit( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_share_files_with_checksum( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_backup_engine_options_get_share_files_with_checksum( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_max_background_operations( + rocksdb_backup_engine_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_backup_engine_options_get_max_background_operations( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_callback_trigger_interval_size( + rocksdb_backup_engine_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_backup_engine_options_get_callback_trigger_interval_size( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_max_valid_backups_to_open( + rocksdb_backup_engine_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_backup_engine_options_get_max_valid_backups_to_open( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_share_files_with_checksum_naming( + rocksdb_backup_engine_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_backup_engine_options_get_share_files_with_checksum_naming( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_schema_version( + rocksdb_backup_engine_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_backup_engine_options_get_schema_version( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_current_temperatures_override_manifest( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_backup_engine_options_get_current_temperatures_override_manifest( + rocksdb_backup_engine_options_t* opt); + +/* CreateBackupOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_create_backup_options_set_flush_before_backup( + rocksdb_create_backup_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_create_backup_options_get_flush_before_backup( + rocksdb_create_backup_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_create_backup_options_set_decrease_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_create_backup_options_get_decrease_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_create_backup_options_set_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_create_backup_options_get_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_create_backup_options_set_atomic_flush( + rocksdb_create_backup_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_create_backup_options_get_atomic_flush( + rocksdb_create_backup_options_t* opt); + +/* RestoreOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_restore_options_set_keep_log_files( + rocksdb_restore_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_restore_options_get_keep_log_files(rocksdb_restore_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_restore_options_set_mode( + rocksdb_restore_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_restore_options_get_mode( + rocksdb_restore_options_t* opt); + +/* TransactionDBOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_set_max_num_locks( + rocksdb_transactiondb_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transactiondb_options_get_max_num_locks( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_max_num_deadlocks( + rocksdb_transactiondb_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_transactiondb_options_get_max_num_deadlocks( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_set_num_stripes( + rocksdb_transactiondb_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_transactiondb_options_get_num_stripes( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_transaction_lock_timeout( + rocksdb_transactiondb_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transactiondb_options_get_transaction_lock_timeout( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_default_lock_timeout( + rocksdb_transactiondb_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transactiondb_options_get_default_lock_timeout( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_set_write_policy( + rocksdb_transactiondb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_transactiondb_options_get_write_policy( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_rollback_merge_operands( + rocksdb_transactiondb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transactiondb_options_get_rollback_merge_operands( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_use_per_key_point_lock_mgr( + rocksdb_transactiondb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transactiondb_options_get_use_per_key_point_lock_mgr( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_skip_concurrency_control( + rocksdb_transactiondb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transactiondb_options_get_skip_concurrency_control( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_default_write_batch_flush_threshold( + rocksdb_transactiondb_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transactiondb_options_get_default_write_batch_flush_threshold( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_enable_udt_validation( + rocksdb_transactiondb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transactiondb_options_get_enable_udt_validation( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_txn_commit_bypass_memtable_threshold( + rocksdb_transactiondb_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_transactiondb_options_get_txn_commit_bypass_memtable_threshold( + rocksdb_transactiondb_options_t* opt); + +/* TransactionOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_set_snapshot( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_set_snapshot( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_deadlock_detect( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_deadlock_detect( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_use_only_the_last_commit_time_batch_for_recovery( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_use_only_the_last_commit_time_batch_for_recovery( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_lock_timeout( + rocksdb_transaction_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t rocksdb_transaction_options_get_lock_timeout( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_deadlock_timeout_us( + rocksdb_transaction_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transaction_options_get_deadlock_timeout_us( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_expiration( + rocksdb_transaction_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transaction_options_get_expiration(rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_deadlock_detect_depth( + rocksdb_transaction_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transaction_options_get_deadlock_detect_depth( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_max_write_batch_size( + rocksdb_transaction_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_transaction_options_get_max_write_batch_size( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_skip_concurrency_control( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_skip_concurrency_control( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_skip_prepare( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_skip_prepare( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_write_batch_flush_threshold( + rocksdb_transaction_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transaction_options_get_write_batch_flush_threshold( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_write_batch_track_timestamp_size( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_write_batch_track_timestamp_size( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_commit_bypass_memtable( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_commit_bypass_memtable( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_large_txn_commit_optimize_threshold( + rocksdb_transaction_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_transaction_options_get_large_txn_commit_optimize_threshold( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_large_txn_commit_optimize_byte_threshold( + rocksdb_transaction_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_transaction_options_get_large_txn_commit_optimize_byte_threshold( + rocksdb_transaction_options_t* opt); + +/* OptimisticTransactionOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_optimistictransaction_options_set_set_snapshot( + rocksdb_optimistictransaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_optimistictransaction_options_get_set_snapshot( + rocksdb_optimistictransaction_options_t* opt); + +/* OptimisticTransactionDBOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_optimistictransactiondb_options_set_validate_policy( + rocksdb_optimistictransactiondb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_optimistictransactiondb_options_get_validate_policy( + rocksdb_optimistictransactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_optimistictransactiondb_options_set_occ_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_optimistictransactiondb_options_get_occ_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt); diff --git a/c_api_gen/c_generated_options_subset.cc.inc b/c_api_gen/c_generated_options_subset.cc.inc new file mode 100644 index 0000000000..5cb38a5513 --- /dev/null +++ b/c_api_gen/c_generated_options_subset.cc.inc @@ -0,0 +1,84 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'Options simple' +// --header-out +// c_api_gen/c_generated_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_options_subset.cc.inc + +/* Options simple */ + +void rocksdb_options_set_compression_options_zstd_max_train_bytes( + rocksdb_options_t* opt, int zstd_max_train_bytes) { + opt->rep.compression_opts.zstd_max_train_bytes = zstd_max_train_bytes; +} + +int rocksdb_options_get_compression_options_zstd_max_train_bytes( + rocksdb_options_t* opt) { + return opt->rep.compression_opts.zstd_max_train_bytes; +} + +void rocksdb_options_set_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer) { + opt->rep.compression_opts.use_zstd_dict_trainer = use_zstd_dict_trainer; +} + +unsigned char rocksdb_options_get_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt) { + return opt->rep.compression_opts.use_zstd_dict_trainer; +} + +void rocksdb_options_set_compression_options_parallel_threads( + rocksdb_options_t* opt, int value) { + opt->rep.compression_opts.parallel_threads = value; +} + +int rocksdb_options_get_compression_options_parallel_threads( + rocksdb_options_t* opt) { + return opt->rep.compression_opts.parallel_threads; +} + +void rocksdb_options_set_compression_options_max_dict_buffer_bytes( + rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes) { + opt->rep.compression_opts.max_dict_buffer_bytes = max_dict_buffer_bytes; +} + +uint64_t rocksdb_options_get_compression_options_max_dict_buffer_bytes( + rocksdb_options_t* opt) { + return opt->rep.compression_opts.max_dict_buffer_bytes; +} + +unsigned char +rocksdb_options_get_bottommost_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt) { + return opt->rep.bottommost_compression_opts.use_zstd_dict_trainer; +} + +void rocksdb_options_set_use_fsync(rocksdb_options_t* opt, int use_fsync) { + opt->rep.use_fsync = use_fsync; +} + +int rocksdb_options_get_use_fsync(rocksdb_options_t* opt) { + return opt->rep.use_fsync; +} + +void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt, + int disable) { + opt->rep.disable_auto_compactions = disable; +} + +void rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t* opt, + int v) { + opt->rep.optimize_filters_for_hits = v; +} + +void rocksdb_options_set_report_bg_io_stats(rocksdb_options_t* opt, int v) { + opt->rep.report_bg_io_stats = v; +} diff --git a/c_api_gen/c_generated_options_subset.h.inc b/c_api_gen/c_generated_options_subset.h.inc new file mode 100644 index 0000000000..5f29909033 --- /dev/null +++ b/c_api_gen/c_generated_options_subset.h.inc @@ -0,0 +1,67 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'Options simple' +// --header-out +// c_api_gen/c_generated_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_options_subset.cc.inc + +/* Options simple */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_compression_options_zstd_max_train_bytes( + rocksdb_options_t* opt, int zstd_max_train_bytes); + +extern ROCKSDB_LIBRARY_API int +rocksdb_options_get_compression_options_zstd_max_train_bytes( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_compression_options_parallel_threads(rocksdb_options_t* opt, + int value); + +extern ROCKSDB_LIBRARY_API int +rocksdb_options_get_compression_options_parallel_threads( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_compression_options_max_dict_buffer_bytes( + rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_compression_options_max_dict_buffer_bytes( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_bottommost_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_use_fsync( + rocksdb_options_t* opt, int use_fsync); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_use_fsync( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_disable_auto_compactions( + rocksdb_options_t* opt, int disable); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_optimize_filters_for_hits( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_report_bg_io_stats( + rocksdb_options_t* opt, int v); diff --git a/c_api_gen/c_generated_readoptions_auto.cc.inc b/c_api_gen/c_generated_readoptions_auto.cc.inc new file mode 100644 index 0000000000..9c9a93c60d --- /dev/null +++ b/c_api_gen/c_generated_readoptions_auto.cc.inc @@ -0,0 +1,236 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/options.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered ReadOptions simple + +/* ReadOptions */ + +void rocksdb_readoptions_set_deadline(rocksdb_readoptions_t* opt, + uint64_t microseconds) { + opt->rep.deadline = std::chrono::microseconds(microseconds); +} + +uint64_t rocksdb_readoptions_get_deadline(rocksdb_readoptions_t* opt) { + return opt->rep.deadline.count(); +} + +void rocksdb_readoptions_set_io_timeout(rocksdb_readoptions_t* opt, + uint64_t microseconds) { + opt->rep.io_timeout = std::chrono::microseconds(microseconds); +} + +uint64_t rocksdb_readoptions_get_io_timeout(rocksdb_readoptions_t* opt) { + return opt->rep.io_timeout.count(); +} + +void rocksdb_readoptions_set_read_tier(rocksdb_readoptions_t* opt, int v) { + opt->rep.read_tier = static_castrep.read_tier)>(v); +} + +int rocksdb_readoptions_get_read_tier(rocksdb_readoptions_t* opt) { + return static_cast(opt->rep.read_tier); +} + +void rocksdb_readoptions_set_rate_limiter_priority(rocksdb_readoptions_t* opt, + int v) { + opt->rep.rate_limiter_priority = + static_castrep.rate_limiter_priority)>(v); +} + +int rocksdb_readoptions_get_rate_limiter_priority(rocksdb_readoptions_t* opt) { + return static_cast(opt->rep.rate_limiter_priority); +} + +void rocksdb_readoptions_set_value_size_soft_limit(rocksdb_readoptions_t* opt, + uint64_t v) { + opt->rep.value_size_soft_limit = v; +} + +uint64_t rocksdb_readoptions_get_value_size_soft_limit( + rocksdb_readoptions_t* opt) { + return opt->rep.value_size_soft_limit; +} + +void rocksdb_readoptions_set_verify_checksums(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.verify_checksums = v; +} + +unsigned char rocksdb_readoptions_get_verify_checksums( + rocksdb_readoptions_t* opt) { + return opt->rep.verify_checksums; +} + +void rocksdb_readoptions_set_fill_cache(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.fill_cache = v; +} + +unsigned char rocksdb_readoptions_get_fill_cache(rocksdb_readoptions_t* opt) { + return opt->rep.fill_cache; +} + +void rocksdb_readoptions_set_ignore_range_deletions(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.ignore_range_deletions = v; +} + +unsigned char rocksdb_readoptions_get_ignore_range_deletions( + rocksdb_readoptions_t* opt) { + return opt->rep.ignore_range_deletions; +} + +void rocksdb_readoptions_set_async_io(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.async_io = v; +} + +unsigned char rocksdb_readoptions_get_async_io(rocksdb_readoptions_t* opt) { + return opt->rep.async_io; +} + +void rocksdb_readoptions_set_optimize_multiget_for_io( + rocksdb_readoptions_t* opt, unsigned char v) { + opt->rep.optimize_multiget_for_io = v; +} + +unsigned char rocksdb_readoptions_get_optimize_multiget_for_io( + rocksdb_readoptions_t* opt) { + return opt->rep.optimize_multiget_for_io; +} + +void rocksdb_readoptions_set_readahead_size(rocksdb_readoptions_t* opt, + size_t v) { + opt->rep.readahead_size = v; +} + +size_t rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t* opt) { + return opt->rep.readahead_size; +} + +void rocksdb_readoptions_set_max_skippable_internal_keys( + rocksdb_readoptions_t* opt, uint64_t v) { + opt->rep.max_skippable_internal_keys = v; +} + +uint64_t rocksdb_readoptions_get_max_skippable_internal_keys( + rocksdb_readoptions_t* opt) { + return opt->rep.max_skippable_internal_keys; +} + +void rocksdb_readoptions_set_tailing(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.tailing = v; +} + +unsigned char rocksdb_readoptions_get_tailing(rocksdb_readoptions_t* opt) { + return opt->rep.tailing; +} + +void rocksdb_readoptions_set_total_order_seek(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.total_order_seek = v; +} + +unsigned char rocksdb_readoptions_get_total_order_seek( + rocksdb_readoptions_t* opt) { + return opt->rep.total_order_seek; +} + +void rocksdb_readoptions_set_auto_prefix_mode(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.auto_prefix_mode = v; +} + +unsigned char rocksdb_readoptions_get_auto_prefix_mode( + rocksdb_readoptions_t* opt) { + return opt->rep.auto_prefix_mode; +} + +void rocksdb_readoptions_set_prefix_same_as_start(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.prefix_same_as_start = v; +} + +unsigned char rocksdb_readoptions_get_prefix_same_as_start( + rocksdb_readoptions_t* opt) { + return opt->rep.prefix_same_as_start; +} + +void rocksdb_readoptions_set_pin_data(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.pin_data = v; +} + +unsigned char rocksdb_readoptions_get_pin_data(rocksdb_readoptions_t* opt) { + return opt->rep.pin_data; +} + +void rocksdb_readoptions_set_adaptive_readahead(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.adaptive_readahead = v; +} + +unsigned char rocksdb_readoptions_get_adaptive_readahead( + rocksdb_readoptions_t* opt) { + return opt->rep.adaptive_readahead; +} + +void rocksdb_readoptions_set_background_purge_on_iterator_cleanup( + rocksdb_readoptions_t* opt, unsigned char v) { + opt->rep.background_purge_on_iterator_cleanup = v; +} + +unsigned char rocksdb_readoptions_get_background_purge_on_iterator_cleanup( + rocksdb_readoptions_t* opt) { + return opt->rep.background_purge_on_iterator_cleanup; +} + +void rocksdb_readoptions_set_auto_readahead_size(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.auto_readahead_size = v; +} + +unsigned char rocksdb_readoptions_get_auto_readahead_size( + rocksdb_readoptions_t* opt) { + return opt->rep.auto_readahead_size; +} + +void rocksdb_readoptions_set_allow_unprepared_value(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.allow_unprepared_value = v; +} + +unsigned char rocksdb_readoptions_get_allow_unprepared_value( + rocksdb_readoptions_t* opt) { + return opt->rep.allow_unprepared_value; +} + +void rocksdb_readoptions_set_auto_refresh_iterator_with_snapshot( + rocksdb_readoptions_t* opt, unsigned char v) { + opt->rep.auto_refresh_iterator_with_snapshot = v; +} + +unsigned char rocksdb_readoptions_get_auto_refresh_iterator_with_snapshot( + rocksdb_readoptions_t* opt) { + return opt->rep.auto_refresh_iterator_with_snapshot; +} + +void rocksdb_readoptions_set_io_activity(rocksdb_readoptions_t* opt, int v) { + opt->rep.io_activity = static_castrep.io_activity)>(v); +} + +int rocksdb_readoptions_get_io_activity(rocksdb_readoptions_t* opt) { + return static_cast(opt->rep.io_activity); +} diff --git a/c_api_gen/c_generated_readoptions_auto.h.inc b/c_api_gen/c_generated_readoptions_auto.h.inc new file mode 100644 index 0000000000..fef7f9f58d --- /dev/null +++ b/c_api_gen/c_generated_readoptions_auto.h.inc @@ -0,0 +1,161 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/options.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered ReadOptions simple + +/* ReadOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_deadline( + rocksdb_readoptions_t* opt, uint64_t microseconds); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_readoptions_get_deadline(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_io_timeout( + rocksdb_readoptions_t* opt, uint64_t microseconds); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_readoptions_get_io_timeout(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_read_tier( + rocksdb_readoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_readoptions_get_read_tier( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_rate_limiter_priority( + rocksdb_readoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_readoptions_get_rate_limiter_priority( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_value_size_soft_limit( + rocksdb_readoptions_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_readoptions_get_value_size_soft_limit(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_verify_checksums( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_verify_checksums(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_fill_cache( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_fill_cache( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_ignore_range_deletions( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_ignore_range_deletions(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_async_io( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_async_io( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_optimize_multiget_for_io(rocksdb_readoptions_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_optimize_multiget_for_io(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_readahead_size( + rocksdb_readoptions_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_max_skippable_internal_keys(rocksdb_readoptions_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_readoptions_get_max_skippable_internal_keys(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_tailing( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_tailing( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_total_order_seek( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_total_order_seek(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_auto_prefix_mode( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_auto_prefix_mode(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_prefix_same_as_start( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_prefix_same_as_start(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_pin_data( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_pin_data( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_adaptive_readahead( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_adaptive_readahead(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_background_purge_on_iterator_cleanup( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_background_purge_on_iterator_cleanup( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_auto_readahead_size( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_auto_readahead_size(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_allow_unprepared_value( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_allow_unprepared_value(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_auto_refresh_iterator_with_snapshot( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_auto_refresh_iterator_with_snapshot( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_io_activity( + rocksdb_readoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_readoptions_get_io_activity( + rocksdb_readoptions_t* opt); diff --git a/c_api_gen/c_generated_roundtrip_tests.c.inc b/c_api_gen/c_generated_roundtrip_tests.c.inc new file mode 100644 index 0000000000..32cb0b4702 --- /dev/null +++ b/c_api_gen/c_generated_roundtrip_tests.c.inc @@ -0,0 +1,1359 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/gen_roundtrip_tests.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Round-trip (set -> get -> assert) coverage for generated option wrappers. +// Rerun: python3 tools/c_api_gen/regen_all.py +// ----------------------------------------------------------------------------- + +static void rocksdb_roundtrip_test_rocksdb_block_based_options(void) { + rocksdb_block_based_table_options_t* obj = + rocksdb_block_based_options_create(); + rocksdb_block_based_options_set_block_align(obj, 1); + CheckCondition(rocksdb_block_based_options_get_block_align(obj) == 1); + rocksdb_block_based_options_set_block_align(obj, 0); + CheckCondition(rocksdb_block_based_options_get_block_align(obj) == 0); + rocksdb_block_based_options_set_block_restart_interval(obj, 1); + CheckCondition(rocksdb_block_based_options_get_block_restart_interval(obj) == + 1); + rocksdb_block_based_options_set_block_restart_interval(obj, 0); + CheckCondition(rocksdb_block_based_options_get_block_restart_interval(obj) == + 0); + rocksdb_block_based_options_set_block_size(obj, 1); + CheckCondition(rocksdb_block_based_options_get_block_size(obj) == 1); + rocksdb_block_based_options_set_block_size(obj, 0); + CheckCondition(rocksdb_block_based_options_get_block_size(obj) == 0); + rocksdb_block_based_options_set_block_size_deviation(obj, 1); + CheckCondition(rocksdb_block_based_options_get_block_size_deviation(obj) == + 1); + rocksdb_block_based_options_set_block_size_deviation(obj, 0); + CheckCondition(rocksdb_block_based_options_get_block_size_deviation(obj) == + 0); + rocksdb_block_based_options_set_cache_index_and_filter_blocks(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_cache_index_and_filter_blocks(obj) == 1); + rocksdb_block_based_options_set_cache_index_and_filter_blocks(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_cache_index_and_filter_blocks(obj) == 0); + rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority( + obj, 1); + CheckCondition( + rocksdb_block_based_options_get_cache_index_and_filter_blocks_with_high_priority( + obj) == 1); + rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority( + obj, 0); + CheckCondition( + rocksdb_block_based_options_get_cache_index_and_filter_blocks_with_high_priority( + obj) == 0); + rocksdb_block_based_options_set_checksum(obj, 1); + CheckCondition(rocksdb_block_based_options_get_checksum(obj) == 1); + rocksdb_block_based_options_set_checksum(obj, 0); + CheckCondition(rocksdb_block_based_options_get_checksum(obj) == 0); + rocksdb_block_based_options_set_data_block_hash_table_util_ratio(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_data_block_hash_table_util_ratio(obj) == + 1); + rocksdb_block_based_options_set_data_block_hash_table_util_ratio(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_data_block_hash_table_util_ratio(obj) == + 0); + rocksdb_block_based_options_set_data_block_index_type(obj, 1); + CheckCondition(rocksdb_block_based_options_get_data_block_index_type(obj) == + 1); + rocksdb_block_based_options_set_data_block_index_type(obj, 0); + CheckCondition(rocksdb_block_based_options_get_data_block_index_type(obj) == + 0); + rocksdb_block_based_options_set_decouple_partitioned_filters(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_decouple_partitioned_filters(obj) == 1); + rocksdb_block_based_options_set_decouple_partitioned_filters(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_decouple_partitioned_filters(obj) == 0); + rocksdb_block_based_options_set_detect_filter_construct_corruption(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_detect_filter_construct_corruption(obj) == + 1); + rocksdb_block_based_options_set_detect_filter_construct_corruption(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_detect_filter_construct_corruption(obj) == + 0); + rocksdb_block_based_options_set_enable_index_compression(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_enable_index_compression(obj) == 1); + rocksdb_block_based_options_set_enable_index_compression(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_enable_index_compression(obj) == 0); + rocksdb_block_based_options_set_fail_if_no_udi_on_open(obj, 1); + CheckCondition(rocksdb_block_based_options_get_fail_if_no_udi_on_open(obj) == + 1); + rocksdb_block_based_options_set_fail_if_no_udi_on_open(obj, 0); + CheckCondition(rocksdb_block_based_options_get_fail_if_no_udi_on_open(obj) == + 0); + rocksdb_block_based_options_set_format_version(obj, 1); + CheckCondition(rocksdb_block_based_options_get_format_version(obj) == 1); + rocksdb_block_based_options_set_format_version(obj, 0); + CheckCondition(rocksdb_block_based_options_get_format_version(obj) == 0); + rocksdb_block_based_options_set_index_block_restart_interval(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_index_block_restart_interval(obj) == 1); + rocksdb_block_based_options_set_index_block_restart_interval(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_index_block_restart_interval(obj) == 0); + rocksdb_block_based_options_set_index_block_search_type(obj, 1); + CheckCondition(rocksdb_block_based_options_get_index_block_search_type(obj) == + 1); + rocksdb_block_based_options_set_index_block_search_type(obj, 0); + CheckCondition(rocksdb_block_based_options_get_index_block_search_type(obj) == + 0); + rocksdb_block_based_options_set_index_shortening(obj, 1); + CheckCondition(rocksdb_block_based_options_get_index_shortening(obj) == 1); + rocksdb_block_based_options_set_index_shortening(obj, 0); + CheckCondition(rocksdb_block_based_options_get_index_shortening(obj) == 0); + rocksdb_block_based_options_set_index_type(obj, 1); + CheckCondition(rocksdb_block_based_options_get_index_type(obj) == 1); + rocksdb_block_based_options_set_index_type(obj, 0); + CheckCondition(rocksdb_block_based_options_get_index_type(obj) == 0); + rocksdb_block_based_options_set_initial_auto_readahead_size(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_initial_auto_readahead_size(obj) == 1); + rocksdb_block_based_options_set_initial_auto_readahead_size(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_initial_auto_readahead_size(obj) == 0); + rocksdb_block_based_options_set_max_auto_readahead_size(obj, 1); + CheckCondition(rocksdb_block_based_options_get_max_auto_readahead_size(obj) == + 1); + rocksdb_block_based_options_set_max_auto_readahead_size(obj, 0); + CheckCondition(rocksdb_block_based_options_get_max_auto_readahead_size(obj) == + 0); + rocksdb_block_based_options_set_metadata_block_size(obj, 1); + CheckCondition(rocksdb_block_based_options_get_metadata_block_size(obj) == 1); + rocksdb_block_based_options_set_metadata_block_size(obj, 0); + CheckCondition(rocksdb_block_based_options_get_metadata_block_size(obj) == 0); + rocksdb_block_based_options_set_no_block_cache(obj, 1); + CheckCondition(rocksdb_block_based_options_get_no_block_cache(obj) == 1); + rocksdb_block_based_options_set_no_block_cache(obj, 0); + CheckCondition(rocksdb_block_based_options_get_no_block_cache(obj) == 0); + rocksdb_block_based_options_set_num_file_reads_for_auto_readahead(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_num_file_reads_for_auto_readahead(obj) == + 1); + rocksdb_block_based_options_set_num_file_reads_for_auto_readahead(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_num_file_reads_for_auto_readahead(obj) == + 0); + rocksdb_block_based_options_set_optimize_filters_for_memory(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_optimize_filters_for_memory(obj) == 1); + rocksdb_block_based_options_set_optimize_filters_for_memory(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_optimize_filters_for_memory(obj) == 0); + rocksdb_block_based_options_set_partition_filters(obj, 1); + CheckCondition(rocksdb_block_based_options_get_partition_filters(obj) == 1); + rocksdb_block_based_options_set_partition_filters(obj, 0); + CheckCondition(rocksdb_block_based_options_get_partition_filters(obj) == 0); + rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(obj, + 1); + CheckCondition( + rocksdb_block_based_options_get_pin_l0_filter_and_index_blocks_in_cache( + obj) == 1); + rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(obj, + 0); + CheckCondition( + rocksdb_block_based_options_get_pin_l0_filter_and_index_blocks_in_cache( + obj) == 0); + rocksdb_block_based_options_set_pin_top_level_index_and_filter(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_pin_top_level_index_and_filter(obj) == 1); + rocksdb_block_based_options_set_pin_top_level_index_and_filter(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_pin_top_level_index_and_filter(obj) == 0); + rocksdb_block_based_options_set_prepopulate_block_cache(obj, 1); + CheckCondition(rocksdb_block_based_options_get_prepopulate_block_cache(obj) == + 1); + rocksdb_block_based_options_set_prepopulate_block_cache(obj, 0); + CheckCondition(rocksdb_block_based_options_get_prepopulate_block_cache(obj) == + 0); + rocksdb_block_based_options_set_read_amp_bytes_per_bit(obj, 1); + CheckCondition(rocksdb_block_based_options_get_read_amp_bytes_per_bit(obj) == + 1); + rocksdb_block_based_options_set_read_amp_bytes_per_bit(obj, 0); + CheckCondition(rocksdb_block_based_options_get_read_amp_bytes_per_bit(obj) == + 0); + rocksdb_block_based_options_set_separate_key_value_in_data_block(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_separate_key_value_in_data_block(obj) == + 1); + rocksdb_block_based_options_set_separate_key_value_in_data_block(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_separate_key_value_in_data_block(obj) == + 0); + rocksdb_block_based_options_set_super_block_alignment_size(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_super_block_alignment_size(obj) == 1); + rocksdb_block_based_options_set_super_block_alignment_size(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_super_block_alignment_size(obj) == 0); + rocksdb_block_based_options_set_super_block_alignment_space_overhead_ratio( + obj, 1); + CheckCondition( + rocksdb_block_based_options_get_super_block_alignment_space_overhead_ratio( + obj) == 1); + rocksdb_block_based_options_set_super_block_alignment_space_overhead_ratio( + obj, 0); + CheckCondition( + rocksdb_block_based_options_get_super_block_alignment_space_overhead_ratio( + obj) == 0); + rocksdb_block_based_options_set_uniform_cv_threshold(obj, 1); + CheckCondition(rocksdb_block_based_options_get_uniform_cv_threshold(obj) == + 1); + rocksdb_block_based_options_set_uniform_cv_threshold(obj, 0); + CheckCondition(rocksdb_block_based_options_get_uniform_cv_threshold(obj) == + 0); + rocksdb_block_based_options_set_use_delta_encoding(obj, 1); + CheckCondition(rocksdb_block_based_options_get_use_delta_encoding(obj) == 1); + rocksdb_block_based_options_set_use_delta_encoding(obj, 0); + CheckCondition(rocksdb_block_based_options_get_use_delta_encoding(obj) == 0); + rocksdb_block_based_options_set_use_udi_as_primary_index(obj, 1); + CheckCondition( + rocksdb_block_based_options_get_use_udi_as_primary_index(obj) == 1); + rocksdb_block_based_options_set_use_udi_as_primary_index(obj, 0); + CheckCondition( + rocksdb_block_based_options_get_use_udi_as_primary_index(obj) == 0); + rocksdb_block_based_options_set_verify_compression(obj, 1); + CheckCondition(rocksdb_block_based_options_get_verify_compression(obj) == 1); + rocksdb_block_based_options_set_verify_compression(obj, 0); + CheckCondition(rocksdb_block_based_options_get_verify_compression(obj) == 0); + rocksdb_block_based_options_set_whole_key_filtering(obj, 1); + CheckCondition(rocksdb_block_based_options_get_whole_key_filtering(obj) == 1); + rocksdb_block_based_options_set_whole_key_filtering(obj, 0); + CheckCondition(rocksdb_block_based_options_get_whole_key_filtering(obj) == 0); + rocksdb_block_based_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_block_cache_trace_options(void) { + rocksdb_block_cache_trace_options_t* obj = + rocksdb_block_cache_trace_options_create(); + rocksdb_block_cache_trace_options_set_sampling_frequency(obj, 1); + CheckCondition( + rocksdb_block_cache_trace_options_get_sampling_frequency(obj) == 1); + rocksdb_block_cache_trace_options_set_sampling_frequency(obj, 0); + CheckCondition( + rocksdb_block_cache_trace_options_get_sampling_frequency(obj) == 0); + rocksdb_block_cache_trace_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_block_cache_trace_writer_options( + void) { + rocksdb_block_cache_trace_writer_options_t* obj = + rocksdb_block_cache_trace_writer_options_create(); + rocksdb_block_cache_trace_writer_options_set_max_trace_file_size(obj, 1); + CheckCondition( + rocksdb_block_cache_trace_writer_options_get_max_trace_file_size(obj) == + 1); + rocksdb_block_cache_trace_writer_options_set_max_trace_file_size(obj, 0); + CheckCondition( + rocksdb_block_cache_trace_writer_options_get_max_trace_file_size(obj) == + 0); + rocksdb_block_cache_trace_writer_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_column_family_metadata_options( + void) { + rocksdb_column_family_metadata_options_t* obj = + rocksdb_column_family_metadata_options_create(); + rocksdb_column_family_metadata_options_set_level(obj, 1); + CheckCondition(rocksdb_column_family_metadata_options_get_level(obj) == 1); + rocksdb_column_family_metadata_options_set_level(obj, 0); + CheckCondition(rocksdb_column_family_metadata_options_get_level(obj) == 0); + rocksdb_column_family_metadata_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_compaction_options(void) { + rocksdb_compaction_options_t* obj = rocksdb_compaction_options_create(); + rocksdb_compaction_options_set_allow_trivial_move(obj, 1); + CheckCondition(rocksdb_compaction_options_get_allow_trivial_move(obj) == 1); + rocksdb_compaction_options_set_allow_trivial_move(obj, 0); + CheckCondition(rocksdb_compaction_options_get_allow_trivial_move(obj) == 0); + rocksdb_compaction_options_set_compression(obj, 1); + CheckCondition(rocksdb_compaction_options_get_compression(obj) == 1); + rocksdb_compaction_options_set_compression(obj, 0); + CheckCondition(rocksdb_compaction_options_get_compression(obj) == 0); + rocksdb_compaction_options_set_max_subcompactions(obj, 1); + CheckCondition(rocksdb_compaction_options_get_max_subcompactions(obj) == 1); + rocksdb_compaction_options_set_max_subcompactions(obj, 0); + CheckCondition(rocksdb_compaction_options_get_max_subcompactions(obj) == 0); + rocksdb_compaction_options_set_output_file_size_limit(obj, 1); + CheckCondition(rocksdb_compaction_options_get_output_file_size_limit(obj) == + 1); + rocksdb_compaction_options_set_output_file_size_limit(obj, 0); + CheckCondition(rocksdb_compaction_options_get_output_file_size_limit(obj) == + 0); + rocksdb_compaction_options_set_output_temperature_override(obj, 1); + CheckCondition( + rocksdb_compaction_options_get_output_temperature_override(obj) == 1); + rocksdb_compaction_options_set_output_temperature_override(obj, 0); + CheckCondition( + rocksdb_compaction_options_get_output_temperature_override(obj) == 0); + rocksdb_compaction_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_compactoptions(void) { + rocksdb_compactoptions_t* obj = rocksdb_compactoptions_create(); + rocksdb_compactoptions_set_blob_garbage_collection_age_cutoff(obj, 1); + CheckCondition( + rocksdb_compactoptions_get_blob_garbage_collection_age_cutoff(obj) == 1); + rocksdb_compactoptions_set_blob_garbage_collection_age_cutoff(obj, 0); + CheckCondition( + rocksdb_compactoptions_get_blob_garbage_collection_age_cutoff(obj) == 0); + rocksdb_compactoptions_set_blob_garbage_collection_policy(obj, 1); + CheckCondition( + rocksdb_compactoptions_get_blob_garbage_collection_policy(obj) == 1); + rocksdb_compactoptions_set_blob_garbage_collection_policy(obj, 0); + CheckCondition( + rocksdb_compactoptions_get_blob_garbage_collection_policy(obj) == 0); + rocksdb_compactoptions_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_create_backup_options(void) { + rocksdb_create_backup_options_t* obj = rocksdb_create_backup_options_create(); + rocksdb_create_backup_options_set_atomic_flush(obj, 1); + CheckCondition(rocksdb_create_backup_options_get_atomic_flush(obj) == 1); + rocksdb_create_backup_options_set_atomic_flush(obj, 0); + CheckCondition(rocksdb_create_backup_options_get_atomic_flush(obj) == 0); + rocksdb_create_backup_options_set_background_thread_cpu_priority(obj, 1); + CheckCondition( + rocksdb_create_backup_options_get_background_thread_cpu_priority(obj) == + 1); + rocksdb_create_backup_options_set_background_thread_cpu_priority(obj, 0); + CheckCondition( + rocksdb_create_backup_options_get_background_thread_cpu_priority(obj) == + 0); + rocksdb_create_backup_options_set_decrease_background_thread_cpu_priority(obj, + 1); + CheckCondition( + rocksdb_create_backup_options_get_decrease_background_thread_cpu_priority( + obj) == 1); + rocksdb_create_backup_options_set_decrease_background_thread_cpu_priority(obj, + 0); + CheckCondition( + rocksdb_create_backup_options_get_decrease_background_thread_cpu_priority( + obj) == 0); + rocksdb_create_backup_options_set_flush_before_backup(obj, 1); + CheckCondition(rocksdb_create_backup_options_get_flush_before_backup(obj) == + 1); + rocksdb_create_backup_options_set_flush_before_backup(obj, 0); + CheckCondition(rocksdb_create_backup_options_get_flush_before_backup(obj) == + 0); + rocksdb_create_backup_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_cuckoo_options(void) { + rocksdb_cuckoo_table_options_t* obj = rocksdb_cuckoo_options_create(); + rocksdb_cuckoo_options_set_cuckoo_block_size(obj, 1); + CheckCondition(rocksdb_cuckoo_options_get_cuckoo_block_size(obj) == 1); + rocksdb_cuckoo_options_set_cuckoo_block_size(obj, 0); + CheckCondition(rocksdb_cuckoo_options_get_cuckoo_block_size(obj) == 0); + rocksdb_cuckoo_options_set_hash_table_ratio(obj, 1); + CheckCondition(rocksdb_cuckoo_options_get_hash_table_ratio(obj) == 1); + rocksdb_cuckoo_options_set_hash_table_ratio(obj, 0); + CheckCondition(rocksdb_cuckoo_options_get_hash_table_ratio(obj) == 0); + rocksdb_cuckoo_options_set_identity_as_first_hash(obj, 1); + CheckCondition(rocksdb_cuckoo_options_get_identity_as_first_hash(obj) == 1); + rocksdb_cuckoo_options_set_identity_as_first_hash(obj, 0); + CheckCondition(rocksdb_cuckoo_options_get_identity_as_first_hash(obj) == 0); + rocksdb_cuckoo_options_set_max_search_depth(obj, 1); + CheckCondition(rocksdb_cuckoo_options_get_max_search_depth(obj) == 1); + rocksdb_cuckoo_options_set_max_search_depth(obj, 0); + CheckCondition(rocksdb_cuckoo_options_get_max_search_depth(obj) == 0); + rocksdb_cuckoo_options_set_use_module_hash(obj, 1); + CheckCondition(rocksdb_cuckoo_options_get_use_module_hash(obj) == 1); + rocksdb_cuckoo_options_set_use_module_hash(obj, 0); + CheckCondition(rocksdb_cuckoo_options_get_use_module_hash(obj) == 0); + rocksdb_cuckoo_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_envoptions(void) { + rocksdb_envoptions_t* obj = rocksdb_envoptions_create(); + rocksdb_envoptions_set_allow_fallocate(obj, 1); + CheckCondition(rocksdb_envoptions_get_allow_fallocate(obj) == 1); + rocksdb_envoptions_set_allow_fallocate(obj, 0); + CheckCondition(rocksdb_envoptions_get_allow_fallocate(obj) == 0); + rocksdb_envoptions_set_bytes_per_sync(obj, 1); + CheckCondition(rocksdb_envoptions_get_bytes_per_sync(obj) == 1); + rocksdb_envoptions_set_bytes_per_sync(obj, 0); + CheckCondition(rocksdb_envoptions_get_bytes_per_sync(obj) == 0); + rocksdb_envoptions_set_compaction_readahead_size(obj, 1); + CheckCondition(rocksdb_envoptions_get_compaction_readahead_size(obj) == 1); + rocksdb_envoptions_set_compaction_readahead_size(obj, 0); + CheckCondition(rocksdb_envoptions_get_compaction_readahead_size(obj) == 0); + rocksdb_envoptions_set_fallocate_with_keep_size(obj, 1); + CheckCondition(rocksdb_envoptions_get_fallocate_with_keep_size(obj) == 1); + rocksdb_envoptions_set_fallocate_with_keep_size(obj, 0); + CheckCondition(rocksdb_envoptions_get_fallocate_with_keep_size(obj) == 0); + rocksdb_envoptions_set_fd_cloexec(obj, 1); + CheckCondition(rocksdb_envoptions_get_fd_cloexec(obj) == 1); + rocksdb_envoptions_set_fd_cloexec(obj, 0); + CheckCondition(rocksdb_envoptions_get_fd_cloexec(obj) == 0); + rocksdb_envoptions_set_strict_bytes_per_sync(obj, 1); + CheckCondition(rocksdb_envoptions_get_strict_bytes_per_sync(obj) == 1); + rocksdb_envoptions_set_strict_bytes_per_sync(obj, 0); + CheckCondition(rocksdb_envoptions_get_strict_bytes_per_sync(obj) == 0); + rocksdb_envoptions_set_use_direct_reads(obj, 1); + CheckCondition(rocksdb_envoptions_get_use_direct_reads(obj) == 1); + rocksdb_envoptions_set_use_direct_reads(obj, 0); + CheckCondition(rocksdb_envoptions_get_use_direct_reads(obj) == 0); + rocksdb_envoptions_set_use_direct_writes(obj, 1); + CheckCondition(rocksdb_envoptions_get_use_direct_writes(obj) == 1); + rocksdb_envoptions_set_use_direct_writes(obj, 0); + CheckCondition(rocksdb_envoptions_get_use_direct_writes(obj) == 0); + rocksdb_envoptions_set_use_mmap_reads(obj, 1); + CheckCondition(rocksdb_envoptions_get_use_mmap_reads(obj) == 1); + rocksdb_envoptions_set_use_mmap_reads(obj, 0); + CheckCondition(rocksdb_envoptions_get_use_mmap_reads(obj) == 0); + rocksdb_envoptions_set_use_mmap_writes(obj, 1); + CheckCondition(rocksdb_envoptions_get_use_mmap_writes(obj) == 1); + rocksdb_envoptions_set_use_mmap_writes(obj, 0); + CheckCondition(rocksdb_envoptions_get_use_mmap_writes(obj) == 0); + rocksdb_envoptions_set_writable_file_max_buffer_size(obj, 1); + CheckCondition(rocksdb_envoptions_get_writable_file_max_buffer_size(obj) == + 1); + rocksdb_envoptions_set_writable_file_max_buffer_size(obj, 0); + CheckCondition(rocksdb_envoptions_get_writable_file_max_buffer_size(obj) == + 0); + rocksdb_envoptions_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_fifo_compaction_options(void) { + rocksdb_fifo_compaction_options_t* obj = + rocksdb_fifo_compaction_options_create(); + rocksdb_fifo_compaction_options_set_age_for_warm(obj, 1); + CheckCondition(rocksdb_fifo_compaction_options_get_age_for_warm(obj) == 1); + rocksdb_fifo_compaction_options_set_age_for_warm(obj, 0); + CheckCondition(rocksdb_fifo_compaction_options_get_age_for_warm(obj) == 0); + rocksdb_fifo_compaction_options_set_allow_trivial_copy_when_change_temperature( + obj, 1); + CheckCondition( + rocksdb_fifo_compaction_options_get_allow_trivial_copy_when_change_temperature( + obj) == 1); + rocksdb_fifo_compaction_options_set_allow_trivial_copy_when_change_temperature( + obj, 0); + CheckCondition( + rocksdb_fifo_compaction_options_get_allow_trivial_copy_when_change_temperature( + obj) == 0); + rocksdb_fifo_compaction_options_set_trivial_copy_buffer_size(obj, 1); + CheckCondition( + rocksdb_fifo_compaction_options_get_trivial_copy_buffer_size(obj) == 1); + rocksdb_fifo_compaction_options_set_trivial_copy_buffer_size(obj, 0); + CheckCondition( + rocksdb_fifo_compaction_options_get_trivial_copy_buffer_size(obj) == 0); + rocksdb_fifo_compaction_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_flushoptions(void) { + rocksdb_flushoptions_t* obj = rocksdb_flushoptions_create(); + rocksdb_flushoptions_set_allow_write_stall(obj, 1); + CheckCondition(rocksdb_flushoptions_get_allow_write_stall(obj) == 1); + rocksdb_flushoptions_set_allow_write_stall(obj, 0); + CheckCondition(rocksdb_flushoptions_get_allow_write_stall(obj) == 0); + rocksdb_flushoptions_set_force_atomic_flush(obj, 1); + CheckCondition(rocksdb_flushoptions_get_force_atomic_flush(obj) == 1); + rocksdb_flushoptions_set_force_atomic_flush(obj, 0); + CheckCondition(rocksdb_flushoptions_get_force_atomic_flush(obj) == 0); + rocksdb_flushoptions_set_wait(obj, 1); + CheckCondition(rocksdb_flushoptions_get_wait(obj) == 1); + rocksdb_flushoptions_set_wait(obj, 0); + CheckCondition(rocksdb_flushoptions_get_wait(obj) == 0); + rocksdb_flushoptions_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_flushwaloptions(void) { + rocksdb_flushwaloptions_t* obj = rocksdb_flushwaloptions_create(); + rocksdb_flushwaloptions_set_rate_limiter_priority(obj, 1); + CheckCondition(rocksdb_flushwaloptions_get_rate_limiter_priority(obj) == 1); + rocksdb_flushwaloptions_set_rate_limiter_priority(obj, 0); + CheckCondition(rocksdb_flushwaloptions_get_rate_limiter_priority(obj) == 0); + rocksdb_flushwaloptions_set_sync(obj, 1); + CheckCondition(rocksdb_flushwaloptions_get_sync(obj) == 1); + rocksdb_flushwaloptions_set_sync(obj, 0); + CheckCondition(rocksdb_flushwaloptions_get_sync(obj) == 0); + rocksdb_flushwaloptions_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_ingestexternalfileoptions(void) { + rocksdb_ingestexternalfileoptions_t* obj = + rocksdb_ingestexternalfileoptions_create(); + rocksdb_ingestexternalfileoptions_set_allow_db_generated_files(obj, 1); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_allow_db_generated_files(obj) == 1); + rocksdb_ingestexternalfileoptions_set_allow_db_generated_files(obj, 0); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_allow_db_generated_files(obj) == 0); + rocksdb_ingestexternalfileoptions_set_failed_move_fall_back_to_copy(obj, 1); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_failed_move_fall_back_to_copy( + obj) == 1); + rocksdb_ingestexternalfileoptions_set_failed_move_fall_back_to_copy(obj, 0); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_failed_move_fall_back_to_copy( + obj) == 0); + rocksdb_ingestexternalfileoptions_set_file_opening_threads(obj, 1); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_file_opening_threads(obj) == 1); + rocksdb_ingestexternalfileoptions_set_file_opening_threads(obj, 0); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_file_opening_threads(obj) == 0); + rocksdb_ingestexternalfileoptions_set_fill_cache(obj, 1); + CheckCondition(rocksdb_ingestexternalfileoptions_get_fill_cache(obj) == 1); + rocksdb_ingestexternalfileoptions_set_fill_cache(obj, 0); + CheckCondition(rocksdb_ingestexternalfileoptions_get_fill_cache(obj) == 0); + rocksdb_ingestexternalfileoptions_set_link_files(obj, 1); + CheckCondition(rocksdb_ingestexternalfileoptions_get_link_files(obj) == 1); + rocksdb_ingestexternalfileoptions_set_link_files(obj, 0); + CheckCondition(rocksdb_ingestexternalfileoptions_get_link_files(obj) == 0); + rocksdb_ingestexternalfileoptions_set_prefetch_lmax_index_and_filter_blocks( + obj, 1); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_prefetch_lmax_index_and_filter_blocks( + obj) == 1); + rocksdb_ingestexternalfileoptions_set_prefetch_lmax_index_and_filter_blocks( + obj, 0); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_prefetch_lmax_index_and_filter_blocks( + obj) == 0); + rocksdb_ingestexternalfileoptions_set_verify_checksums_before_ingest(obj, 1); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_verify_checksums_before_ingest( + obj) == 1); + rocksdb_ingestexternalfileoptions_set_verify_checksums_before_ingest(obj, 0); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_verify_checksums_before_ingest( + obj) == 0); + rocksdb_ingestexternalfileoptions_set_verify_checksums_readahead_size(obj, 1); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_verify_checksums_readahead_size( + obj) == 1); + rocksdb_ingestexternalfileoptions_set_verify_checksums_readahead_size(obj, 0); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_verify_checksums_readahead_size( + obj) == 0); + rocksdb_ingestexternalfileoptions_set_verify_file_checksum(obj, 1); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_verify_file_checksum(obj) == 1); + rocksdb_ingestexternalfileoptions_set_verify_file_checksum(obj, 0); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_verify_file_checksum(obj) == 0); + rocksdb_ingestexternalfileoptions_set_write_global_seqno(obj, 1); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_write_global_seqno(obj) == 1); + rocksdb_ingestexternalfileoptions_set_write_global_seqno(obj, 0); + CheckCondition( + rocksdb_ingestexternalfileoptions_get_write_global_seqno(obj) == 0); + rocksdb_ingestexternalfileoptions_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_livefiles_storage_info_options( + void) { + rocksdb_livefiles_storage_info_options_t* obj = + rocksdb_livefiles_storage_info_options_create(); + rocksdb_livefiles_storage_info_options_set_atomic_flush(obj, 1); + CheckCondition(rocksdb_livefiles_storage_info_options_get_atomic_flush(obj) == + 1); + rocksdb_livefiles_storage_info_options_set_atomic_flush(obj, 0); + CheckCondition(rocksdb_livefiles_storage_info_options_get_atomic_flush(obj) == + 0); + rocksdb_livefiles_storage_info_options_set_include_checksum_info(obj, 1); + CheckCondition( + rocksdb_livefiles_storage_info_options_get_include_checksum_info(obj) == + 1); + rocksdb_livefiles_storage_info_options_set_include_checksum_info(obj, 0); + CheckCondition( + rocksdb_livefiles_storage_info_options_get_include_checksum_info(obj) == + 0); + rocksdb_livefiles_storage_info_options_set_wal_size_for_flush(obj, 1); + CheckCondition( + rocksdb_livefiles_storage_info_options_get_wal_size_for_flush(obj) == 1); + rocksdb_livefiles_storage_info_options_set_wal_size_for_flush(obj, 0); + CheckCondition( + rocksdb_livefiles_storage_info_options_get_wal_size_for_flush(obj) == 0); + rocksdb_livefiles_storage_info_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_optimistictransactiondb_options( + void) { + rocksdb_optimistictransactiondb_options_t* obj = + rocksdb_optimistictransactiondb_options_create(); + rocksdb_optimistictransactiondb_options_set_occ_lock_buckets(obj, 1); + CheckCondition( + rocksdb_optimistictransactiondb_options_get_occ_lock_buckets(obj) == 1); + rocksdb_optimistictransactiondb_options_set_occ_lock_buckets(obj, 0); + CheckCondition( + rocksdb_optimistictransactiondb_options_get_occ_lock_buckets(obj) == 0); + rocksdb_optimistictransactiondb_options_set_validate_policy(obj, 1); + CheckCondition( + rocksdb_optimistictransactiondb_options_get_validate_policy(obj) == 1); + rocksdb_optimistictransactiondb_options_set_validate_policy(obj, 0); + CheckCondition( + rocksdb_optimistictransactiondb_options_get_validate_policy(obj) == 0); + rocksdb_optimistictransactiondb_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_options(void) { + rocksdb_options_t* obj = rocksdb_options_create(); + rocksdb_options_set_allow_2pc(obj, 1); + CheckCondition(rocksdb_options_get_allow_2pc(obj) == 1); + rocksdb_options_set_allow_2pc(obj, 0); + CheckCondition(rocksdb_options_get_allow_2pc(obj) == 0); + rocksdb_options_set_allow_data_in_errors(obj, 1); + CheckCondition(rocksdb_options_get_allow_data_in_errors(obj) == 1); + rocksdb_options_set_allow_data_in_errors(obj, 0); + CheckCondition(rocksdb_options_get_allow_data_in_errors(obj) == 0); + rocksdb_options_set_allow_fallocate(obj, 1); + CheckCondition(rocksdb_options_get_allow_fallocate(obj) == 1); + rocksdb_options_set_allow_fallocate(obj, 0); + CheckCondition(rocksdb_options_get_allow_fallocate(obj) == 0); + rocksdb_options_set_async_wal_precreate(obj, 1); + CheckCondition(rocksdb_options_get_async_wal_precreate(obj) == 1); + rocksdb_options_set_async_wal_precreate(obj, 0); + CheckCondition(rocksdb_options_get_async_wal_precreate(obj) == 0); + rocksdb_options_set_avoid_flush_during_recovery(obj, 1); + CheckCondition(rocksdb_options_get_avoid_flush_during_recovery(obj) == 1); + rocksdb_options_set_avoid_flush_during_recovery(obj, 0); + CheckCondition(rocksdb_options_get_avoid_flush_during_recovery(obj) == 0); + rocksdb_options_set_avoid_flush_during_shutdown(obj, 1); + CheckCondition(rocksdb_options_get_avoid_flush_during_shutdown(obj) == 1); + rocksdb_options_set_avoid_flush_during_shutdown(obj, 0); + CheckCondition(rocksdb_options_get_avoid_flush_during_shutdown(obj) == 0); + rocksdb_options_set_background_close_inactive_wals(obj, 1); + CheckCondition(rocksdb_options_get_background_close_inactive_wals(obj) == 1); + rocksdb_options_set_background_close_inactive_wals(obj, 0); + CheckCondition(rocksdb_options_get_background_close_inactive_wals(obj) == 0); + rocksdb_options_set_best_efforts_recovery(obj, 1); + CheckCondition(rocksdb_options_get_best_efforts_recovery(obj) == 1); + rocksdb_options_set_best_efforts_recovery(obj, 0); + CheckCondition(rocksdb_options_get_best_efforts_recovery(obj) == 0); + rocksdb_options_set_bgerror_resume_retry_interval(obj, 1); + CheckCondition(rocksdb_options_get_bgerror_resume_retry_interval(obj) == 1); + rocksdb_options_set_bgerror_resume_retry_interval(obj, 0); + CheckCondition(rocksdb_options_get_bgerror_resume_retry_interval(obj) == 0); + rocksdb_options_set_blob_direct_write_partitions(obj, 1); + CheckCondition(rocksdb_options_get_blob_direct_write_partitions(obj) == 1); + rocksdb_options_set_blob_direct_write_partitions(obj, 0); + CheckCondition(rocksdb_options_get_blob_direct_write_partitions(obj) == 0); + rocksdb_options_set_block_protection_bytes_per_key(obj, 1); + CheckCondition(rocksdb_options_get_block_protection_bytes_per_key(obj) == 1); + rocksdb_options_set_block_protection_bytes_per_key(obj, 0); + CheckCondition(rocksdb_options_get_block_protection_bytes_per_key(obj) == 0); + rocksdb_options_set_bottommost_file_compaction_delay(obj, 1); + CheckCondition(rocksdb_options_get_bottommost_file_compaction_delay(obj) == + 1); + rocksdb_options_set_bottommost_file_compaction_delay(obj, 0); + CheckCondition(rocksdb_options_get_bottommost_file_compaction_delay(obj) == + 0); + rocksdb_options_set_cf_allow_ingest_behind(obj, 1); + CheckCondition(rocksdb_options_get_cf_allow_ingest_behind(obj) == 1); + rocksdb_options_set_cf_allow_ingest_behind(obj, 0); + CheckCondition(rocksdb_options_get_cf_allow_ingest_behind(obj) == 0); + rocksdb_options_set_compaction_verify_record_count(obj, 1); + CheckCondition(rocksdb_options_get_compaction_verify_record_count(obj) == 1); + rocksdb_options_set_compaction_verify_record_count(obj, 0); + CheckCondition(rocksdb_options_get_compaction_verify_record_count(obj) == 0); + rocksdb_options_set_compression_options_max_dict_buffer_bytes(obj, 1); + CheckCondition( + rocksdb_options_get_compression_options_max_dict_buffer_bytes(obj) == 1); + rocksdb_options_set_compression_options_max_dict_buffer_bytes(obj, 0); + CheckCondition( + rocksdb_options_get_compression_options_max_dict_buffer_bytes(obj) == 0); + rocksdb_options_set_compression_options_parallel_threads(obj, 1); + CheckCondition( + rocksdb_options_get_compression_options_parallel_threads(obj) == 1); + rocksdb_options_set_compression_options_parallel_threads(obj, 0); + CheckCondition( + rocksdb_options_get_compression_options_parallel_threads(obj) == 0); + rocksdb_options_set_compression_options_use_zstd_dict_trainer(obj, 1); + CheckCondition( + rocksdb_options_get_compression_options_use_zstd_dict_trainer(obj) == 1); + rocksdb_options_set_compression_options_use_zstd_dict_trainer(obj, 0); + CheckCondition( + rocksdb_options_get_compression_options_use_zstd_dict_trainer(obj) == 0); + rocksdb_options_set_compression_options_zstd_max_train_bytes(obj, 1); + CheckCondition( + rocksdb_options_get_compression_options_zstd_max_train_bytes(obj) == 1); + rocksdb_options_set_compression_options_zstd_max_train_bytes(obj, 0); + CheckCondition( + rocksdb_options_get_compression_options_zstd_max_train_bytes(obj) == 0); + rocksdb_options_set_daily_offpeak_time_utc(obj, "test"); + { + size_t rt_len = 0; + const char* rt_v = rocksdb_options_get_daily_offpeak_time_utc(obj, &rt_len); + CheckCondition(rt_len == 4 && rt_v != NULL && memcmp(rt_v, "test", 4) == 0); + } + rocksdb_options_set_db_host_id(obj, "test"); + { + size_t rt_len = 0; + const char* rt_v = rocksdb_options_get_db_host_id(obj, &rt_len); + CheckCondition(rt_len == 4 && rt_v != NULL && memcmp(rt_v, "test", 4) == 0); + } + rocksdb_options_set_default_temperature(obj, 1); + CheckCondition(rocksdb_options_get_default_temperature(obj) == 1); + rocksdb_options_set_default_temperature(obj, 0); + CheckCondition(rocksdb_options_get_default_temperature(obj) == 0); + rocksdb_options_set_default_write_temperature(obj, 1); + CheckCondition(rocksdb_options_get_default_write_temperature(obj) == 1); + rocksdb_options_set_default_write_temperature(obj, 0); + CheckCondition(rocksdb_options_get_default_write_temperature(obj) == 0); + rocksdb_options_set_delayed_write_rate(obj, 1); + CheckCondition(rocksdb_options_get_delayed_write_rate(obj) == 1); + rocksdb_options_set_delayed_write_rate(obj, 0); + CheckCondition(rocksdb_options_get_delayed_write_rate(obj) == 0); + rocksdb_options_set_disallow_memtable_writes(obj, 1); + CheckCondition(rocksdb_options_get_disallow_memtable_writes(obj) == 1); + rocksdb_options_set_disallow_memtable_writes(obj, 0); + CheckCondition(rocksdb_options_get_disallow_memtable_writes(obj) == 0); + rocksdb_options_set_enable_blob_direct_write(obj, 1); + CheckCondition(rocksdb_options_get_enable_blob_direct_write(obj) == 1); + rocksdb_options_set_enable_blob_direct_write(obj, 0); + CheckCondition(rocksdb_options_get_enable_blob_direct_write(obj) == 0); + rocksdb_options_set_enable_thread_tracking(obj, 1); + CheckCondition(rocksdb_options_get_enable_thread_tracking(obj) == 1); + rocksdb_options_set_enable_thread_tracking(obj, 0); + CheckCondition(rocksdb_options_get_enable_thread_tracking(obj) == 0); + rocksdb_options_set_enforce_single_del_contracts(obj, 1); + CheckCondition(rocksdb_options_get_enforce_single_del_contracts(obj) == 1); + rocksdb_options_set_enforce_single_del_contracts(obj, 0); + CheckCondition(rocksdb_options_get_enforce_single_del_contracts(obj) == 0); + rocksdb_options_set_enforce_write_buffer_manager_during_recovery(obj, 1); + CheckCondition( + rocksdb_options_get_enforce_write_buffer_manager_during_recovery(obj) == + 1); + rocksdb_options_set_enforce_write_buffer_manager_during_recovery(obj, 0); + CheckCondition( + rocksdb_options_get_enforce_write_buffer_manager_during_recovery(obj) == + 0); + rocksdb_options_set_fast_sst_open(obj, 1); + CheckCondition(rocksdb_options_get_fast_sst_open(obj) == 1); + rocksdb_options_set_fast_sst_open(obj, 0); + CheckCondition(rocksdb_options_get_fast_sst_open(obj) == 0); + rocksdb_options_set_flush_verify_memtable_count(obj, 1); + CheckCondition(rocksdb_options_get_flush_verify_memtable_count(obj) == 1); + rocksdb_options_set_flush_verify_memtable_count(obj, 0); + CheckCondition(rocksdb_options_get_flush_verify_memtable_count(obj) == 0); + rocksdb_options_set_follower_catchup_retry_count(obj, 1); + CheckCondition(rocksdb_options_get_follower_catchup_retry_count(obj) == 1); + rocksdb_options_set_follower_catchup_retry_count(obj, 0); + CheckCondition(rocksdb_options_get_follower_catchup_retry_count(obj) == 0); + rocksdb_options_set_follower_catchup_retry_wait_ms(obj, 1); + CheckCondition(rocksdb_options_get_follower_catchup_retry_wait_ms(obj) == 1); + rocksdb_options_set_follower_catchup_retry_wait_ms(obj, 0); + CheckCondition(rocksdb_options_get_follower_catchup_retry_wait_ms(obj) == 0); + rocksdb_options_set_follower_refresh_catchup_period_ms(obj, 1); + CheckCondition(rocksdb_options_get_follower_refresh_catchup_period_ms(obj) == + 1); + rocksdb_options_set_follower_refresh_catchup_period_ms(obj, 0); + CheckCondition(rocksdb_options_get_follower_refresh_catchup_period_ms(obj) == + 0); + rocksdb_options_set_force_consistency_checks(obj, 1); + CheckCondition(rocksdb_options_get_force_consistency_checks(obj) == 1); + rocksdb_options_set_force_consistency_checks(obj, 0); + CheckCondition(rocksdb_options_get_force_consistency_checks(obj) == 0); + rocksdb_options_set_last_level_temperature(obj, 1); + CheckCondition(rocksdb_options_get_last_level_temperature(obj) == 1); + rocksdb_options_set_last_level_temperature(obj, 0); + CheckCondition(rocksdb_options_get_last_level_temperature(obj) == 0); + rocksdb_options_set_log_readahead_size(obj, 1); + CheckCondition(rocksdb_options_get_log_readahead_size(obj) == 1); + rocksdb_options_set_log_readahead_size(obj, 0); + CheckCondition(rocksdb_options_get_log_readahead_size(obj) == 0); + rocksdb_options_set_lowest_used_cache_tier(obj, 1); + CheckCondition(rocksdb_options_get_lowest_used_cache_tier(obj) == 1); + rocksdb_options_set_lowest_used_cache_tier(obj, 0); + CheckCondition(rocksdb_options_get_lowest_used_cache_tier(obj) == 0); + rocksdb_options_set_max_bgerror_resume_count(obj, 1); + CheckCondition(rocksdb_options_get_max_bgerror_resume_count(obj) == 1); + rocksdb_options_set_max_bgerror_resume_count(obj, 0); + CheckCondition(rocksdb_options_get_max_bgerror_resume_count(obj) == 0); + rocksdb_options_set_max_manifest_space_amp_pct(obj, 1); + CheckCondition(rocksdb_options_get_max_manifest_space_amp_pct(obj) == 1); + rocksdb_options_set_max_manifest_space_amp_pct(obj, 0); + CheckCondition(rocksdb_options_get_max_manifest_space_amp_pct(obj) == 0); + rocksdb_options_set_max_write_batch_group_size_bytes(obj, 1); + CheckCondition(rocksdb_options_get_max_write_batch_group_size_bytes(obj) == + 1); + rocksdb_options_set_max_write_batch_group_size_bytes(obj, 0); + CheckCondition(rocksdb_options_get_max_write_batch_group_size_bytes(obj) == + 0); + rocksdb_options_set_memtable_batch_lookup_optimization(obj, 1); + CheckCondition(rocksdb_options_get_memtable_batch_lookup_optimization(obj) == + 1); + rocksdb_options_set_memtable_batch_lookup_optimization(obj, 0); + CheckCondition(rocksdb_options_get_memtable_batch_lookup_optimization(obj) == + 0); + rocksdb_options_set_memtable_max_range_deletions(obj, 1); + CheckCondition(rocksdb_options_get_memtable_max_range_deletions(obj) == 1); + rocksdb_options_set_memtable_max_range_deletions(obj, 0); + CheckCondition(rocksdb_options_get_memtable_max_range_deletions(obj) == 0); + rocksdb_options_set_memtable_protection_bytes_per_key(obj, 1); + CheckCondition(rocksdb_options_get_memtable_protection_bytes_per_key(obj) == + 1); + rocksdb_options_set_memtable_protection_bytes_per_key(obj, 0); + CheckCondition(rocksdb_options_get_memtable_protection_bytes_per_key(obj) == + 0); + rocksdb_options_set_memtable_verify_per_key_checksum_on_seek(obj, 1); + CheckCondition( + rocksdb_options_get_memtable_verify_per_key_checksum_on_seek(obj) == 1); + rocksdb_options_set_memtable_verify_per_key_checksum_on_seek(obj, 0); + CheckCondition( + rocksdb_options_get_memtable_verify_per_key_checksum_on_seek(obj) == 0); + rocksdb_options_set_metadata_write_temperature(obj, 1); + CheckCondition(rocksdb_options_get_metadata_write_temperature(obj) == 1); + rocksdb_options_set_metadata_write_temperature(obj, 0); + CheckCondition(rocksdb_options_get_metadata_write_temperature(obj) == 0); + rocksdb_options_set_optimize_manifest_for_recovery(obj, 1); + CheckCondition(rocksdb_options_get_optimize_manifest_for_recovery(obj) == 1); + rocksdb_options_set_optimize_manifest_for_recovery(obj, 0); + CheckCondition(rocksdb_options_get_optimize_manifest_for_recovery(obj) == 0); + rocksdb_options_set_paranoid_file_checks(obj, 1); + CheckCondition(rocksdb_options_get_paranoid_file_checks(obj) == 1); + rocksdb_options_set_paranoid_file_checks(obj, 0); + CheckCondition(rocksdb_options_get_paranoid_file_checks(obj) == 0); + rocksdb_options_set_paranoid_memory_checks(obj, 1); + CheckCondition(rocksdb_options_get_paranoid_memory_checks(obj) == 1); + rocksdb_options_set_paranoid_memory_checks(obj, 0); + CheckCondition(rocksdb_options_get_paranoid_memory_checks(obj) == 0); + rocksdb_options_set_persist_stats_to_disk(obj, 1); + CheckCondition(rocksdb_options_get_persist_stats_to_disk(obj) == 1); + rocksdb_options_set_persist_stats_to_disk(obj, 0); + CheckCondition(rocksdb_options_get_persist_stats_to_disk(obj) == 0); + rocksdb_options_set_persist_user_defined_timestamps(obj, 1); + CheckCondition(rocksdb_options_get_persist_user_defined_timestamps(obj) == 1); + rocksdb_options_set_persist_user_defined_timestamps(obj, 0); + CheckCondition(rocksdb_options_get_persist_user_defined_timestamps(obj) == 0); + rocksdb_options_set_preclude_last_level_data_seconds(obj, 1); + CheckCondition(rocksdb_options_get_preclude_last_level_data_seconds(obj) == + 1); + rocksdb_options_set_preclude_last_level_data_seconds(obj, 0); + CheckCondition(rocksdb_options_get_preclude_last_level_data_seconds(obj) == + 0); + rocksdb_options_set_prefix_seek_opt_in_only(obj, 1); + CheckCondition(rocksdb_options_get_prefix_seek_opt_in_only(obj) == 1); + rocksdb_options_set_prefix_seek_opt_in_only(obj, 0); + CheckCondition(rocksdb_options_get_prefix_seek_opt_in_only(obj) == 0); + rocksdb_options_set_preserve_internal_time_seconds(obj, 1); + CheckCondition(rocksdb_options_get_preserve_internal_time_seconds(obj) == 1); + rocksdb_options_set_preserve_internal_time_seconds(obj, 0); + CheckCondition(rocksdb_options_get_preserve_internal_time_seconds(obj) == 0); + rocksdb_options_set_reuse_manifest_on_open(obj, 1); + CheckCondition(rocksdb_options_get_reuse_manifest_on_open(obj) == 1); + rocksdb_options_set_reuse_manifest_on_open(obj, 0); + CheckCondition(rocksdb_options_get_reuse_manifest_on_open(obj) == 0); + rocksdb_options_set_sample_for_compression(obj, 1); + CheckCondition(rocksdb_options_get_sample_for_compression(obj) == 1); + rocksdb_options_set_sample_for_compression(obj, 0); + CheckCondition(rocksdb_options_get_sample_for_compression(obj) == 0); + rocksdb_options_set_stats_history_buffer_size(obj, 1); + CheckCondition(rocksdb_options_get_stats_history_buffer_size(obj) == 1); + rocksdb_options_set_stats_history_buffer_size(obj, 0); + CheckCondition(rocksdb_options_get_stats_history_buffer_size(obj) == 0); + rocksdb_options_set_strict_bytes_per_sync(obj, 1); + CheckCondition(rocksdb_options_get_strict_bytes_per_sync(obj) == 1); + rocksdb_options_set_strict_bytes_per_sync(obj, 0); + CheckCondition(rocksdb_options_get_strict_bytes_per_sync(obj) == 0); + rocksdb_options_set_strict_max_successive_merges(obj, 1); + CheckCondition(rocksdb_options_get_strict_max_successive_merges(obj) == 1); + rocksdb_options_set_strict_max_successive_merges(obj, 0); + CheckCondition(rocksdb_options_get_strict_max_successive_merges(obj) == 0); + rocksdb_options_set_target_file_size_is_upper_bound(obj, 1); + CheckCondition(rocksdb_options_get_target_file_size_is_upper_bound(obj) == 1); + rocksdb_options_set_target_file_size_is_upper_bound(obj, 0); + CheckCondition(rocksdb_options_get_target_file_size_is_upper_bound(obj) == 0); + rocksdb_options_set_track_and_verify_wals(obj, 1); + CheckCondition(rocksdb_options_get_track_and_verify_wals(obj) == 1); + rocksdb_options_set_track_and_verify_wals(obj, 0); + CheckCondition(rocksdb_options_get_track_and_verify_wals(obj) == 0); + rocksdb_options_set_two_write_queues(obj, 1); + CheckCondition(rocksdb_options_get_two_write_queues(obj) == 1); + rocksdb_options_set_two_write_queues(obj, 0); + CheckCondition(rocksdb_options_get_two_write_queues(obj) == 0); + rocksdb_options_set_uncache_aggressiveness(obj, 1); + CheckCondition(rocksdb_options_get_uncache_aggressiveness(obj) == 1); + rocksdb_options_set_uncache_aggressiveness(obj, 0); + CheckCondition(rocksdb_options_get_uncache_aggressiveness(obj) == 0); + rocksdb_options_set_use_direct_io_for_compaction_reads(obj, 1); + CheckCondition(rocksdb_options_get_use_direct_io_for_compaction_reads(obj) == + 1); + rocksdb_options_set_use_direct_io_for_compaction_reads(obj, 0); + CheckCondition(rocksdb_options_get_use_direct_io_for_compaction_reads(obj) == + 0); + rocksdb_options_set_use_fsync(obj, 1); + CheckCondition(rocksdb_options_get_use_fsync(obj) == 1); + rocksdb_options_set_use_fsync(obj, 0); + CheckCondition(rocksdb_options_get_use_fsync(obj) == 0); + rocksdb_options_set_verify_manifest_content_on_close(obj, 1); + CheckCondition(rocksdb_options_get_verify_manifest_content_on_close(obj) == + 1); + rocksdb_options_set_verify_manifest_content_on_close(obj, 0); + CheckCondition(rocksdb_options_get_verify_manifest_content_on_close(obj) == + 0); + rocksdb_options_set_verify_output_flags(obj, 1); + CheckCondition(rocksdb_options_get_verify_output_flags(obj) == 1); + rocksdb_options_set_verify_output_flags(obj, 0); + CheckCondition(rocksdb_options_get_verify_output_flags(obj) == 0); + rocksdb_options_set_verify_sst_unique_id_in_manifest(obj, 1); + CheckCondition(rocksdb_options_get_verify_sst_unique_id_in_manifest(obj) == + 1); + rocksdb_options_set_verify_sst_unique_id_in_manifest(obj, 0); + CheckCondition(rocksdb_options_get_verify_sst_unique_id_in_manifest(obj) == + 0); + rocksdb_options_set_wal_write_temperature(obj, 1); + CheckCondition(rocksdb_options_get_wal_write_temperature(obj) == 1); + rocksdb_options_set_wal_write_temperature(obj, 0); + CheckCondition(rocksdb_options_get_wal_write_temperature(obj) == 0); + rocksdb_options_set_write_thread_max_yield_usec(obj, 1); + CheckCondition(rocksdb_options_get_write_thread_max_yield_usec(obj) == 1); + rocksdb_options_set_write_thread_max_yield_usec(obj, 0); + CheckCondition(rocksdb_options_get_write_thread_max_yield_usec(obj) == 0); + rocksdb_options_set_write_thread_slow_yield_usec(obj, 1); + CheckCondition(rocksdb_options_get_write_thread_slow_yield_usec(obj) == 1); + rocksdb_options_set_write_thread_slow_yield_usec(obj, 0); + CheckCondition(rocksdb_options_get_write_thread_slow_yield_usec(obj) == 0); + rocksdb_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_readoptions(void) { + rocksdb_readoptions_t* obj = rocksdb_readoptions_create(); + rocksdb_readoptions_set_adaptive_readahead(obj, 1); + CheckCondition(rocksdb_readoptions_get_adaptive_readahead(obj) == 1); + rocksdb_readoptions_set_adaptive_readahead(obj, 0); + CheckCondition(rocksdb_readoptions_get_adaptive_readahead(obj) == 0); + rocksdb_readoptions_set_allow_unprepared_value(obj, 1); + CheckCondition(rocksdb_readoptions_get_allow_unprepared_value(obj) == 1); + rocksdb_readoptions_set_allow_unprepared_value(obj, 0); + CheckCondition(rocksdb_readoptions_get_allow_unprepared_value(obj) == 0); + rocksdb_readoptions_set_async_io(obj, 1); + CheckCondition(rocksdb_readoptions_get_async_io(obj) == 1); + rocksdb_readoptions_set_async_io(obj, 0); + CheckCondition(rocksdb_readoptions_get_async_io(obj) == 0); + rocksdb_readoptions_set_auto_prefix_mode(obj, 1); + CheckCondition(rocksdb_readoptions_get_auto_prefix_mode(obj) == 1); + rocksdb_readoptions_set_auto_prefix_mode(obj, 0); + CheckCondition(rocksdb_readoptions_get_auto_prefix_mode(obj) == 0); + rocksdb_readoptions_set_auto_readahead_size(obj, 1); + CheckCondition(rocksdb_readoptions_get_auto_readahead_size(obj) == 1); + rocksdb_readoptions_set_auto_readahead_size(obj, 0); + CheckCondition(rocksdb_readoptions_get_auto_readahead_size(obj) == 0); + rocksdb_readoptions_set_auto_refresh_iterator_with_snapshot(obj, 1); + CheckCondition( + rocksdb_readoptions_get_auto_refresh_iterator_with_snapshot(obj) == 1); + rocksdb_readoptions_set_auto_refresh_iterator_with_snapshot(obj, 0); + CheckCondition( + rocksdb_readoptions_get_auto_refresh_iterator_with_snapshot(obj) == 0); + rocksdb_readoptions_set_background_purge_on_iterator_cleanup(obj, 1); + CheckCondition( + rocksdb_readoptions_get_background_purge_on_iterator_cleanup(obj) == 1); + rocksdb_readoptions_set_background_purge_on_iterator_cleanup(obj, 0); + CheckCondition( + rocksdb_readoptions_get_background_purge_on_iterator_cleanup(obj) == 0); + rocksdb_readoptions_set_deadline(obj, 1); + CheckCondition(rocksdb_readoptions_get_deadline(obj) == 1); + rocksdb_readoptions_set_deadline(obj, 0); + CheckCondition(rocksdb_readoptions_get_deadline(obj) == 0); + rocksdb_readoptions_set_fill_cache(obj, 1); + CheckCondition(rocksdb_readoptions_get_fill_cache(obj) == 1); + rocksdb_readoptions_set_fill_cache(obj, 0); + CheckCondition(rocksdb_readoptions_get_fill_cache(obj) == 0); + rocksdb_readoptions_set_ignore_range_deletions(obj, 1); + CheckCondition(rocksdb_readoptions_get_ignore_range_deletions(obj) == 1); + rocksdb_readoptions_set_ignore_range_deletions(obj, 0); + CheckCondition(rocksdb_readoptions_get_ignore_range_deletions(obj) == 0); + rocksdb_readoptions_set_io_activity(obj, 1); + CheckCondition(rocksdb_readoptions_get_io_activity(obj) == 1); + rocksdb_readoptions_set_io_activity(obj, 0); + CheckCondition(rocksdb_readoptions_get_io_activity(obj) == 0); + rocksdb_readoptions_set_io_timeout(obj, 1); + CheckCondition(rocksdb_readoptions_get_io_timeout(obj) == 1); + rocksdb_readoptions_set_io_timeout(obj, 0); + CheckCondition(rocksdb_readoptions_get_io_timeout(obj) == 0); + rocksdb_readoptions_set_max_skippable_internal_keys(obj, 1); + CheckCondition(rocksdb_readoptions_get_max_skippable_internal_keys(obj) == 1); + rocksdb_readoptions_set_max_skippable_internal_keys(obj, 0); + CheckCondition(rocksdb_readoptions_get_max_skippable_internal_keys(obj) == 0); + rocksdb_readoptions_set_optimize_multiget_for_io(obj, 1); + CheckCondition(rocksdb_readoptions_get_optimize_multiget_for_io(obj) == 1); + rocksdb_readoptions_set_optimize_multiget_for_io(obj, 0); + CheckCondition(rocksdb_readoptions_get_optimize_multiget_for_io(obj) == 0); + rocksdb_readoptions_set_pin_data(obj, 1); + CheckCondition(rocksdb_readoptions_get_pin_data(obj) == 1); + rocksdb_readoptions_set_pin_data(obj, 0); + CheckCondition(rocksdb_readoptions_get_pin_data(obj) == 0); + rocksdb_readoptions_set_prefix_same_as_start(obj, 1); + CheckCondition(rocksdb_readoptions_get_prefix_same_as_start(obj) == 1); + rocksdb_readoptions_set_prefix_same_as_start(obj, 0); + CheckCondition(rocksdb_readoptions_get_prefix_same_as_start(obj) == 0); + rocksdb_readoptions_set_rate_limiter_priority(obj, 1); + CheckCondition(rocksdb_readoptions_get_rate_limiter_priority(obj) == 1); + rocksdb_readoptions_set_rate_limiter_priority(obj, 0); + CheckCondition(rocksdb_readoptions_get_rate_limiter_priority(obj) == 0); + rocksdb_readoptions_set_read_tier(obj, 1); + CheckCondition(rocksdb_readoptions_get_read_tier(obj) == 1); + rocksdb_readoptions_set_read_tier(obj, 0); + CheckCondition(rocksdb_readoptions_get_read_tier(obj) == 0); + rocksdb_readoptions_set_readahead_size(obj, 1); + CheckCondition(rocksdb_readoptions_get_readahead_size(obj) == 1); + rocksdb_readoptions_set_readahead_size(obj, 0); + CheckCondition(rocksdb_readoptions_get_readahead_size(obj) == 0); + rocksdb_readoptions_set_tailing(obj, 1); + CheckCondition(rocksdb_readoptions_get_tailing(obj) == 1); + rocksdb_readoptions_set_tailing(obj, 0); + CheckCondition(rocksdb_readoptions_get_tailing(obj) == 0); + rocksdb_readoptions_set_total_order_seek(obj, 1); + CheckCondition(rocksdb_readoptions_get_total_order_seek(obj) == 1); + rocksdb_readoptions_set_total_order_seek(obj, 0); + CheckCondition(rocksdb_readoptions_get_total_order_seek(obj) == 0); + rocksdb_readoptions_set_value_size_soft_limit(obj, 1); + CheckCondition(rocksdb_readoptions_get_value_size_soft_limit(obj) == 1); + rocksdb_readoptions_set_value_size_soft_limit(obj, 0); + CheckCondition(rocksdb_readoptions_get_value_size_soft_limit(obj) == 0); + rocksdb_readoptions_set_verify_checksums(obj, 1); + CheckCondition(rocksdb_readoptions_get_verify_checksums(obj) == 1); + rocksdb_readoptions_set_verify_checksums(obj, 0); + CheckCondition(rocksdb_readoptions_get_verify_checksums(obj) == 0); + rocksdb_readoptions_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_restore_options(void) { + rocksdb_restore_options_t* obj = rocksdb_restore_options_create(); + rocksdb_restore_options_set_keep_log_files(obj, 1); + CheckCondition(rocksdb_restore_options_get_keep_log_files(obj) == 1); + rocksdb_restore_options_set_keep_log_files(obj, 0); + CheckCondition(rocksdb_restore_options_get_keep_log_files(obj) == 0); + rocksdb_restore_options_set_mode(obj, 1); + CheckCondition(rocksdb_restore_options_get_mode(obj) == 1); + rocksdb_restore_options_set_mode(obj, 0); + CheckCondition(rocksdb_restore_options_get_mode(obj) == 0); + rocksdb_restore_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_size_approximation_options(void) { + rocksdb_size_approximation_options_t* obj = + rocksdb_size_approximation_options_create(); + rocksdb_size_approximation_options_set_files_size_error_margin(obj, 1); + CheckCondition( + rocksdb_size_approximation_options_get_files_size_error_margin(obj) == 1); + rocksdb_size_approximation_options_set_files_size_error_margin(obj, 0); + CheckCondition( + rocksdb_size_approximation_options_get_files_size_error_margin(obj) == 0); + rocksdb_size_approximation_options_set_include_blob_files(obj, 1); + CheckCondition( + rocksdb_size_approximation_options_get_include_blob_files(obj) == 1); + rocksdb_size_approximation_options_set_include_blob_files(obj, 0); + CheckCondition( + rocksdb_size_approximation_options_get_include_blob_files(obj) == 0); + rocksdb_size_approximation_options_set_include_files(obj, 1); + CheckCondition(rocksdb_size_approximation_options_get_include_files(obj) == + 1); + rocksdb_size_approximation_options_set_include_files(obj, 0); + CheckCondition(rocksdb_size_approximation_options_get_include_files(obj) == + 0); + rocksdb_size_approximation_options_set_include_memtables(obj, 1); + CheckCondition( + rocksdb_size_approximation_options_get_include_memtables(obj) == 1); + rocksdb_size_approximation_options_set_include_memtables(obj, 0); + CheckCondition( + rocksdb_size_approximation_options_get_include_memtables(obj) == 0); + rocksdb_size_approximation_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_trace_options(void) { + rocksdb_trace_options_t* obj = rocksdb_trace_options_create(); + rocksdb_trace_options_set_filter(obj, 1); + CheckCondition(rocksdb_trace_options_get_filter(obj) == 1); + rocksdb_trace_options_set_filter(obj, 0); + CheckCondition(rocksdb_trace_options_get_filter(obj) == 0); + rocksdb_trace_options_set_max_trace_file_size(obj, 1); + CheckCondition(rocksdb_trace_options_get_max_trace_file_size(obj) == 1); + rocksdb_trace_options_set_max_trace_file_size(obj, 0); + CheckCondition(rocksdb_trace_options_get_max_trace_file_size(obj) == 0); + rocksdb_trace_options_set_preserve_write_order(obj, 1); + CheckCondition(rocksdb_trace_options_get_preserve_write_order(obj) == 1); + rocksdb_trace_options_set_preserve_write_order(obj, 0); + CheckCondition(rocksdb_trace_options_get_preserve_write_order(obj) == 0); + rocksdb_trace_options_set_sampling_frequency(obj, 1); + CheckCondition(rocksdb_trace_options_get_sampling_frequency(obj) == 1); + rocksdb_trace_options_set_sampling_frequency(obj, 0); + CheckCondition(rocksdb_trace_options_get_sampling_frequency(obj) == 0); + rocksdb_trace_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_transaction_options(void) { + rocksdb_transaction_options_t* obj = rocksdb_transaction_options_create(); + rocksdb_transaction_options_set_commit_bypass_memtable(obj, 1); + CheckCondition(rocksdb_transaction_options_get_commit_bypass_memtable(obj) == + 1); + rocksdb_transaction_options_set_commit_bypass_memtable(obj, 0); + CheckCondition(rocksdb_transaction_options_get_commit_bypass_memtable(obj) == + 0); + rocksdb_transaction_options_set_deadlock_detect(obj, 1); + CheckCondition(rocksdb_transaction_options_get_deadlock_detect(obj) == 1); + rocksdb_transaction_options_set_deadlock_detect(obj, 0); + CheckCondition(rocksdb_transaction_options_get_deadlock_detect(obj) == 0); + rocksdb_transaction_options_set_deadlock_detect_depth(obj, 1); + CheckCondition(rocksdb_transaction_options_get_deadlock_detect_depth(obj) == + 1); + rocksdb_transaction_options_set_deadlock_detect_depth(obj, 0); + CheckCondition(rocksdb_transaction_options_get_deadlock_detect_depth(obj) == + 0); + rocksdb_transaction_options_set_deadlock_timeout_us(obj, 1); + CheckCondition(rocksdb_transaction_options_get_deadlock_timeout_us(obj) == 1); + rocksdb_transaction_options_set_deadlock_timeout_us(obj, 0); + CheckCondition(rocksdb_transaction_options_get_deadlock_timeout_us(obj) == 0); + rocksdb_transaction_options_set_expiration(obj, 1); + CheckCondition(rocksdb_transaction_options_get_expiration(obj) == 1); + rocksdb_transaction_options_set_expiration(obj, 0); + CheckCondition(rocksdb_transaction_options_get_expiration(obj) == 0); + rocksdb_transaction_options_set_large_txn_commit_optimize_byte_threshold(obj, + 1); + CheckCondition( + rocksdb_transaction_options_get_large_txn_commit_optimize_byte_threshold( + obj) == 1); + rocksdb_transaction_options_set_large_txn_commit_optimize_byte_threshold(obj, + 0); + CheckCondition( + rocksdb_transaction_options_get_large_txn_commit_optimize_byte_threshold( + obj) == 0); + rocksdb_transaction_options_set_large_txn_commit_optimize_threshold(obj, 1); + CheckCondition( + rocksdb_transaction_options_get_large_txn_commit_optimize_threshold( + obj) == 1); + rocksdb_transaction_options_set_large_txn_commit_optimize_threshold(obj, 0); + CheckCondition( + rocksdb_transaction_options_get_large_txn_commit_optimize_threshold( + obj) == 0); + rocksdb_transaction_options_set_lock_timeout(obj, 1); + CheckCondition(rocksdb_transaction_options_get_lock_timeout(obj) == 1); + rocksdb_transaction_options_set_lock_timeout(obj, 0); + CheckCondition(rocksdb_transaction_options_get_lock_timeout(obj) == 0); + rocksdb_transaction_options_set_max_write_batch_size(obj, 1); + CheckCondition(rocksdb_transaction_options_get_max_write_batch_size(obj) == + 1); + rocksdb_transaction_options_set_max_write_batch_size(obj, 0); + CheckCondition(rocksdb_transaction_options_get_max_write_batch_size(obj) == + 0); + rocksdb_transaction_options_set_skip_concurrency_control(obj, 1); + CheckCondition( + rocksdb_transaction_options_get_skip_concurrency_control(obj) == 1); + rocksdb_transaction_options_set_skip_concurrency_control(obj, 0); + CheckCondition( + rocksdb_transaction_options_get_skip_concurrency_control(obj) == 0); + rocksdb_transaction_options_set_skip_prepare(obj, 1); + CheckCondition(rocksdb_transaction_options_get_skip_prepare(obj) == 1); + rocksdb_transaction_options_set_skip_prepare(obj, 0); + CheckCondition(rocksdb_transaction_options_get_skip_prepare(obj) == 0); + rocksdb_transaction_options_set_use_only_the_last_commit_time_batch_for_recovery( + obj, 1); + CheckCondition( + rocksdb_transaction_options_get_use_only_the_last_commit_time_batch_for_recovery( + obj) == 1); + rocksdb_transaction_options_set_use_only_the_last_commit_time_batch_for_recovery( + obj, 0); + CheckCondition( + rocksdb_transaction_options_get_use_only_the_last_commit_time_batch_for_recovery( + obj) == 0); + rocksdb_transaction_options_set_write_batch_flush_threshold(obj, 1); + CheckCondition( + rocksdb_transaction_options_get_write_batch_flush_threshold(obj) == 1); + rocksdb_transaction_options_set_write_batch_flush_threshold(obj, 0); + CheckCondition( + rocksdb_transaction_options_get_write_batch_flush_threshold(obj) == 0); + rocksdb_transaction_options_set_write_batch_track_timestamp_size(obj, 1); + CheckCondition( + rocksdb_transaction_options_get_write_batch_track_timestamp_size(obj) == + 1); + rocksdb_transaction_options_set_write_batch_track_timestamp_size(obj, 0); + CheckCondition( + rocksdb_transaction_options_get_write_batch_track_timestamp_size(obj) == + 0); + rocksdb_transaction_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_transactiondb_options(void) { + rocksdb_transactiondb_options_t* obj = rocksdb_transactiondb_options_create(); + rocksdb_transactiondb_options_set_default_lock_timeout(obj, 1); + CheckCondition(rocksdb_transactiondb_options_get_default_lock_timeout(obj) == + 1); + rocksdb_transactiondb_options_set_default_lock_timeout(obj, 0); + CheckCondition(rocksdb_transactiondb_options_get_default_lock_timeout(obj) == + 0); + rocksdb_transactiondb_options_set_default_write_batch_flush_threshold(obj, 1); + CheckCondition( + rocksdb_transactiondb_options_get_default_write_batch_flush_threshold( + obj) == 1); + rocksdb_transactiondb_options_set_default_write_batch_flush_threshold(obj, 0); + CheckCondition( + rocksdb_transactiondb_options_get_default_write_batch_flush_threshold( + obj) == 0); + rocksdb_transactiondb_options_set_enable_udt_validation(obj, 1); + CheckCondition(rocksdb_transactiondb_options_get_enable_udt_validation(obj) == + 1); + rocksdb_transactiondb_options_set_enable_udt_validation(obj, 0); + CheckCondition(rocksdb_transactiondb_options_get_enable_udt_validation(obj) == + 0); + rocksdb_transactiondb_options_set_max_num_deadlocks(obj, 1); + CheckCondition(rocksdb_transactiondb_options_get_max_num_deadlocks(obj) == 1); + rocksdb_transactiondb_options_set_max_num_deadlocks(obj, 0); + CheckCondition(rocksdb_transactiondb_options_get_max_num_deadlocks(obj) == 0); + rocksdb_transactiondb_options_set_max_num_locks(obj, 1); + CheckCondition(rocksdb_transactiondb_options_get_max_num_locks(obj) == 1); + rocksdb_transactiondb_options_set_max_num_locks(obj, 0); + CheckCondition(rocksdb_transactiondb_options_get_max_num_locks(obj) == 0); + rocksdb_transactiondb_options_set_num_stripes(obj, 1); + CheckCondition(rocksdb_transactiondb_options_get_num_stripes(obj) == 1); + rocksdb_transactiondb_options_set_num_stripes(obj, 0); + CheckCondition(rocksdb_transactiondb_options_get_num_stripes(obj) == 0); + rocksdb_transactiondb_options_set_rollback_merge_operands(obj, 1); + CheckCondition( + rocksdb_transactiondb_options_get_rollback_merge_operands(obj) == 1); + rocksdb_transactiondb_options_set_rollback_merge_operands(obj, 0); + CheckCondition( + rocksdb_transactiondb_options_get_rollback_merge_operands(obj) == 0); + rocksdb_transactiondb_options_set_skip_concurrency_control(obj, 1); + CheckCondition( + rocksdb_transactiondb_options_get_skip_concurrency_control(obj) == 1); + rocksdb_transactiondb_options_set_skip_concurrency_control(obj, 0); + CheckCondition( + rocksdb_transactiondb_options_get_skip_concurrency_control(obj) == 0); + rocksdb_transactiondb_options_set_transaction_lock_timeout(obj, 1); + CheckCondition( + rocksdb_transactiondb_options_get_transaction_lock_timeout(obj) == 1); + rocksdb_transactiondb_options_set_transaction_lock_timeout(obj, 0); + CheckCondition( + rocksdb_transactiondb_options_get_transaction_lock_timeout(obj) == 0); + rocksdb_transactiondb_options_set_txn_commit_bypass_memtable_threshold(obj, + 1); + CheckCondition( + rocksdb_transactiondb_options_get_txn_commit_bypass_memtable_threshold( + obj) == 1); + rocksdb_transactiondb_options_set_txn_commit_bypass_memtable_threshold(obj, + 0); + CheckCondition( + rocksdb_transactiondb_options_get_txn_commit_bypass_memtable_threshold( + obj) == 0); + rocksdb_transactiondb_options_set_use_per_key_point_lock_mgr(obj, 1); + CheckCondition( + rocksdb_transactiondb_options_get_use_per_key_point_lock_mgr(obj) == 1); + rocksdb_transactiondb_options_set_use_per_key_point_lock_mgr(obj, 0); + CheckCondition( + rocksdb_transactiondb_options_get_use_per_key_point_lock_mgr(obj) == 0); + rocksdb_transactiondb_options_set_write_policy(obj, 1); + CheckCondition(rocksdb_transactiondb_options_get_write_policy(obj) == 1); + rocksdb_transactiondb_options_set_write_policy(obj, 0); + CheckCondition(rocksdb_transactiondb_options_get_write_policy(obj) == 0); + rocksdb_transactiondb_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_universal_compaction_options(void) { + rocksdb_universal_compaction_options_t* obj = + rocksdb_universal_compaction_options_create(); + rocksdb_universal_compaction_options_set_allow_trivial_move(obj, 1); + CheckCondition( + rocksdb_universal_compaction_options_get_allow_trivial_move(obj) == 1); + rocksdb_universal_compaction_options_set_allow_trivial_move(obj, 0); + CheckCondition( + rocksdb_universal_compaction_options_get_allow_trivial_move(obj) == 0); + rocksdb_universal_compaction_options_set_incremental(obj, 1); + CheckCondition(rocksdb_universal_compaction_options_get_incremental(obj) == + 1); + rocksdb_universal_compaction_options_set_incremental(obj, 0); + CheckCondition(rocksdb_universal_compaction_options_get_incremental(obj) == + 0); + rocksdb_universal_compaction_options_set_max_read_amp(obj, 1); + CheckCondition(rocksdb_universal_compaction_options_get_max_read_amp(obj) == + 1); + rocksdb_universal_compaction_options_set_max_read_amp(obj, 0); + CheckCondition(rocksdb_universal_compaction_options_get_max_read_amp(obj) == + 0); + rocksdb_universal_compaction_options_set_reduce_file_locking(obj, 1); + CheckCondition( + rocksdb_universal_compaction_options_get_reduce_file_locking(obj) == 1); + rocksdb_universal_compaction_options_set_reduce_file_locking(obj, 0); + CheckCondition( + rocksdb_universal_compaction_options_get_reduce_file_locking(obj) == 0); + rocksdb_universal_compaction_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_wait_for_compact_options(void) { + rocksdb_wait_for_compact_options_t* obj = + rocksdb_wait_for_compact_options_create(); + rocksdb_wait_for_compact_options_set_wait_for_purge(obj, 1); + CheckCondition(rocksdb_wait_for_compact_options_get_wait_for_purge(obj) == 1); + rocksdb_wait_for_compact_options_set_wait_for_purge(obj, 0); + CheckCondition(rocksdb_wait_for_compact_options_get_wait_for_purge(obj) == 0); + rocksdb_wait_for_compact_options_destroy(obj); +} + +static void rocksdb_roundtrip_test_rocksdb_writeoptions(void) { + rocksdb_writeoptions_t* obj = rocksdb_writeoptions_create(); + rocksdb_writeoptions_set_ignore_missing_column_families(obj, 1); + CheckCondition(rocksdb_writeoptions_get_ignore_missing_column_families(obj) == + 1); + rocksdb_writeoptions_set_ignore_missing_column_families(obj, 0); + CheckCondition(rocksdb_writeoptions_get_ignore_missing_column_families(obj) == + 0); + rocksdb_writeoptions_set_io_activity(obj, 1); + CheckCondition(rocksdb_writeoptions_get_io_activity(obj) == 1); + rocksdb_writeoptions_set_io_activity(obj, 0); + CheckCondition(rocksdb_writeoptions_get_io_activity(obj) == 0); + rocksdb_writeoptions_set_low_pri(obj, 1); + CheckCondition(rocksdb_writeoptions_get_low_pri(obj) == 1); + rocksdb_writeoptions_set_low_pri(obj, 0); + CheckCondition(rocksdb_writeoptions_get_low_pri(obj) == 0); + rocksdb_writeoptions_set_memtable_insert_hint_per_batch(obj, 1); + CheckCondition(rocksdb_writeoptions_get_memtable_insert_hint_per_batch(obj) == + 1); + rocksdb_writeoptions_set_memtable_insert_hint_per_batch(obj, 0); + CheckCondition(rocksdb_writeoptions_get_memtable_insert_hint_per_batch(obj) == + 0); + rocksdb_writeoptions_set_no_slowdown(obj, 1); + CheckCondition(rocksdb_writeoptions_get_no_slowdown(obj) == 1); + rocksdb_writeoptions_set_no_slowdown(obj, 0); + CheckCondition(rocksdb_writeoptions_get_no_slowdown(obj) == 0); + rocksdb_writeoptions_set_protection_bytes_per_key(obj, 1); + CheckCondition(rocksdb_writeoptions_get_protection_bytes_per_key(obj) == 1); + rocksdb_writeoptions_set_protection_bytes_per_key(obj, 0); + CheckCondition(rocksdb_writeoptions_get_protection_bytes_per_key(obj) == 0); + rocksdb_writeoptions_set_rate_limiter_priority(obj, 1); + CheckCondition(rocksdb_writeoptions_get_rate_limiter_priority(obj) == 1); + rocksdb_writeoptions_set_rate_limiter_priority(obj, 0); + CheckCondition(rocksdb_writeoptions_get_rate_limiter_priority(obj) == 0); + rocksdb_writeoptions_set_sync(obj, 1); + CheckCondition(rocksdb_writeoptions_get_sync(obj) == 1); + rocksdb_writeoptions_set_sync(obj, 0); + CheckCondition(rocksdb_writeoptions_get_sync(obj) == 0); + rocksdb_writeoptions_destroy(obj); +} + +static void rocksdb_run_generated_roundtrip_tests(void) { + rocksdb_roundtrip_test_rocksdb_block_based_options(); + rocksdb_roundtrip_test_rocksdb_block_cache_trace_options(); + rocksdb_roundtrip_test_rocksdb_block_cache_trace_writer_options(); + rocksdb_roundtrip_test_rocksdb_column_family_metadata_options(); + rocksdb_roundtrip_test_rocksdb_compaction_options(); + rocksdb_roundtrip_test_rocksdb_compactoptions(); + rocksdb_roundtrip_test_rocksdb_create_backup_options(); + rocksdb_roundtrip_test_rocksdb_cuckoo_options(); + rocksdb_roundtrip_test_rocksdb_envoptions(); + rocksdb_roundtrip_test_rocksdb_fifo_compaction_options(); + rocksdb_roundtrip_test_rocksdb_flushoptions(); + rocksdb_roundtrip_test_rocksdb_flushwaloptions(); + rocksdb_roundtrip_test_rocksdb_ingestexternalfileoptions(); + rocksdb_roundtrip_test_rocksdb_livefiles_storage_info_options(); + rocksdb_roundtrip_test_rocksdb_optimistictransactiondb_options(); + rocksdb_roundtrip_test_rocksdb_options(); + rocksdb_roundtrip_test_rocksdb_readoptions(); + rocksdb_roundtrip_test_rocksdb_restore_options(); + rocksdb_roundtrip_test_rocksdb_size_approximation_options(); + rocksdb_roundtrip_test_rocksdb_trace_options(); + rocksdb_roundtrip_test_rocksdb_transaction_options(); + rocksdb_roundtrip_test_rocksdb_transactiondb_options(); + rocksdb_roundtrip_test_rocksdb_universal_compaction_options(); + rocksdb_roundtrip_test_rocksdb_wait_for_compact_options(); + rocksdb_roundtrip_test_rocksdb_writeoptions(); +} diff --git a/c_api_gen/c_generated_subset.cc.inc b/c_api_gen/c_generated_subset.cc.inc new file mode 100644 index 0000000000..890e769df9 --- /dev/null +++ b/c_api_gen/c_generated_subset.cc.inc @@ -0,0 +1,371 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'DB data operations' +// --section 'WriteBatch' --section 'Transaction' +// --section 'TransactionDB simple' +// --header-out +// c_api_gen/c_generated_subset.h.inc +// --source-out +// c_api_gen/c_generated_subset.cc.inc + +/* DB data operations */ + +void rocksdb_put(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, + db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_put_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, const char* val, + size_t vallen, char** errptr) { + SaveError(errptr, db->rep->Put(options->rep, column_family->rep, + Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_delete(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, char** errptr) { + SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen))); +} + +void rocksdb_delete_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, char** errptr) { + SaveError(errptr, db->rep->Delete(options->rep, column_family->rep, + Slice(key, keylen))); +} + +void rocksdb_merge(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, const char* val, + size_t vallen, char** errptr) { + SaveError(errptr, db->rep->Merge(options->rep, Slice(key, keylen), + Slice(val, vallen))); +} + +void rocksdb_merge_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, const char* val, + size_t vallen, char** errptr) { + SaveError(errptr, db->rep->Merge(options->rep, column_family->rep, + Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_write(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr) { + SaveError(errptr, db->rep->Write(options->rep, &batch->rep)); +} + +void rocksdb_put_with_ts(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, const char* ts, + size_t tslen, const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, db->rep->Put(options->rep, Slice(key, keylen), + Slice(ts, tslen), Slice(val, vallen))); +} + +void rocksdb_put_cf_with_ts(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, const char* ts, + size_t tslen, const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, + db->rep->Put(options->rep, column_family->rep, Slice(key, keylen), + Slice(ts, tslen), Slice(val, vallen))); +} + +void rocksdb_delete_with_ts(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, const char* ts, + size_t tslen, char** errptr) { + SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen), + Slice(ts, tslen))); +} + +void rocksdb_delete_cf_with_ts(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, const char* ts, + size_t tslen, char** errptr) { + SaveError(errptr, db->rep->Delete(options->rep, column_family->rep, + Slice(key, keylen), Slice(ts, tslen))); +} + +void rocksdb_singledelete(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, char** errptr) { + SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen))); +} + +void rocksdb_singledelete_cf(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, char** errptr) { + SaveError(errptr, db->rep->SingleDelete(options->rep, column_family->rep, + Slice(key, keylen))); +} + +void rocksdb_singledelete_with_ts(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, + const char* ts, size_t tslen, char** errptr) { + SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen), + Slice(ts, tslen))); +} + +void rocksdb_singledelete_cf_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* ts, size_t tslen, char** errptr) { + SaveError(errptr, + db->rep->SingleDelete(options->rep, column_family->rep, + Slice(key, keylen), Slice(ts, tslen))); +} + +void rocksdb_delete_range_cf(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, + const char* end_key, size_t end_key_len, + char** errptr) { + SaveError(errptr, db->rep->DeleteRange(options->rep, column_family->rep, + Slice(start_key, start_key_len), + Slice(end_key, end_key_len))); +} + +void rocksdb_flush(rocksdb_t* db, const rocksdb_flushoptions_t* options, + char** errptr) { + SaveError(errptr, db->rep->Flush(options->rep)); +} + +void rocksdb_flush_cf(rocksdb_t* db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, + char** errptr) { + SaveError(errptr, db->rep->Flush(options->rep, column_family->rep)); +} + +void rocksdb_flush_wal(rocksdb_t* db, unsigned char sync, char** errptr) { + SaveError(errptr, db->rep->FlushWAL(sync)); +} + +void rocksdb_pause_background_work(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->PauseBackgroundWork()); +} + +void rocksdb_continue_background_work(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->ContinueBackgroundWork()); +} + +void rocksdb_disable_file_deletions(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->DisableFileDeletions()); +} + +void rocksdb_enable_file_deletions(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->EnableFileDeletions()); +} + +void rocksdb_verify_checksum(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->VerifyChecksum()); +} + +void rocksdb_verify_file_checksums(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->VerifyFileChecksums(ReadOptions())); +} + +void rocksdb_destroy_db(const rocksdb_options_t* options, const char* name, + char** errptr) { + SaveError(errptr, DestroyDB(name, options->rep)); +} + +void rocksdb_repair_db(const rocksdb_options_t* options, const char* name, + char** errptr) { + SaveError(errptr, RepairDB(name, options->rep)); +} + +/* WriteBatch */ + +void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) { b->rep.Clear(); } + +void rocksdb_writebatch_put(rocksdb_writebatch_t* b, const char* key, + size_t klen, const char* val, size_t vlen) { + b->rep.Put(Slice(key, klen), Slice(val, vlen)); +} + +void rocksdb_writebatch_put_cf(rocksdb_writebatch_t* b, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, + size_t vlen) { + b->rep.Put(column_family->rep, Slice(key, klen), Slice(val, vlen)); +} + +void rocksdb_writebatch_delete(rocksdb_writebatch_t* b, const char* key, + size_t klen) { + b->rep.Delete(Slice(key, klen)); +} + +void rocksdb_writebatch_put_log_data(rocksdb_writebatch_t* b, const char* blob, + size_t len) { + b->rep.PutLogData(Slice(blob, len)); +} + +void rocksdb_writebatch_set_save_point(rocksdb_writebatch_t* b) { + b->rep.SetSavePoint(); +} + +void rocksdb_writebatch_rollback_to_save_point(rocksdb_writebatch_t* b, + char** errptr) { + SaveError(errptr, b->rep.RollbackToSavePoint()); +} + +void rocksdb_writebatch_pop_save_point(rocksdb_writebatch_t* b, char** errptr) { + SaveError(errptr, b->rep.PopSavePoint()); +} + +void rocksdb_writebatch_verify_checksum(rocksdb_writebatch_t* b, + char** errptr) { + SaveError(errptr, b->rep.VerifyChecksum()); +} + +/* Transaction */ + +void rocksdb_transaction_put(rocksdb_transaction_t* txn, const char* key, + size_t klen, const char* val, size_t vlen, + char** errptr) { + SaveError(errptr, txn->rep->Put(Slice(key, klen), Slice(val, vlen))); +} + +void rocksdb_transaction_put_cf(rocksdb_transaction_t* txn, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, + size_t vlen, char** errptr) { + SaveError(errptr, txn->rep->Put(column_family->rep, Slice(key, klen), + Slice(val, vlen))); +} + +void rocksdb_transaction_merge(rocksdb_transaction_t* txn, const char* key, + size_t klen, const char* val, size_t vlen, + char** errptr) { + SaveError(errptr, txn->rep->Merge(Slice(key, klen), Slice(val, vlen))); +} + +void rocksdb_transaction_merge_cf(rocksdb_transaction_t* txn, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, + size_t vlen, char** errptr) { + SaveError(errptr, txn->rep->Merge(column_family->rep, Slice(key, klen), + Slice(val, vlen))); +} + +void rocksdb_transaction_delete(rocksdb_transaction_t* txn, const char* key, + size_t klen, char** errptr) { + SaveError(errptr, txn->rep->Delete(Slice(key, klen))); +} + +void rocksdb_transaction_delete_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, char** errptr) { + SaveError(errptr, txn->rep->Delete(column_family->rep, Slice(key, klen))); +} + +void rocksdb_transaction_commit(rocksdb_transaction_t* txn, char** errptr) { + SaveError(errptr, txn->rep->Commit()); +} + +void rocksdb_transaction_rollback(rocksdb_transaction_t* txn, char** errptr) { + SaveError(errptr, txn->rep->Rollback()); +} + +void rocksdb_transaction_put_log_data(rocksdb_transaction_t* txn, + const char* blob, size_t len) { + txn->rep->PutLogData(Slice(blob, len)); +} + +void rocksdb_transaction_set_savepoint(rocksdb_transaction_t* txn) { + txn->rep->SetSavePoint(); +} + +void rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t* txn, + char** errptr) { + SaveError(errptr, txn->rep->RollbackToSavePoint()); +} + +/* TransactionDB simple */ + +void rocksdb_transactiondb_put(rocksdb_transactiondb_t* txn_db, + const rocksdb_writeoptions_t* options, + const char* key, size_t klen, const char* val, + size_t vlen, char** errptr) { + SaveError(errptr, + txn_db->rep->Put(options->rep, Slice(key, klen), Slice(val, vlen))); +} + +void rocksdb_transactiondb_put_cf(rocksdb_transactiondb_t* txn_db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, + const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, txn_db->rep->Put(options->rep, column_family->rep, + Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_transactiondb_write(rocksdb_transactiondb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr) { + SaveError(errptr, db->rep->Write(options->rep, &batch->rep)); +} + +void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db, + const rocksdb_writeoptions_t* options, + const char* key, size_t klen, const char* val, + size_t vlen, char** errptr) { + SaveError(errptr, txn_db->rep->Merge(options->rep, Slice(key, klen), + Slice(val, vlen))); +} + +void rocksdb_transactiondb_merge_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, + const char* val, size_t vlen, char** errptr) { + SaveError(errptr, txn_db->rep->Merge(options->rep, column_family->rep, + Slice(key, klen), Slice(val, vlen))); +} + +void rocksdb_transactiondb_delete(rocksdb_transactiondb_t* txn_db, + const rocksdb_writeoptions_t* options, + const char* key, size_t klen, char** errptr) { + SaveError(errptr, txn_db->rep->Delete(options->rep, Slice(key, klen))); +} + +void rocksdb_transactiondb_delete_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr) { + SaveError(errptr, txn_db->rep->Delete(options->rep, column_family->rep, + Slice(key, keylen))); +} + +void rocksdb_transactiondb_flush_wal(rocksdb_transactiondb_t* txn_db, + unsigned char sync, char** errptr) { + SaveError(errptr, txn_db->rep->FlushWAL(sync)); +} + +void rocksdb_transactiondb_flush(rocksdb_transactiondb_t* txn_db, + const rocksdb_flushoptions_t* options, + char** errptr) { + SaveError(errptr, txn_db->rep->Flush(options->rep)); +} + +void rocksdb_transactiondb_flush_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, char** errptr) { + SaveError(errptr, txn_db->rep->Flush(options->rep, column_family->rep)); +} diff --git a/c_api_gen/c_generated_subset.h.inc b/c_api_gen/c_generated_subset.h.inc new file mode 100644 index 0000000000..9b2c96686c --- /dev/null +++ b/c_api_gen/c_generated_subset.h.inc @@ -0,0 +1,245 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'DB data operations' +// --section 'WriteBatch' --section 'Transaction' +// --section 'TransactionDB simple' +// --header-out +// c_api_gen/c_generated_subset.h.inc +// --source-out +// c_api_gen/c_generated_subset.cc.inc + +/* DB data operations */ + +extern ROCKSDB_LIBRARY_API void rocksdb_put( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_put_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_merge( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_merge_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_write( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_put_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* ts, size_t tslen, const char* val, size_t vallen, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_put_cf_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* ts, size_t tslen, const char* val, size_t vallen, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* ts, size_t tslen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_cf_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* ts, size_t tslen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_singledelete( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* ts, size_t tslen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_cf_with_ts( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* ts, size_t tslen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_range_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* start_key, + size_t start_key_len, const char* end_key, size_t end_key_len, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_flush( + rocksdb_t* db, const rocksdb_flushoptions_t* options, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_flush_cf( + rocksdb_t* db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_flush_wal(rocksdb_t* db, + unsigned char sync, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_pause_background_work(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_continue_background_work(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_disable_file_deletions(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_enable_file_deletions(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_verify_checksum(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_verify_file_checksums(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_destroy_db( + const rocksdb_options_t* options, const char* name, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_repair_db( + const rocksdb_options_t* options, const char* name, char** errptr); + +/* WriteBatch */ + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_clear( + rocksdb_writebatch_t* b); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put(rocksdb_writebatch_t* b, + const char* key, + size_t klen, + const char* val, + size_t vlen); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete( + rocksdb_writebatch_t* b, const char* key, size_t klen); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_log_data( + rocksdb_writebatch_t* b, const char* blob, size_t len); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_set_save_point( + rocksdb_writebatch_t* b); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_rollback_to_save_point( + rocksdb_writebatch_t* b, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_pop_save_point( + rocksdb_writebatch_t* b, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_verify_checksum( + rocksdb_writebatch_t* b, char** errptr); + +/* Transaction */ + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put( + rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val, + size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge( + rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val, + size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete( + rocksdb_transaction_t* txn, const char* key, size_t klen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_commit( + rocksdb_transaction_t* txn, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback( + rocksdb_transaction_t* txn, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_log_data( + rocksdb_transaction_t* txn, const char* blob, size_t len); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_set_savepoint( + rocksdb_transaction_t* txn); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback_to_savepoint( + rocksdb_transaction_t* txn, char** errptr); + +/* TransactionDB simple */ + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_put( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + const char* key, size_t klen, const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_put_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_write( + rocksdb_transactiondb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + const char* key, size_t klen, const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, + const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_delete( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + const char* key, size_t klen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_delete_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_wal( + rocksdb_transactiondb_t* txn_db, unsigned char sync, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, char** errptr); diff --git a/c_api_gen/c_generated_transaction_subset.cc.inc b/c_api_gen/c_generated_transaction_subset.cc.inc new file mode 100644 index 0000000000..f981bb543a --- /dev/null +++ b/c_api_gen/c_generated_transaction_subset.cc.inc @@ -0,0 +1,77 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'Transaction' +// --header-out +// c_api_gen/c_generated_transaction_subset.h.inc +// --source-out +// c_api_gen/c_generated_transaction_subset.cc.inc + +/* Transaction */ + +void rocksdb_transaction_put(rocksdb_transaction_t* txn, const char* key, + size_t klen, const char* val, size_t vlen, + char** errptr) { + SaveError(errptr, txn->rep->Put(Slice(key, klen), Slice(val, vlen))); +} + +void rocksdb_transaction_put_cf(rocksdb_transaction_t* txn, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, + size_t vlen, char** errptr) { + SaveError(errptr, txn->rep->Put(column_family->rep, Slice(key, klen), + Slice(val, vlen))); +} + +void rocksdb_transaction_merge(rocksdb_transaction_t* txn, const char* key, + size_t klen, const char* val, size_t vlen, + char** errptr) { + SaveError(errptr, txn->rep->Merge(Slice(key, klen), Slice(val, vlen))); +} + +void rocksdb_transaction_merge_cf(rocksdb_transaction_t* txn, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, + size_t vlen, char** errptr) { + SaveError(errptr, txn->rep->Merge(column_family->rep, Slice(key, klen), + Slice(val, vlen))); +} + +void rocksdb_transaction_delete(rocksdb_transaction_t* txn, const char* key, + size_t klen, char** errptr) { + SaveError(errptr, txn->rep->Delete(Slice(key, klen))); +} + +void rocksdb_transaction_delete_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, char** errptr) { + SaveError(errptr, txn->rep->Delete(column_family->rep, Slice(key, klen))); +} + +void rocksdb_transaction_commit(rocksdb_transaction_t* txn, char** errptr) { + SaveError(errptr, txn->rep->Commit()); +} + +void rocksdb_transaction_rollback(rocksdb_transaction_t* txn, char** errptr) { + SaveError(errptr, txn->rep->Rollback()); +} + +void rocksdb_transaction_put_log_data(rocksdb_transaction_t* txn, + const char* blob, size_t len) { + txn->rep->PutLogData(Slice(blob, len)); +} + +void rocksdb_transaction_set_savepoint(rocksdb_transaction_t* txn) { + txn->rep->SetSavePoint(); +} + +void rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t* txn, + char** errptr) { + SaveError(errptr, txn->rep->RollbackToSavePoint()); +} diff --git a/c_api_gen/c_generated_transaction_subset.h.inc b/c_api_gen/c_generated_transaction_subset.h.inc new file mode 100644 index 0000000000..3d005ed6bc --- /dev/null +++ b/c_api_gen/c_generated_transaction_subset.h.inc @@ -0,0 +1,54 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'Transaction' +// --header-out +// c_api_gen/c_generated_transaction_subset.h.inc +// --source-out +// c_api_gen/c_generated_transaction_subset.cc.inc + +/* Transaction */ + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put( + rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val, + size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge( + rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val, + size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete( + rocksdb_transaction_t* txn, const char* key, size_t klen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_commit( + rocksdb_transaction_t* txn, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback( + rocksdb_transaction_t* txn, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_log_data( + rocksdb_transaction_t* txn, const char* blob, size_t len); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_set_savepoint( + rocksdb_transaction_t* txn); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback_to_savepoint( + rocksdb_transaction_t* txn, char** errptr); diff --git a/c_api_gen/c_generated_transactiondb_subset.cc.inc b/c_api_gen/c_generated_transactiondb_subset.cc.inc new file mode 100644 index 0000000000..ee427fec56 --- /dev/null +++ b/c_api_gen/c_generated_transactiondb_subset.cc.inc @@ -0,0 +1,87 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'TransactionDB simple' +// --header-out +// c_api_gen/c_generated_transactiondb_subset.h.inc +// --source-out +// c_api_gen/c_generated_transactiondb_subset.cc.inc + +/* TransactionDB simple */ + +void rocksdb_transactiondb_put(rocksdb_transactiondb_t* txn_db, + const rocksdb_writeoptions_t* options, + const char* key, size_t klen, const char* val, + size_t vlen, char** errptr) { + SaveError(errptr, + txn_db->rep->Put(options->rep, Slice(key, klen), Slice(val, vlen))); +} + +void rocksdb_transactiondb_put_cf(rocksdb_transactiondb_t* txn_db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, + const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, txn_db->rep->Put(options->rep, column_family->rep, + Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_transactiondb_write(rocksdb_transactiondb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr) { + SaveError(errptr, db->rep->Write(options->rep, &batch->rep)); +} + +void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db, + const rocksdb_writeoptions_t* options, + const char* key, size_t klen, const char* val, + size_t vlen, char** errptr) { + SaveError(errptr, txn_db->rep->Merge(options->rep, Slice(key, klen), + Slice(val, vlen))); +} + +void rocksdb_transactiondb_merge_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, + const char* val, size_t vlen, char** errptr) { + SaveError(errptr, txn_db->rep->Merge(options->rep, column_family->rep, + Slice(key, klen), Slice(val, vlen))); +} + +void rocksdb_transactiondb_delete(rocksdb_transactiondb_t* txn_db, + const rocksdb_writeoptions_t* options, + const char* key, size_t klen, char** errptr) { + SaveError(errptr, txn_db->rep->Delete(options->rep, Slice(key, klen))); +} + +void rocksdb_transactiondb_delete_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr) { + SaveError(errptr, txn_db->rep->Delete(options->rep, column_family->rep, + Slice(key, keylen))); +} + +void rocksdb_transactiondb_flush_wal(rocksdb_transactiondb_t* txn_db, + unsigned char sync, char** errptr) { + SaveError(errptr, txn_db->rep->FlushWAL(sync)); +} + +void rocksdb_transactiondb_flush(rocksdb_transactiondb_t* txn_db, + const rocksdb_flushoptions_t* options, + char** errptr) { + SaveError(errptr, txn_db->rep->Flush(options->rep)); +} + +void rocksdb_transactiondb_flush_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, char** errptr) { + SaveError(errptr, txn_db->rep->Flush(options->rep, column_family->rep)); +} diff --git a/c_api_gen/c_generated_transactiondb_subset.h.inc b/c_api_gen/c_generated_transactiondb_subset.h.inc new file mode 100644 index 0000000000..bd221bd973 --- /dev/null +++ b/c_api_gen/c_generated_transactiondb_subset.h.inc @@ -0,0 +1,58 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'TransactionDB simple' +// --header-out +// c_api_gen/c_generated_transactiondb_subset.h.inc +// --source-out +// c_api_gen/c_generated_transactiondb_subset.cc.inc + +/* TransactionDB simple */ + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_put( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + const char* key, size_t klen, const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_put_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_write( + rocksdb_transactiondb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + const char* key, size_t klen, const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, + const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_delete( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + const char* key, size_t klen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_delete_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_wal( + rocksdb_transactiondb_t* txn_db, unsigned char sync, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, char** errptr); diff --git a/c_api_gen/c_generated_writebatch_subset.cc.inc b/c_api_gen/c_generated_writebatch_subset.cc.inc new file mode 100644 index 0000000000..61c637d0fd --- /dev/null +++ b/c_api_gen/c_generated_writebatch_subset.cc.inc @@ -0,0 +1,58 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'WriteBatch' +// --header-out +// c_api_gen/c_generated_writebatch_subset.h.inc +// --source-out +// c_api_gen/c_generated_writebatch_subset.cc.inc + +/* WriteBatch */ + +void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) { b->rep.Clear(); } + +void rocksdb_writebatch_put(rocksdb_writebatch_t* b, const char* key, + size_t klen, const char* val, size_t vlen) { + b->rep.Put(Slice(key, klen), Slice(val, vlen)); +} + +void rocksdb_writebatch_put_cf(rocksdb_writebatch_t* b, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, + size_t vlen) { + b->rep.Put(column_family->rep, Slice(key, klen), Slice(val, vlen)); +} + +void rocksdb_writebatch_delete(rocksdb_writebatch_t* b, const char* key, + size_t klen) { + b->rep.Delete(Slice(key, klen)); +} + +void rocksdb_writebatch_put_log_data(rocksdb_writebatch_t* b, const char* blob, + size_t len) { + b->rep.PutLogData(Slice(blob, len)); +} + +void rocksdb_writebatch_set_save_point(rocksdb_writebatch_t* b) { + b->rep.SetSavePoint(); +} + +void rocksdb_writebatch_rollback_to_save_point(rocksdb_writebatch_t* b, + char** errptr) { + SaveError(errptr, b->rep.RollbackToSavePoint()); +} + +void rocksdb_writebatch_pop_save_point(rocksdb_writebatch_t* b, char** errptr) { + SaveError(errptr, b->rep.PopSavePoint()); +} + +void rocksdb_writebatch_verify_checksum(rocksdb_writebatch_t* b, + char** errptr) { + SaveError(errptr, b->rep.VerifyChecksum()); +} diff --git a/c_api_gen/c_generated_writebatch_subset.h.inc b/c_api_gen/c_generated_writebatch_subset.h.inc new file mode 100644 index 0000000000..75166a8233 --- /dev/null +++ b/c_api_gen/c_generated_writebatch_subset.h.inc @@ -0,0 +1,47 @@ +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'WriteBatch' +// --header-out +// c_api_gen/c_generated_writebatch_subset.h.inc +// --source-out +// c_api_gen/c_generated_writebatch_subset.cc.inc + +/* WriteBatch */ + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_clear( + rocksdb_writebatch_t* b); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put(rocksdb_writebatch_t* b, + const char* key, + size_t klen, + const char* val, + size_t vlen); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete( + rocksdb_writebatch_t* b, const char* key, size_t klen); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_log_data( + rocksdb_writebatch_t* b, const char* blob, size_t len); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_set_save_point( + rocksdb_writebatch_t* b); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_rollback_to_save_point( + rocksdb_writebatch_t* b, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_pop_save_point( + rocksdb_writebatch_t* b, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_verify_checksum( + rocksdb_writebatch_t* b, char** errptr); diff --git a/claude_md/add_option.md b/claude_md/add_option.md index 6c48b949cd..d92058a6f0 100644 --- a/claude_md/add_option.md +++ b/claude_md/add_option.md @@ -421,6 +421,30 @@ Example reference: commit `429b36c22d76403d275dd0e6877b08d4cea2bc90` (block_alig If an option already exists but needs C API support: +**First decide whether the option is auto-managed.** + +Many simple option fields are no longer maintained by hand in +`include/rocksdb/c.h` and `db/c.cc`. Before adding a manual wrapper: + +- Check whether the option belongs to a family handled by + `tools/c_api_gen/auto_simple_bindings.py`. +- If it is a simple scalar/enum/string field in an auto-managed family, run + `python3 tools/c_api_gen/regen_all.py` and let the generator add the C API. +- After regenerating, run + `python3 tools/c_api_gen/verify_generated_up_to_date.py` to confirm the + checked-in generated fragments stay stable. +- Do not edit generated `.inc` files under `c_api_gen/` by hand. +- If the new field is not ready for C API support yet, add an entry to + `tools/c_api_gen/auto_simple_bindings_blocklist.json` with + `"policy": "deferred"` and a concrete reason so the build stays intentional + rather than silently drifting. +- If the field needs custom ownership, callback, vector, or nested-struct + marshalling, keep it manual or move it into `tools/c_api_gen/spec.json` + depending on the API shape. + +If the option is not auto-managed, or the C API really is a custom/manual case, +the traditional hand-written pattern still applies: + **File: `db/c.cc`** ```cpp @@ -509,4 +533,3 @@ Common option types used in serialization: - [ ] unreleased_history markdown file - [ ] Java API (for BlockBasedTableOptions) - [ ] C API (if needed) - diff --git a/claude_md/add_public_api.md b/claude_md/add_public_api.md index 684b89faeb..d897b1ec28 100644 --- a/claude_md/add_public_api.md +++ b/claude_md/add_public_api.md @@ -168,9 +168,18 @@ Status YourNewAPI(const YourAPIOptions& /*options*/, ### Step 5: Add C API Bindings -**Header:** `include/rocksdb/c.h` +> **Important:** `include/rocksdb/c.h` and `db/c.cc` are `@generated` and must +> NOT be edited by hand — your changes would be overwritten on the next +> regeneration. Choose the right path first (see "Before writing C API code by +> hand" below). For hand-written (manual) wrappers, edit the source templates +> `tools/c_api_gen/c_base.h` (declarations) and `tools/c_api_gen/c_base.cc` +> (implementations), then run `python3 tools/c_api_gen/regen_all.py` to produce +> `c.h` / `c.cc`. The snippets below show the *declaration* and *implementation* +> you would add to those templates. -\`\`\`c +**Header (declaration → `tools/c_api_gen/c_base.h`):** + +```c // Basic version extern ROCKSDB_LIBRARY_API void rocksdb_your_new_api( rocksdb_t* db, @@ -191,7 +200,7 @@ extern ROCKSDB_LIBRARY_API void rocksdb_your_new_api_opt( char** errptr); \`\`\` -**Implementation:** `db/c.cc` +**Implementation (→ `tools/c_api_gen/c_base.cc`):** \`\`\`cpp void rocksdb_your_new_api(rocksdb_t* db, const char* start_key, @@ -217,6 +226,38 @@ void rocksdb_your_new_api_cf(rocksdb_t* db, } \`\`\` +**Before writing C API code by hand, choose the right path:** + +- **Auto-managed simple struct fields:** If you added a new field to a managed + public struct such as `ReadOptions`, selected option structs, or managed + metadata structs, first check `tools/c_api_gen/auto_simple_bindings.py`. + Simple scalar/enum/string fields should be regenerated with + `python3 tools/c_api_gen/regen_all.py` rather than hand-editing + `include/rocksdb/c.h` / `db/c.cc`. + After regenerating, run + `python3 tools/c_api_gen/verify_generated_up_to_date.py` to confirm the + checked-in generated fragments are stable. +- **Spec-driven wrappers:** If the API is still mechanically generated but needs + an explicit C shape, naming, or `Status`/`char** errptr` policy, add it to + `tools/c_api_gen/spec.json`. +- **Fully manual wrappers:** If the API uses callbacks, ownership transfer, + vectors/maps, open flows, or otherwise irregular marshalling, keep the C API + hand-written. + +**Temporary deferral for auto-managed families:** + +If a new field lands in an auto-managed family but the C API shape is not ready +yet, add a checked-in entry to +`tools/c_api_gen/auto_simple_bindings_blocklist.json` with: + +- `policy: "manual"` when the field is intentionally outside simple auto-gen +- `policy: "deferred"` when the field should be revisited later +- a concrete `reason` +- `tracking_issue` when available + +If a field in an auto-managed family is not supported by the generator and is +not covered by the blocklist, regeneration should fail. That is intentional. + **If you have options, also add:** \`\`\`cpp @@ -482,8 +523,8 @@ public class YourAPIOptionsTest { | StackableDB | `include/rocksdb/utilities/stackable_db.h` | ✓ | | Secondary DB | `db/db_impl/db_impl_secondary.h` | If not supported | | Compacted DB | `db/db_impl/compacted_db_impl.h` | If not supported | -| C API Header | `include/rocksdb/c.h` | ✓ | -| C API Implementation | `db/c.cc` | ✓ | +| C API Header (manual wrappers) | `tools/c_api_gen/c_base.h` → regen → `include/rocksdb/c.h` (`@generated`) | ✓ | +| C API Implementation (manual wrappers) | `tools/c_api_gen/c_base.cc` → regen → `db/c.cc` (`@generated`) | ✓ | | Java API | `java/src/main/java/org/rocksdb/RocksDB.java` | ✓ | | Java Options | `java/src/main/java/org/rocksdb/YourAPIOptions.java` | If needed | | JNI Implementation | `java/rocksjni/rocksjni.cc` | ✓ | diff --git a/db/c.cc b/db/c.cc index 4a363a7dae..29e6799f73 100644 --- a/db/c.cc +++ b/db/c.cc @@ -1,15 +1,19 @@ -// Copyright (c) 2011-present, Facebook, Inc. All rights reserved. +// 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). -// -// 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. +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/regen_all.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Edit tools/c_api_gen/c_base.cc or the inputs under tools/c_api_gen/, +// then rerun: python3 tools/c_api_gen/regen_all.py +// ----------------------------------------------------------------------------- #include "rocksdb/c.h" #include +#include #include #include #include @@ -36,17 +40,21 @@ #include "rocksdb/statistics.h" #include "rocksdb/status.h" #include "rocksdb/table.h" +#include "rocksdb/trace_reader_writer.h" #include "rocksdb/universal_compaction.h" +#include "rocksdb/user_defined_index.h" #include "rocksdb/utilities/backup_engine.h" #include "rocksdb/utilities/checkpoint.h" #include "rocksdb/utilities/db_ttl.h" #include "rocksdb/utilities/memory_util.h" #include "rocksdb/utilities/optimistic_transaction_db.h" #include "rocksdb/utilities/options_util.h" +#include "rocksdb/utilities/replayer.h" #include "rocksdb/utilities/table_properties_collectors.h" #include "rocksdb/utilities/transaction.h" #include "rocksdb/utilities/transaction_db.h" #include "rocksdb/utilities/write_batch_with_index.h" +#include "rocksdb/wal_filter.h" #include "rocksdb/write_batch.h" #include "rocksdb/write_buffer_manager.h" #include "util/stderr_logger.h" @@ -58,7 +66,11 @@ using ROCKSDB_NAMESPACE::BackupEngineOptions; using ROCKSDB_NAMESPACE::BackupID; using ROCKSDB_NAMESPACE::BackupInfo; using ROCKSDB_NAMESPACE::BatchResult; +using ROCKSDB_NAMESPACE::BlobFileAdditionInfo; +using ROCKSDB_NAMESPACE::BlobFileGarbageInfo; using ROCKSDB_NAMESPACE::BlockBasedTableOptions; +using ROCKSDB_NAMESPACE::BlockCacheTraceOptions; +using ROCKSDB_NAMESPACE::BlockCacheTraceWriterOptions; using ROCKSDB_NAMESPACE::BottommostLevelCompaction; using ROCKSDB_NAMESPACE::BytewiseComparator; using ROCKSDB_NAMESPACE::Cache; @@ -67,9 +79,12 @@ using ROCKSDB_NAMESPACE::ColumnFamilyDescriptor; using ROCKSDB_NAMESPACE::ColumnFamilyHandle; using ROCKSDB_NAMESPACE::ColumnFamilyMetaData; using ROCKSDB_NAMESPACE::ColumnFamilyOptions; +using ROCKSDB_NAMESPACE::CompactionFileInfo; using ROCKSDB_NAMESPACE::CompactionFilter; using ROCKSDB_NAMESPACE::CompactionFilterFactory; using ROCKSDB_NAMESPACE::CompactionJobInfo; +using ROCKSDB_NAMESPACE::CompactionJobStats; +using ROCKSDB_NAMESPACE::CompactionOptions; using ROCKSDB_NAMESPACE::CompactionOptionsFIFO; using ROCKSDB_NAMESPACE::CompactionReason; using ROCKSDB_NAMESPACE::CompactionService; @@ -77,10 +92,12 @@ using ROCKSDB_NAMESPACE::CompactionServiceJobInfo; using ROCKSDB_NAMESPACE::CompactionServiceJobStatus; using ROCKSDB_NAMESPACE::CompactionServiceOptionsOverride; using ROCKSDB_NAMESPACE::CompactionServiceScheduleResponse; +using ROCKSDB_NAMESPACE::CompactionStyle; using ROCKSDB_NAMESPACE::CompactRangeOptions; using ROCKSDB_NAMESPACE::Comparator; using ROCKSDB_NAMESPACE::CompressionType; using ROCKSDB_NAMESPACE::ConfigOptions; +using ROCKSDB_NAMESPACE::CreateBackupOptions; using ROCKSDB_NAMESPACE::CuckooTableOptions; using ROCKSDB_NAMESPACE::DB; using ROCKSDB_NAMESPACE::DBOptions; @@ -92,9 +109,12 @@ using ROCKSDB_NAMESPACE::ExportImportFilesMetaData; using ROCKSDB_NAMESPACE::ExternalFileIngestionInfo; using ROCKSDB_NAMESPACE::FileChecksumGenFactory; using ROCKSDB_NAMESPACE::FileLock; +using ROCKSDB_NAMESPACE::FileType; using ROCKSDB_NAMESPACE::FilterPolicy; using ROCKSDB_NAMESPACE::FlushJobInfo; using ROCKSDB_NAMESPACE::FlushOptions; +using ROCKSDB_NAMESPACE::FlushWALOptions; +using ROCKSDB_NAMESPACE::GetColumnFamilyMetaDataOptions; using ROCKSDB_NAMESPACE::GetFileChecksumGenCrc32cFactory; using ROCKSDB_NAMESPACE::HistogramData; using ROCKSDB_NAMESPACE::HyperClockCacheOptions; @@ -104,20 +124,29 @@ using ROCKSDB_NAMESPACE::IngestExternalFileOptions; using ROCKSDB_NAMESPACE::Iterator; using ROCKSDB_NAMESPACE::LevelMetaData; using ROCKSDB_NAMESPACE::LiveFileMetaData; +using ROCKSDB_NAMESPACE::LiveFilesStorageInfoOptions; +using ROCKSDB_NAMESPACE::LiveFileStorageInfo; using ROCKSDB_NAMESPACE::Logger; using ROCKSDB_NAMESPACE::LRUCacheOptions; +using ROCKSDB_NAMESPACE::MakeSharedOccLockBuckets; +using ROCKSDB_NAMESPACE::MaybeExcludeBackupFile; using ROCKSDB_NAMESPACE::MemoryAllocator; using ROCKSDB_NAMESPACE::MemoryUtil; using ROCKSDB_NAMESPACE::MemTableInfo; using ROCKSDB_NAMESPACE::MergeOperator; +using ROCKSDB_NAMESPACE::NewBlockCacheTraceWriter; using ROCKSDB_NAMESPACE::NewBloomFilterPolicy; using ROCKSDB_NAMESPACE::NewCompactOnDeletionCollectorFactory; +using ROCKSDB_NAMESPACE::NewFileTraceReader; +using ROCKSDB_NAMESPACE::NewFileTraceWriter; using ROCKSDB_NAMESPACE::NewGenericRateLimiter; using ROCKSDB_NAMESPACE::NewLRUCache; using ROCKSDB_NAMESPACE::NewRibbonFilterPolicy; using ROCKSDB_NAMESPACE::NewSstPartitionerFixedPrefixFactory; +using ROCKSDB_NAMESPACE::OccLockBuckets; using ROCKSDB_NAMESPACE::OpenAndCompactOptions; using ROCKSDB_NAMESPACE::OptimisticTransactionDB; +using ROCKSDB_NAMESPACE::OptimisticTransactionDBOptions; using ROCKSDB_NAMESPACE::OptimisticTransactionOptions; using ROCKSDB_NAMESPACE::Options; using ROCKSDB_NAMESPACE::PerfContext; @@ -128,8 +157,11 @@ using ROCKSDB_NAMESPACE::RandomAccessFile; using ROCKSDB_NAMESPACE::Range; using ROCKSDB_NAMESPACE::RateLimiter; using ROCKSDB_NAMESPACE::ReadOptions; +using ROCKSDB_NAMESPACE::Replayer; +using ROCKSDB_NAMESPACE::ReplayOptions; using ROCKSDB_NAMESPACE::RestoreOptions; using ROCKSDB_NAMESPACE::SequentialFile; +using ROCKSDB_NAMESPACE::SizeApproximationOptions; using ROCKSDB_NAMESPACE::Slice; using ROCKSDB_NAMESPACE::SliceParts; using ROCKSDB_NAMESPACE::SliceTransform; @@ -142,14 +174,22 @@ using ROCKSDB_NAMESPACE::Status; using ROCKSDB_NAMESPACE::StderrLogger; using ROCKSDB_NAMESPACE::SubcompactionJobInfo; using ROCKSDB_NAMESPACE::TableFactory; +using ROCKSDB_NAMESPACE::TableProperties; +using ROCKSDB_NAMESPACE::TablePropertiesCollection; using ROCKSDB_NAMESPACE::TablePropertiesCollectorFactory; +using ROCKSDB_NAMESPACE::TraceOptions; +using ROCKSDB_NAMESPACE::TraceReader; using ROCKSDB_NAMESPACE::Transaction; using ROCKSDB_NAMESPACE::TransactionDB; using ROCKSDB_NAMESPACE::TransactionDBOptions; using ROCKSDB_NAMESPACE::TransactionLogIterator; using ROCKSDB_NAMESPACE::TransactionOptions; -using ROCKSDB_NAMESPACE::TxnDBWritePolicy; +using ROCKSDB_NAMESPACE::UserCollectedProperties; +using ROCKSDB_NAMESPACE::UserDefinedIndexFactory; +using ROCKSDB_NAMESPACE::VectorWalPtr; using ROCKSDB_NAMESPACE::WaitForCompactOptions; +using ROCKSDB_NAMESPACE::WalFile; +using ROCKSDB_NAMESPACE::WalFilter; using ROCKSDB_NAMESPACE::WALRecoveryMode; using ROCKSDB_NAMESPACE::WritableFile; using ROCKSDB_NAMESPACE::WriteBatch; @@ -162,6 +202,51 @@ using ROCKSDB_NAMESPACE::WriteStallInfo; using std::unordered_set; using std::vector; +template +// Returns iterator to the element at position `pos`, or cend() if out of +// bounds. NOTE: O(n) per call due to std::advance on non-random-access +// iterators (std::map). Callers iterating the full map are O(n^2). +static typename MapType::const_iterator GetMapEntryAt(const MapType& map, + size_t pos) { + if (pos >= map.size()) { + return map.cend(); + } + auto it = map.cbegin(); + std::advance(it, pos); + return it; +} + +static std::unique_ptr BuildRanges(int num_ranges, + const char* const* range_start_key, + const size_t* range_start_key_len, + const char* const* range_limit_key, + const size_t* range_limit_key_len) { + std::unique_ptr ranges(new Range[num_ranges]); + for (int i = 0; i < num_ranges; ++i) { + ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]); + ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]); + } + return ranges; +} + +struct rocksdb_wal_file_t { + std::string path_name; + uint64_t log_number = 0; + int type = 0; + uint64_t start_sequence = 0; + uint64_t size_file_bytes = 0; +}; + +static rocksdb_wal_file_t CaptureWalFile(const WalFile& wal_file) { + rocksdb_wal_file_t result; + result.path_name = wal_file.PathName(); + result.log_number = wal_file.LogNumber(); + result.type = static_cast(wal_file.Type()); + result.start_sequence = wal_file.StartSequence(); + result.size_file_bytes = wal_file.SizeFileBytes(); + return result; +} + extern "C" { struct rocksdb_t { @@ -176,6 +261,14 @@ struct rocksdb_backup_engine_t { struct rocksdb_backup_engine_info_t { std::vector rep; }; +struct rocksdb_create_backup_options_t { + CreateBackupOptions rep; + void* progress_state = nullptr; + rocksdb_create_backup_options_progress_cb progress_callback = nullptr; + void* exclude_files_state = nullptr; + rocksdb_create_backup_options_exclude_files_cb exclude_files_callback = + nullptr; +}; struct rocksdb_restore_options_t { RestoreOptions rep; }; @@ -188,12 +281,123 @@ struct rocksdb_writebatch_t { struct rocksdb_writebatch_wi_t { WriteBatchWithIndex* rep; }; +struct rocksdb_table_properties_t { + TableProperties rep; +}; +struct rocksdb_compaction_job_stats_t { + CompactionJobStats rep; +}; +struct rocksdb_compaction_file_info_t { + CompactionFileInfo rep; +}; +struct rocksdb_blob_file_addition_info_t { + BlobFileAdditionInfo rep; +}; +struct rocksdb_blob_file_garbage_info_t { + BlobFileGarbageInfo rep; +}; +struct rocksdb_walfilter_t : public WalFilter { + void* state_ = nullptr; + void (*destructor_)(void*) = nullptr; + rocksdb_walfilter_column_family_log_number_map_cb + column_family_log_number_map_ = nullptr; + rocksdb_walfilter_log_record_found_cb log_record_found_ = nullptr; + const char* (*name_)(void*) = nullptr; + + rocksdb_walfilter_t() = default; + rocksdb_walfilter_t(const rocksdb_walfilter_t&) = delete; + rocksdb_walfilter_t& operator=(const rocksdb_walfilter_t&) = delete; + rocksdb_walfilter_t(rocksdb_walfilter_t&&) = delete; + rocksdb_walfilter_t& operator=(rocksdb_walfilter_t&&) = delete; + ~rocksdb_walfilter_t() override { + if (destructor_) { + (*destructor_)(state_); + } + } + + void ColumnFamilyLogNumberMap( + const std::map& cf_lognumber_map, + const std::map& cf_name_id_map) override { + if (column_family_log_number_map_ == nullptr) { + return; + } + + std::vector cf_ids; + std::vector log_numbers; + cf_ids.reserve(cf_lognumber_map.size()); + log_numbers.reserve(cf_lognumber_map.size()); + for (const auto& entry : cf_lognumber_map) { + cf_ids.push_back(entry.first); + log_numbers.push_back(entry.second); + } + + std::vector cf_names; + std::vector cf_name_lengths; + std::vector cf_name_ids; + cf_names.reserve(cf_name_id_map.size()); + cf_name_lengths.reserve(cf_name_id_map.size()); + cf_name_ids.reserve(cf_name_id_map.size()); + for (const auto& entry : cf_name_id_map) { + cf_names.push_back(entry.first.data()); + cf_name_lengths.push_back(entry.first.size()); + cf_name_ids.push_back(entry.second); + } + + column_family_log_number_map_(state_, cf_ids.data(), log_numbers.data(), + cf_ids.size(), cf_names.data(), + cf_name_lengths.data(), cf_name_ids.data(), + cf_name_ids.size()); + } + + WalProcessingOption LogRecordFound(unsigned long long log_number, + const std::string& log_file_name, + const WriteBatch& batch, + WriteBatch* new_batch, + bool* batch_changed) override { + if (log_record_found_ == nullptr) { + return WalProcessingOption::kContinueProcessing; + } + + // Avoid deep copy: rocksdb_writebatch_t has WriteBatch as its only member + const rocksdb_writebatch_t* c_batch = + reinterpret_cast(&batch); + rocksdb_writebatch_t c_new_batch = {WriteBatch()}; + unsigned char c_batch_changed = 0; + int option = log_record_found_(state_, log_number, log_file_name.data(), + log_file_name.size(), c_batch, &c_new_batch, + &c_batch_changed); + if (c_batch_changed != 0) { + // c_new_batch is a local about to be destroyed; move instead of copying + // the WriteBatch out of it. + *new_batch = std::move(c_new_batch.rep); + } + *batch_changed = c_batch_changed != 0; + + switch (option) { + case rocksdb_wal_filter_continue_processing: + return WalProcessingOption::kContinueProcessing; + case rocksdb_wal_filter_ignore_current_record: + return WalProcessingOption::kIgnoreCurrentRecord; + case rocksdb_wal_filter_stop_replay: + return WalProcessingOption::kStopReplay; + case rocksdb_wal_filter_corrupted_record: + return WalProcessingOption::kCorruptedRecord; + default: + return WalProcessingOption::kCorruptedRecord; + } + } + + const char* Name() const override { return name_ ? (*name_)(state_) : ""; } +}; struct rocksdb_snapshot_t { const Snapshot* rep; }; struct rocksdb_flushoptions_t { FlushOptions rep; }; +struct rocksdb_flushwaloptions_t { + FlushWALOptions rep; +}; struct rocksdb_fifo_compaction_options_t { CompactionOptionsFIFO rep; }; @@ -204,19 +408,64 @@ struct rocksdb_readoptions_t { Slice lower_bound; Slice timestamp; Slice iter_start_ts; + std::unique_ptr request_id; + void* table_filter_state = nullptr; + void (*table_filter_destructor)(void*) = nullptr; + rocksdb_readoptions_table_filter_cb table_filter_callback = nullptr; + std::shared_ptr table_index_factory; + + ~rocksdb_readoptions_t() { ClearTableFilter(); } + + void ClearTableFilter() { + rep.table_filter = {}; + if (table_filter_destructor != nullptr) { + (*table_filter_destructor)(table_filter_state); + } + table_filter_state = nullptr; + table_filter_destructor = nullptr; + table_filter_callback = nullptr; + } + + void SetTableFilter(void* state, void (*destructor)(void*), + rocksdb_readoptions_table_filter_cb callback) { + ClearTableFilter(); + table_filter_state = state; + table_filter_destructor = destructor; + table_filter_callback = callback; + if (callback != nullptr) { + auto cb = table_filter_callback; + auto filter_state = table_filter_state; + rep.table_filter = [cb, filter_state](const TableProperties& props) { + return cb(filter_state, + reinterpret_cast( + &props)) != 0; + }; + } + } }; + struct rocksdb_writeoptions_t { WriteOptions rep; }; struct rocksdb_options_t { Options rep; }; +struct rocksdb_compaction_options_t { + CompactionOptions rep; +}; struct rocksdb_compactoptions_t { CompactRangeOptions rep; Slice full_history_ts_low; }; struct rocksdb_block_based_table_options_t { BlockBasedTableOptions rep; + std::shared_ptr user_defined_index_factory; +}; +struct rocksdb_block_cache_trace_options_t { + BlockCacheTraceOptions rep; +}; +struct rocksdb_block_cache_trace_writer_options_t { + BlockCacheTraceWriterOptions rep; }; struct rocksdb_cuckoo_table_options_t { CuckooTableOptions rep; @@ -236,6 +485,10 @@ struct rocksdb_wal_iterator_t { struct rocksdb_wal_readoptions_t { TransactionLogIterator::ReadOptions rep; }; + +struct rocksdb_wal_files_t { + std::vector rep; +}; struct rocksdb_filelock_t { FileLock* rep; }; @@ -282,6 +535,13 @@ struct rocksdb_column_family_handle_t { struct rocksdb_column_family_metadata_t { ColumnFamilyMetaData rep; }; +struct rocksdb_column_family_metadata_options_t { + GetColumnFamilyMetaDataOptions rep; + std::string start_key; + std::string end_key; + bool has_start_key = false; + bool has_end_key = false; +}; struct rocksdb_export_import_files_metadata_t { ExportImportFilesMetaData* rep; }; @@ -296,10 +556,32 @@ struct rocksdb_sst_file_metadata_t { }; struct rocksdb_envoptions_t { EnvOptions rep; + std::shared_ptr rate_limiter; }; struct rocksdb_ingestexternalfileoptions_t { IngestExternalFileOptions rep; }; +struct rocksdb_trace_options_t { + TraceOptions rep; +}; +struct rocksdb_trace_reader_t { + std::unique_ptr rep; +}; +struct rocksdb_replay_options_t { + ReplayOptions rep; +}; +struct rocksdb_replayer_t { + std::unique_ptr rep; +}; +struct rocksdb_size_approximation_options_t { + SizeApproximationOptions rep; +}; +struct rocksdb_livefiles_storage_info_options_t { + LiveFilesStorageInfoOptions rep; +}; +struct rocksdb_livefiles_storage_info_t { + std::vector rep; +}; struct rocksdb_sstfilewriter_t { SstFileWriter* rep; }; @@ -333,6 +615,12 @@ struct rocksdb_checkpoint_t { struct rocksdb_optimistictransactiondb_t { OptimisticTransactionDB* rep; }; +struct rocksdb_optimistictransactiondb_options_t { + OptimisticTransactionDBOptions rep; +}; +struct rocksdb_optimistictransactiondb_lock_buckets_t { + std::shared_ptr rep; +}; struct rocksdb_optimistictransaction_options_t { OptimisticTransactionOptions rep; }; @@ -378,6 +666,71 @@ struct rocksdb_compactionservice_scheduleresponse_t { struct rocksdb_compactionservice_jobinfo_t { CompactionServiceJobInfo rep; }; +// Layout assertions: these structs must be reinterpret_cast-compatible +// with their rep field (single-member struct, standard-layout). +static_assert(sizeof(rocksdb_writebatch_t) == sizeof(WriteBatch), + "Layout mismatch: rocksdb_writebatch_t vs WriteBatch"); +static_assert(offsetof(rocksdb_writebatch_t, rep) == 0, + "rep must be at offset 0 in rocksdb_writebatch_t"); +static_assert(sizeof(rocksdb_table_properties_t) == sizeof(TableProperties), + "Layout mismatch: rocksdb_table_properties_t vs TableProperties"); +static_assert(offsetof(rocksdb_table_properties_t, rep) == 0, + "rep must be at offset 0 in rocksdb_table_properties_t"); +static_assert(sizeof(rocksdb_blob_file_addition_info_t) == + sizeof(BlobFileAdditionInfo), + "Layout mismatch: rocksdb_blob_file_addition_info_t vs " + "BlobFileAdditionInfo"); +static_assert(offsetof(rocksdb_blob_file_addition_info_t, rep) == 0, + "rep must be at offset 0 in rocksdb_blob_file_addition_info_t"); +static_assert( + sizeof(rocksdb_blob_file_garbage_info_t) == sizeof(BlobFileGarbageInfo), + "Layout mismatch: rocksdb_blob_file_garbage_info_t vs BlobFileGarbageInfo"); +static_assert(offsetof(rocksdb_blob_file_garbage_info_t, rep) == 0, + "rep must be at offset 0 in rocksdb_blob_file_garbage_info_t"); +static_assert( + sizeof(rocksdb_compaction_file_info_t) == sizeof(CompactionFileInfo), + "Layout mismatch: rocksdb_compaction_file_info_t vs CompactionFileInfo"); +static_assert(offsetof(rocksdb_compaction_file_info_t, rep) == 0, + "rep must be at offset 0 in rocksdb_compaction_file_info_t"); +static_assert( + sizeof(rocksdb_compactionjobinfo_t) == sizeof(CompactionJobInfo), + "Layout mismatch: rocksdb_compactionjobinfo_t vs CompactionJobInfo"); +static_assert(offsetof(rocksdb_compactionjobinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_compactionjobinfo_t"); +static_assert( + sizeof(rocksdb_compaction_job_stats_t) == sizeof(CompactionJobStats), + "Layout mismatch: rocksdb_compaction_job_stats_t vs CompactionJobStats"); +static_assert(offsetof(rocksdb_compaction_job_stats_t, rep) == 0, + "rep must be at offset 0 in rocksdb_compaction_job_stats_t"); +static_assert(sizeof(rocksdb_compactionservice_jobinfo_t) == + sizeof(CompactionServiceJobInfo), + "Layout mismatch: rocksdb_compactionservice_jobinfo_t vs " + "CompactionServiceJobInfo"); +static_assert(offsetof(rocksdb_compactionservice_jobinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_compactionservice_jobinfo_t"); +static_assert(sizeof(rocksdb_externalfileingestioninfo_t) == + sizeof(ExternalFileIngestionInfo), + "Layout mismatch: rocksdb_externalfileingestioninfo_t vs " + "ExternalFileIngestionInfo"); +static_assert(offsetof(rocksdb_externalfileingestioninfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_externalfileingestioninfo_t"); +static_assert(sizeof(rocksdb_flushjobinfo_t) == sizeof(FlushJobInfo), + "Layout mismatch: rocksdb_flushjobinfo_t vs FlushJobInfo"); +static_assert(offsetof(rocksdb_flushjobinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_flushjobinfo_t"); +static_assert(sizeof(rocksdb_memtableinfo_t) == sizeof(MemTableInfo), + "Layout mismatch: rocksdb_memtableinfo_t vs MemTableInfo"); +static_assert(offsetof(rocksdb_memtableinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_memtableinfo_t"); +static_assert( + sizeof(rocksdb_subcompactionjobinfo_t) == sizeof(SubcompactionJobInfo), + "Layout mismatch: rocksdb_subcompactionjobinfo_t vs SubcompactionJobInfo"); +static_assert(offsetof(rocksdb_subcompactionjobinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_subcompactionjobinfo_t"); +static_assert(sizeof(rocksdb_writestallinfo_t) == sizeof(WriteStallInfo), + "Layout mismatch: rocksdb_writestallinfo_t vs WriteStallInfo"); +static_assert(offsetof(rocksdb_writestallinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_writestallinfo_t"); struct rocksdb_compaction_service_options_override_t { CompactionServiceOptionsOverride rep; @@ -631,16 +984,22 @@ struct rocksdb_callback_logger_t : public Logger { char* buf = stack_buf; int len = 0; va_list ap1; - if (!logv_cb_) return; + if (!logv_cb_) { + return; + } va_copy(ap1, ap0); len = vsnprintf(buf, STACK_BUFSZ, fmt, ap0); - if (len <= 0) + if (len <= 0) { goto cleanup; - else if (len >= STACK_BUFSZ) { + } else if (len >= STACK_BUFSZ) { buf = alloc_buf = reinterpret_cast(malloc(len + 1)); - if (!buf) goto cleanup; + if (!buf) { + goto cleanup; + } len = vsnprintf(buf, len + 1, fmt, ap1); - if (len <= 0) goto cleanup; + if (len <= 0) { + goto cleanup; + } } logv_cb_(priv_, unsigned(level), buf, size_t(len)); cleanup: @@ -668,6 +1027,43 @@ static bool SaveError(char** errptr, const Status& s) { return true; } +static const CreateBackupOptions& GetCreateBackupOptions( + const rocksdb_create_backup_options_t* options, + CreateBackupOptions* default_options) { + if (options != nullptr) { + return options->rep; + } + *default_options = CreateBackupOptions(); + return *default_options; +} + +static const FlushWALOptions& GetFlushWALOptions( + const rocksdb_flushwaloptions_t* options, + FlushWALOptions* default_options) { + if (options != nullptr) { + return options->rep; + } + *default_options = FlushWALOptions(); + return *default_options; +} + +static const OptimisticTransactionDBOptions& GetOptimisticTransactionDBOptions( + const rocksdb_optimistictransactiondb_options_t* options, + OptimisticTransactionDBOptions* default_options) { + if (options != nullptr) { + return options->rep; + } + *default_options = OptimisticTransactionDBOptions(); + return *default_options; +} + +static rocksdb_optimistictransactiondb_t* WrapOptimisticTransactionDB( + OptimisticTransactionDB* otxn_db) { + auto* result = new rocksdb_optimistictransactiondb_t; + result->rep = otxn_db; + return result; +} + // Helper function to copy string data to a malloc'd buffer // Works with std::string, Slice, and PinnableSlice through implicit conversion static inline char* CopyString(const Slice& slice) { @@ -676,6 +1072,46 @@ static inline char* CopyString(const Slice& slice) { return result; } +static inline char** CopyStringVector(const std::vector& values) { + if (values.empty()) { + return nullptr; + } + char** result = static_cast(malloc(sizeof(char*) * values.size())); + if (result == nullptr) { + return nullptr; + } + for (size_t i = 0; i < values.size(); ++i) { + result[i] = strdup(values[i].c_str()); + } + return result; +} + +static void SyncColumnFamilyMetadataOptionsRange( + rocksdb_column_family_metadata_options_t* options) { + options->rep.range.start = options->has_start_key + ? options->start_key + : ROCKSDB_NAMESPACE::OptSlice(); + options->rep.range.limit = + options->has_end_key ? options->end_key : ROCKSDB_NAMESPACE::OptSlice(); +} + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4190) // C-linkage function returning C++ type +#endif +static Status LoadUserDefinedIndexFactoryFromString( + const char* value, size_t value_len, + std::shared_ptr* factory) { + ConfigOptions config_options; + config_options.ignore_unknown_options = false; + config_options.ignore_unsupported_options = false; + return UserDefinedIndexFactory::CreateFromString( + config_options, std::string(value, value_len), factory); +} +#ifdef _MSC_VER +#pragma warning(pop) +#endif + const char* rocksdb_compactionservice_jobinfo_t_get_db_name( const rocksdb_compactionservice_jobinfo_t* info, size_t* len) { *len = info->rep.db_name.size(); @@ -1297,6 +1733,53 @@ rocksdb_backup_engine_t* rocksdb_backup_engine_open_opts( return result; } +rocksdb_create_backup_options_t* rocksdb_create_backup_options_create() { + return new rocksdb_create_backup_options_t; +} + +void rocksdb_create_backup_options_destroy( + rocksdb_create_backup_options_t* options) { + delete options; +} + +void rocksdb_create_backup_options_set_progress_callback( + rocksdb_create_backup_options_t* options, void* state, + rocksdb_create_backup_options_progress_cb callback) { + options->progress_state = state; + options->progress_callback = callback; + if (callback == nullptr) { + options->rep.progress_callback = {}; + return; + } + auto progress_cb = callback; + auto progress_state = options->progress_state; + options->rep.progress_callback = [progress_cb, progress_state]() { + progress_cb(progress_state); + }; +} + +void rocksdb_create_backup_options_set_exclude_files_callback( + rocksdb_create_backup_options_t* options, void* state, + rocksdb_create_backup_options_exclude_files_cb callback) { + options->exclude_files_state = state; + options->exclude_files_callback = callback; + if (callback == nullptr) { + options->rep.exclude_files_callback = {}; + return; + } + // Capture the callback and state by value (matching progress_callback above) + // rather than the options wrapper pointer, so the lambda does not depend on + // the wrapper outliving it. + options->rep.exclude_files_callback = [callback, state]( + MaybeExcludeBackupFile* files_begin, + MaybeExcludeBackupFile* files_end) { + for (auto* file = files_begin; file != files_end; ++file) { + file->exclude_decision = callback(state, file->info.relative_file.data(), + file->info.relative_file.size()); + } + }; +} + void rocksdb_backup_engine_create_new_backup(rocksdb_backup_engine_t* be, rocksdb_t* db, char** errptr) { SaveError(errptr, be->rep->CreateNewBackup(db->rep)); @@ -1308,6 +1791,46 @@ void rocksdb_backup_engine_create_new_backup_flush( SaveError(errptr, be->rep->CreateNewBackup(db->rep, flush_before_backup)); } +void rocksdb_backup_engine_create_new_backup_with_options( + rocksdb_backup_engine_t* be, rocksdb_t* db, + const rocksdb_create_backup_options_t* options, uint32_t* backup_id, + char** errptr) { + CreateBackupOptions default_options; + const CreateBackupOptions& effective_options = + GetCreateBackupOptions(options, &default_options); + BackupID new_backup_id = 0; + BackupID* new_backup_id_ptr = backup_id != nullptr ? &new_backup_id : nullptr; + if (!SaveError(errptr, be->rep->CreateNewBackup(effective_options, db->rep, + new_backup_id_ptr)) && + backup_id != nullptr) { + *backup_id = new_backup_id; + } +} + +void rocksdb_backup_engine_create_new_backup_with_metadata( + rocksdb_backup_engine_t* be, rocksdb_t* db, + const rocksdb_create_backup_options_t* options, const char* app_metadata, + size_t app_metadata_len, uint32_t* backup_id, char** errptr) { + CreateBackupOptions default_options; + const CreateBackupOptions& effective_options = + GetCreateBackupOptions(options, &default_options); + const char* effective_app_metadata = + app_metadata != nullptr ? app_metadata : ""; + if (app_metadata == nullptr) { + app_metadata_len = 0; + } + BackupID new_backup_id = 0; + BackupID* new_backup_id_ptr = backup_id != nullptr ? &new_backup_id : nullptr; + if (!SaveError(errptr, + be->rep->CreateNewBackupWithMetadata( + effective_options, db->rep, + std::string(effective_app_metadata, app_metadata_len), + new_backup_id_ptr)) && + backup_id != nullptr) { + *backup_id = new_backup_id; + } +} + void rocksdb_backup_engine_purge_old_backups(rocksdb_backup_engine_t* be, uint32_t num_backups_to_keep, char** errptr) { @@ -1322,11 +1845,6 @@ void rocksdb_restore_options_destroy(rocksdb_restore_options_t* opt) { delete opt; } -void rocksdb_restore_options_set_keep_log_files(rocksdb_restore_options_t* opt, - int v) { - opt->rep.keep_log_files = v; -} - void rocksdb_backup_engine_verify_backup(rocksdb_backup_engine_t* be, uint32_t backup_id, char** errptr) { SaveError(errptr, be->rep->VerifyBackup(static_cast(backup_id))); @@ -1380,6 +1898,13 @@ uint32_t rocksdb_backup_engine_info_number_files( return info->rep[index].number_files; } +const char* rocksdb_backup_engine_info_app_metadata( + const rocksdb_backup_engine_info_t* info, int index, size_t* len) { + const std::string& app_metadata = info->rep[index].app_metadata; + *len = app_metadata.size(); + return app_metadata.data(); +} + void rocksdb_backup_engine_info_destroy( const rocksdb_backup_engine_info_t* info) { delete info; @@ -1400,76 +1925,11 @@ rocksdb_backup_engine_options_t* rocksdb_backup_engine_options_create( BackupEngineOptions(std::string(backup_dir))}; } -void rocksdb_backup_engine_options_set_backup_dir( - rocksdb_backup_engine_options_t* options, const char* backup_dir) { - options->rep.backup_dir = std::string(backup_dir); -} - void rocksdb_backup_engine_options_set_env( rocksdb_backup_engine_options_t* options, rocksdb_env_t* env) { options->rep.backup_env = (env ? env->rep : nullptr); } -void rocksdb_backup_engine_options_set_share_table_files( - rocksdb_backup_engine_options_t* options, unsigned char val) { - options->rep.share_table_files = val; -} - -unsigned char rocksdb_backup_engine_options_get_share_table_files( - rocksdb_backup_engine_options_t* options) { - return options->rep.share_table_files; -} - -void rocksdb_backup_engine_options_set_sync( - rocksdb_backup_engine_options_t* options, unsigned char val) { - options->rep.sync = val; -} - -unsigned char rocksdb_backup_engine_options_get_sync( - rocksdb_backup_engine_options_t* options) { - return options->rep.sync; -} - -void rocksdb_backup_engine_options_set_destroy_old_data( - rocksdb_backup_engine_options_t* options, unsigned char val) { - options->rep.destroy_old_data = val; -} - -unsigned char rocksdb_backup_engine_options_get_destroy_old_data( - rocksdb_backup_engine_options_t* options) { - return options->rep.destroy_old_data; -} - -void rocksdb_backup_engine_options_set_backup_log_files( - rocksdb_backup_engine_options_t* options, unsigned char val) { - options->rep.backup_log_files = val; -} - -unsigned char rocksdb_backup_engine_options_get_backup_log_files( - rocksdb_backup_engine_options_t* options) { - return options->rep.backup_log_files; -} - -void rocksdb_backup_engine_options_set_backup_rate_limit( - rocksdb_backup_engine_options_t* options, uint64_t limit) { - options->rep.backup_rate_limit = limit; -} - -uint64_t rocksdb_backup_engine_options_get_backup_rate_limit( - rocksdb_backup_engine_options_t* options) { - return options->rep.backup_rate_limit; -} - -void rocksdb_backup_engine_options_set_restore_rate_limit( - rocksdb_backup_engine_options_t* options, uint64_t limit) { - options->rep.restore_rate_limit = limit; -} - -uint64_t rocksdb_backup_engine_options_get_restore_rate_limit( - rocksdb_backup_engine_options_t* options) { - return options->rep.restore_rate_limit; -} - void rocksdb_backup_engine_options_set_backup_rate_limiter( rocksdb_backup_engine_options_t* options, rocksdb_ratelimiter_t* limiter) { if (limiter) { @@ -1484,47 +1944,6 @@ void rocksdb_backup_engine_options_set_restore_rate_limiter( } } -void rocksdb_backup_engine_options_set_max_background_operations( - rocksdb_backup_engine_options_t* options, int val) { - options->rep.max_background_operations = val; -} - -int rocksdb_backup_engine_options_get_max_background_operations( - rocksdb_backup_engine_options_t* options) { - return options->rep.max_background_operations; -} - -void rocksdb_backup_engine_options_set_callback_trigger_interval_size( - rocksdb_backup_engine_options_t* options, uint64_t size) { - options->rep.callback_trigger_interval_size = size; -} - -uint64_t rocksdb_backup_engine_options_get_callback_trigger_interval_size( - rocksdb_backup_engine_options_t* options) { - return options->rep.callback_trigger_interval_size; -} - -void rocksdb_backup_engine_options_set_max_valid_backups_to_open( - rocksdb_backup_engine_options_t* options, int val) { - options->rep.max_valid_backups_to_open = val; -} - -int rocksdb_backup_engine_options_get_max_valid_backups_to_open( - rocksdb_backup_engine_options_t* options) { - return options->rep.max_valid_backups_to_open; -} - -void rocksdb_backup_engine_options_set_share_files_with_checksum_naming( - rocksdb_backup_engine_options_t* options, int val) { - options->rep.share_files_with_checksum_naming = - static_cast(val); -} - -int rocksdb_backup_engine_options_get_share_files_with_checksum_naming( - rocksdb_backup_engine_options_t* options) { - return static_cast(options->rep.share_files_with_checksum_naming); -} - void rocksdb_backup_engine_options_destroy( rocksdb_backup_engine_options_t* options) { delete options; @@ -1590,6 +2009,7 @@ rocksdb_t* rocksdb_open_and_trim_history( rocksdb_column_family_handle_t** column_family_handles, char* trim_ts, size_t trim_tslen, char** errptr) { std::vector column_families; + column_families.reserve(num_column_families); for (int i = 0; i < num_column_families; i++) { column_families.emplace_back( std::string(column_family_names[i]), @@ -1887,6 +2307,24 @@ void rocksdb_column_family_handle_destroy( delete handle; } +// BEGIN generated: c_generated_db_simple_subset.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'DB data operations' +// --header-out +// c_api_gen/c_generated_db_simple_subset.h.inc +// --source-out +// c_api_gen/c_generated_db_simple_subset.cc.inc + +/* DB data operations */ + void rocksdb_put(rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, size_t keylen, const char* val, size_t vallen, char** errptr) { @@ -1902,6 +2340,38 @@ void rocksdb_put_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, Slice(key, keylen), Slice(val, vallen))); } +void rocksdb_delete(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, char** errptr) { + SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen))); +} + +void rocksdb_delete_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, char** errptr) { + SaveError(errptr, db->rep->Delete(options->rep, column_family->rep, + Slice(key, keylen))); +} + +void rocksdb_merge(rocksdb_t* db, const rocksdb_writeoptions_t* options, + const char* key, size_t keylen, const char* val, + size_t vallen, char** errptr) { + SaveError(errptr, db->rep->Merge(options->rep, Slice(key, keylen), + Slice(val, vallen))); +} + +void rocksdb_merge_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, const char* val, + size_t vallen, char** errptr) { + SaveError(errptr, db->rep->Merge(options->rep, column_family->rep, + Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_write(rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr) { + SaveError(errptr, db->rep->Write(options->rep, &batch->rep)); +} + void rocksdb_put_with_ts(rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, size_t keylen, const char* ts, size_t tslen, const char* val, size_t vallen, @@ -1921,18 +2391,6 @@ void rocksdb_put_cf_with_ts(rocksdb_t* db, Slice(ts, tslen), Slice(val, vallen))); } -void rocksdb_delete(rocksdb_t* db, const rocksdb_writeoptions_t* options, - const char* key, size_t keylen, char** errptr) { - SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen))); -} - -void rocksdb_delete_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, - rocksdb_column_family_handle_t* column_family, - const char* key, size_t keylen, char** errptr) { - SaveError(errptr, db->rep->Delete(options->rep, column_family->rep, - Slice(key, keylen))); -} - void rocksdb_delete_with_ts(rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, size_t keylen, const char* ts, @@ -1980,6 +2438,84 @@ void rocksdb_singledelete_cf_with_ts( Slice(key, keylen), Slice(ts, tslen))); } +void rocksdb_delete_range_cf(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, + const char* end_key, size_t end_key_len, + char** errptr) { + SaveError(errptr, db->rep->DeleteRange(options->rep, column_family->rep, + Slice(start_key, start_key_len), + Slice(end_key, end_key_len))); +} + +void rocksdb_flush(rocksdb_t* db, const rocksdb_flushoptions_t* options, + char** errptr) { + SaveError(errptr, db->rep->Flush(options->rep)); +} + +void rocksdb_flush_cf(rocksdb_t* db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, + char** errptr) { + SaveError(errptr, db->rep->Flush(options->rep, column_family->rep)); +} + +void rocksdb_flush_wal(rocksdb_t* db, unsigned char sync, char** errptr) { + SaveError(errptr, db->rep->FlushWAL(sync)); +} + +void rocksdb_pause_background_work(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->PauseBackgroundWork()); +} + +void rocksdb_continue_background_work(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->ContinueBackgroundWork()); +} + +void rocksdb_disable_file_deletions(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->DisableFileDeletions()); +} + +void rocksdb_enable_file_deletions(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->EnableFileDeletions()); +} + +void rocksdb_verify_checksum(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->VerifyChecksum()); +} + +void rocksdb_verify_file_checksums(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->VerifyFileChecksums(ReadOptions())); +} + +void rocksdb_destroy_db(const rocksdb_options_t* options, const char* name, + char** errptr) { + SaveError(errptr, DestroyDB(name, options->rep)); +} + +void rocksdb_repair_db(const rocksdb_options_t* options, const char* name, + char** errptr) { + SaveError(errptr, RepairDB(name, options->rep)); +} +// END generated: c_generated_db_simple_subset.cc.inc + +void rocksdb_verify_checksum_with_options(rocksdb_t* db, + const rocksdb_readoptions_t* options, + char** errptr) { + ReadOptions default_options; + const ReadOptions& read_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, db->rep->VerifyChecksum(read_options)); +} + +void rocksdb_verify_file_checksums_with_options( + rocksdb_t* db, const rocksdb_readoptions_t* options, char** errptr) { + ReadOptions default_options; + const ReadOptions& read_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, db->rep->VerifyFileChecksums(read_options)); +} + void rocksdb_increase_full_history_ts_low( rocksdb_t* db, rocksdb_column_family_handle_t* column_family, const char* ts_low, size_t ts_lowlen, char** errptr) { @@ -2003,37 +2539,6 @@ char* rocksdb_get_full_history_ts_low( return result; } -void rocksdb_delete_range_cf(rocksdb_t* db, - const rocksdb_writeoptions_t* options, - rocksdb_column_family_handle_t* column_family, - const char* start_key, size_t start_key_len, - const char* end_key, size_t end_key_len, - char** errptr) { - SaveError(errptr, db->rep->DeleteRange(options->rep, column_family->rep, - Slice(start_key, start_key_len), - Slice(end_key, end_key_len))); -} - -void rocksdb_merge(rocksdb_t* db, const rocksdb_writeoptions_t* options, - const char* key, size_t keylen, const char* val, - size_t vallen, char** errptr) { - SaveError(errptr, db->rep->Merge(options->rep, Slice(key, keylen), - Slice(val, vallen))); -} - -void rocksdb_merge_cf(rocksdb_t* db, const rocksdb_writeoptions_t* options, - rocksdb_column_family_handle_t* column_family, - const char* key, size_t keylen, const char* val, - size_t vallen, char** errptr) { - SaveError(errptr, db->rep->Merge(options->rep, column_family->rep, - Slice(key, keylen), Slice(val, vallen))); -} - -void rocksdb_write(rocksdb_t* db, const rocksdb_writeoptions_t* options, - rocksdb_writebatch_t* batch, char** errptr) { - SaveError(errptr, db->rep->Write(options->rep, &batch->rep)); -} - char* rocksdb_get(rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key, size_t keylen, size_t* vallen, char** errptr) { @@ -2429,6 +2934,31 @@ rocksdb_wal_iterator_t* rocksdb_get_updates_since( return result; } +rocksdb_wal_files_t* rocksdb_get_sorted_wal_files(rocksdb_t* db, + char** errptr) { + auto* result = new rocksdb_wal_files_t; + VectorWalPtr wal_files; + if (SaveError(errptr, db->rep->GetSortedWalFiles(wal_files))) { + delete result; + return nullptr; + } + result->rep.reserve(wal_files.size()); + for (const auto& wal_file : wal_files) { + result->rep.push_back(CaptureWalFile(*wal_file)); + } + return result; +} + +rocksdb_wal_file_t* rocksdb_get_current_wal_file(rocksdb_t* db, char** errptr) { + std::unique_ptr wal_file; + if (SaveError(errptr, db->rep->GetCurrentWalFile(&wal_file))) { + return nullptr; + } + auto* result = new rocksdb_wal_file_t; + *result = CaptureWalFile(*wal_file); + return result; +} + void rocksdb_wal_iter_next(rocksdb_wal_iterator_t* iter) { iter->rep->Next(); } unsigned char rocksdb_wal_iter_valid(const rocksdb_wal_iterator_t* iter) { @@ -2445,6 +2975,58 @@ void rocksdb_wal_iter_destroy(const rocksdb_wal_iterator_t* iter) { delete iter; } +rocksdb_wal_readoptions_t* rocksdb_wal_readoptions_create() { + return new rocksdb_wal_readoptions_t; +} + +void rocksdb_wal_readoptions_destroy(rocksdb_wal_readoptions_t* options) { + delete options; +} + +void rocksdb_wal_readoptions_set_verify_checksums( + rocksdb_wal_readoptions_t* options, unsigned char verify_checksums) { + options->rep.verify_checksums_ = verify_checksums != 0; +} + +unsigned char rocksdb_wal_readoptions_get_verify_checksums( + rocksdb_wal_readoptions_t* options) { + return options->rep.verify_checksums_; +} + +const char* rocksdb_wal_file_path_name(const rocksdb_wal_file_t* file) { + return file->path_name.c_str(); +} + +uint64_t rocksdb_wal_file_log_number(const rocksdb_wal_file_t* file) { + return file->log_number; +} + +int rocksdb_wal_file_type(const rocksdb_wal_file_t* file) { return file->type; } + +uint64_t rocksdb_wal_file_start_sequence(const rocksdb_wal_file_t* file) { + return file->start_sequence; +} + +uint64_t rocksdb_wal_file_size_file_bytes(const rocksdb_wal_file_t* file) { + return file->size_file_bytes; +} + +void rocksdb_wal_file_destroy(rocksdb_wal_file_t* file) { delete file; } + +size_t rocksdb_wal_files_count(const rocksdb_wal_files_t* files) { + return files->rep.size(); +} + +const rocksdb_wal_file_t* rocksdb_wal_files_get_wal_file( + const rocksdb_wal_files_t* files, size_t index) { + if (index >= files->rep.size()) { + return nullptr; + } + return &files->rep[index]; +} + +void rocksdb_wal_files_destroy(rocksdb_wal_files_t* files) { delete files; } + rocksdb_writebatch_t* rocksdb_wal_iter_get_batch( const rocksdb_wal_iterator_t* iter, uint64_t* seq) { rocksdb_writebatch_t* result = rocksdb_writebatch_create(); @@ -2554,16 +3136,12 @@ void rocksdb_approximate_sizes(rocksdb_t* db, int num_ranges, const char* const* range_limit_key, const size_t* range_limit_key_len, uint64_t* sizes, char** errptr) { - Range* ranges = new Range[num_ranges]; - for (int i = 0; i < num_ranges; i++) { - ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]); - ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]); - } - Status s = db->rep->GetApproximateSizes(ranges, num_ranges, sizes); + auto ranges = BuildRanges(num_ranges, range_start_key, range_start_key_len, + range_limit_key, range_limit_key_len); + Status s = db->rep->GetApproximateSizes(ranges.get(), num_ranges, sizes); if (!s.ok()) { SaveError(errptr, s); } - delete[] ranges; } void rocksdb_approximate_sizes_cf( @@ -2571,17 +3149,13 @@ void rocksdb_approximate_sizes_cf( int num_ranges, const char* const* range_start_key, const size_t* range_start_key_len, const char* const* range_limit_key, const size_t* range_limit_key_len, uint64_t* sizes, char** errptr) { - Range* ranges = new Range[num_ranges]; - for (int i = 0; i < num_ranges; i++) { - ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]); - ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]); - } - Status s = db->rep->GetApproximateSizes(column_family->rep, ranges, + auto ranges = BuildRanges(num_ranges, range_start_key, range_start_key_len, + range_limit_key, range_limit_key_len); + Status s = db->rep->GetApproximateSizes(column_family->rep, ranges.get(), num_ranges, sizes); if (!s.ok()) { SaveError(errptr, s); } - delete[] ranges; } extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_cf_with_flags( @@ -2590,18 +3164,55 @@ extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_cf_with_flags( const size_t* range_start_key_len, const char* const* range_limit_key, const size_t* range_limit_key_len, uint8_t include_flags, uint64_t* sizes, char** errptr) { - Range* ranges = new Range[num_ranges]; - for (int i = 0; i < num_ranges; i++) { - ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]); - ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]); - } + auto ranges = BuildRanges(num_ranges, range_start_key, range_start_key_len, + range_limit_key, range_limit_key_len); Status s = db->rep->GetApproximateSizes( - column_family->rep, ranges, num_ranges, sizes, + column_family->rep, ranges.get(), num_ranges, sizes, static_cast(include_flags)); if (!s.ok()) { SaveError(errptr, s); } - delete[] ranges; +} + +rocksdb_size_approximation_options_t* +rocksdb_size_approximation_options_create() { + return new rocksdb_size_approximation_options_t; +} + +void rocksdb_size_approximation_options_destroy( + rocksdb_size_approximation_options_t* options) { + delete options; +} + +void rocksdb_approximate_sizes_with_options( + rocksdb_t* db, const rocksdb_size_approximation_options_t* options, + int num_ranges, const char* const* range_start_key, + const size_t* range_start_key_len, const char* const* range_limit_key, + const size_t* range_limit_key_len, uint64_t* sizes, char** errptr) { + auto ranges = BuildRanges(num_ranges, range_start_key, range_start_key_len, + range_limit_key, range_limit_key_len); + SizeApproximationOptions default_options; + const SizeApproximationOptions& size_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, db->rep->GetApproximateSizes( + size_options, db->rep->DefaultColumnFamily(), + ranges.get(), num_ranges, sizes)); +} + +void rocksdb_approximate_sizes_cf_with_options( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const rocksdb_size_approximation_options_t* options, int num_ranges, + const char* const* range_start_key, const size_t* range_start_key_len, + const char* const* range_limit_key, const size_t* range_limit_key_len, + uint64_t* sizes, char** errptr) { + auto ranges = BuildRanges(num_ranges, range_start_key, range_start_key_len, + range_limit_key, range_limit_key_len); + SizeApproximationOptions default_options; + const SizeApproximationOptions& size_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, + db->rep->GetApproximateSizes(size_options, column_family->rep, + ranges.get(), num_ranges, sizes)); } const rocksdb_livefiles_t* rocksdb_livefiles(rocksdb_t* db) { @@ -2613,7 +3224,8 @@ const rocksdb_livefiles_t* rocksdb_livefiles(rocksdb_t* db) { void rocksdb_compact_range(rocksdb_t* db, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len) { - Slice a, b; + Slice a; + Slice b; db->rep->CompactRange( CompactRangeOptions(), // Pass nullptr Slice if corresponding "const char*" is nullptr @@ -2625,7 +3237,8 @@ void rocksdb_compact_range_cf(rocksdb_t* db, rocksdb_column_family_handle_t* column_family, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len) { - Slice a, b; + Slice a; + Slice b; db->rep->CompactRange( CompactRangeOptions(), column_family->rep, // Pass nullptr Slice if corresponding "const char*" is nullptr @@ -2636,7 +3249,8 @@ void rocksdb_compact_range_cf(rocksdb_t* db, void rocksdb_suggest_compact_range(rocksdb_t* db, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len, char** errptr) { - Slice a, b; + Slice a; + Slice b; Status s = ROCKSDB_NAMESPACE::experimental::SuggestCompactRange( db->rep, (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), @@ -2648,7 +3262,8 @@ void rocksdb_suggest_compact_range_cf( rocksdb_t* db, rocksdb_column_family_handle_t* column_family, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len, char** errptr) { - Slice a, b; + Slice a; + Slice b; Status s = db->rep->SuggestCompactRange( column_family->rep, (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), @@ -2659,7 +3274,8 @@ void rocksdb_suggest_compact_range_cf( void rocksdb_compact_range_opt(rocksdb_t* db, rocksdb_compactoptions_t* opt, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len) { - Slice a, b; + Slice a; + Slice b; db->rep->CompactRange( opt->rep, // Pass nullptr Slice if corresponding "const char*" is nullptr @@ -2672,7 +3288,8 @@ void rocksdb_compact_range_cf_opt(rocksdb_t* db, rocksdb_compactoptions_t* opt, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len) { - Slice a, b; + Slice a; + Slice b; db->rep->CompactRange( opt->rep, column_family->rep, // Pass nullptr Slice if corresponding "const char*" is nullptr @@ -2680,21 +3297,73 @@ void rocksdb_compact_range_cf_opt(rocksdb_t* db, (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)); } -void rocksdb_flush(rocksdb_t* db, const rocksdb_flushoptions_t* options, - char** errptr) { - SaveError(errptr, db->rep->Flush(options->rep)); +void rocksdb_compact_files_output_file_names_destroy( + char** output_file_names, size_t num_output_file_names) { + rocksdb_list_column_families_destroy(output_file_names, + num_output_file_names); } -void rocksdb_flush_cf(rocksdb_t* db, const rocksdb_flushoptions_t* options, - rocksdb_column_family_handle_t* column_family, - char** errptr) { - SaveError(errptr, db->rep->Flush(options->rep, column_family->rep)); +void rocksdb_compact_files(rocksdb_t* db, + const rocksdb_compaction_options_t* options, + const char* const* input_file_names, + size_t num_input_file_names, int output_level, + int output_path_id, char*** output_file_names, + size_t* num_output_file_names, + rocksdb_compactionjobinfo_t* compaction_job_info, + char** errptr) { + rocksdb_compact_files_cf(db, nullptr, options, input_file_names, + num_input_file_names, output_level, output_path_id, + output_file_names, num_output_file_names, + compaction_job_info, errptr); +} + +void rocksdb_compact_files_cf(rocksdb_t* db, + rocksdb_column_family_handle_t* column_family, + const rocksdb_compaction_options_t* options, + const char* const* input_file_names, + size_t num_input_file_names, int output_level, + int output_path_id, char*** output_file_names, + size_t* num_output_file_names, + rocksdb_compactionjobinfo_t* compaction_job_info, + char** errptr) { + std::vector input_files; + input_files.reserve(num_input_file_names); + for (size_t i = 0; i < num_input_file_names; ++i) { + input_files.emplace_back(input_file_names[i]); + } + + std::vector output_files; + std::vector* output_files_ptr = + output_file_names != nullptr ? &output_files : nullptr; + CompactionOptions default_options; + const CompactionOptions* compaction_options = + options != nullptr ? &options->rep : &default_options; + ColumnFamilyHandle* cf_handle = column_family != nullptr + ? column_family->rep + : db->rep->DefaultColumnFamily(); + CompactionJobInfo* job_info = + compaction_job_info != nullptr ? &compaction_job_info->rep : nullptr; + + Status s = db->rep->CompactFiles(*compaction_options, cf_handle, input_files, + output_level, output_path_id, + output_files_ptr, job_info); + if (SaveError(errptr, s)) { + return; + } + + if (num_output_file_names != nullptr) { + *num_output_file_names = output_files.size(); + } + if (output_file_names != nullptr) { + *output_file_names = CopyStringVector(output_files); + } } void rocksdb_flush_cfs(rocksdb_t* db, const rocksdb_flushoptions_t* options, rocksdb_column_family_handle_t** column_families, int num_column_families, char** errptr) { std::vector column_family_handles; + column_family_handles.reserve(num_column_families); for (int i = 0; i < num_column_families; i++) { column_family_handles.push_back(column_families[i]->rep); } @@ -2702,28 +3371,6 @@ void rocksdb_flush_cfs(rocksdb_t* db, const rocksdb_flushoptions_t* options, SaveError(errptr, db->rep->Flush(options->rep, column_family_handles)); } -void rocksdb_flush_wal(rocksdb_t* db, unsigned char sync, char** errptr) { - SaveError(errptr, db->rep->FlushWAL(sync)); -} - -void rocksdb_disable_file_deletions(rocksdb_t* db, char** errptr) { - SaveError(errptr, db->rep->DisableFileDeletions()); -} - -void rocksdb_enable_file_deletions(rocksdb_t* db, char** errptr) { - SaveError(errptr, db->rep->EnableFileDeletions()); -} - -void rocksdb_destroy_db(const rocksdb_options_t* options, const char* name, - char** errptr) { - SaveError(errptr, DestroyDB(name, options->rep)); -} - -void rocksdb_repair_db(const rocksdb_options_t* options, const char* name, - char** errptr) { - SaveError(errptr, RepairDB(name, options->rep)); -} - void rocksdb_iter_destroy(rocksdb_iterator_t* iter) { delete iter->rep; delete iter; @@ -2829,10 +3476,28 @@ rocksdb_writebatch_t* rocksdb_writebatch_create_with_params( void rocksdb_writebatch_destroy(rocksdb_writebatch_t* b) { delete b; } -void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) { b->rep.Clear(); } - int rocksdb_writebatch_count(rocksdb_writebatch_t* b) { return b->rep.Count(); } +// BEGIN generated: c_generated_writebatch_subset.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'WriteBatch' +// --header-out +// c_api_gen/c_generated_writebatch_subset.h.inc +// --source-out +// c_api_gen/c_generated_writebatch_subset.cc.inc + +/* WriteBatch */ + +void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) { b->rep.Clear(); } + void rocksdb_writebatch_put(rocksdb_writebatch_t* b, const char* key, size_t klen, const char* val, size_t vlen) { b->rep.Put(Slice(key, klen), Slice(val, vlen)); @@ -2845,6 +3510,35 @@ void rocksdb_writebatch_put_cf(rocksdb_writebatch_t* b, b->rep.Put(column_family->rep, Slice(key, klen), Slice(val, vlen)); } +void rocksdb_writebatch_delete(rocksdb_writebatch_t* b, const char* key, + size_t klen) { + b->rep.Delete(Slice(key, klen)); +} + +void rocksdb_writebatch_put_log_data(rocksdb_writebatch_t* b, const char* blob, + size_t len) { + b->rep.PutLogData(Slice(blob, len)); +} + +void rocksdb_writebatch_set_save_point(rocksdb_writebatch_t* b) { + b->rep.SetSavePoint(); +} + +void rocksdb_writebatch_rollback_to_save_point(rocksdb_writebatch_t* b, + char** errptr) { + SaveError(errptr, b->rep.RollbackToSavePoint()); +} + +void rocksdb_writebatch_pop_save_point(rocksdb_writebatch_t* b, char** errptr) { + SaveError(errptr, b->rep.PopSavePoint()); +} + +void rocksdb_writebatch_verify_checksum(rocksdb_writebatch_t* b, + char** errptr) { + SaveError(errptr, b->rep.VerifyChecksum()); +} +// END generated: c_generated_writebatch_subset.cc.inc + void rocksdb_writebatch_put_cf_with_ts( rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, const char* ts, size_t tslen, const char* val, @@ -2943,11 +3637,6 @@ void rocksdb_writebatch_mergev_cf(rocksdb_writebatch_t* b, SliceParts(value_slices.get(), num_values)); } -void rocksdb_writebatch_delete(rocksdb_writebatch_t* b, const char* key, - size_t klen) { - b->rep.Delete(Slice(key, klen)); -} - void rocksdb_writebatch_singledelete(rocksdb_writebatch_t* b, const char* key, size_t klen) { b->rep.SingleDelete(Slice(key, klen)); @@ -3052,11 +3741,6 @@ void rocksdb_writebatch_delete_rangev_cf( SliceParts(end_key_slices.get(), num_keys)); } -void rocksdb_writebatch_put_log_data(rocksdb_writebatch_t* b, const char* blob, - size_t len) { - b->rep.PutLogData(Slice(blob, len)); -} - class H : public WriteBatch::Handler { public: void* state_; @@ -3176,19 +3860,6 @@ const char* rocksdb_writebatch_data(rocksdb_writebatch_t* b, size_t* size) { return b->rep.Data().c_str(); } -void rocksdb_writebatch_set_save_point(rocksdb_writebatch_t* b) { - b->rep.SetSavePoint(); -} - -void rocksdb_writebatch_rollback_to_save_point(rocksdb_writebatch_t* b, - char** errptr) { - SaveError(errptr, b->rep.RollbackToSavePoint()); -} - -void rocksdb_writebatch_pop_save_point(rocksdb_writebatch_t* b, char** errptr) { - SaveError(errptr, b->rep.PopSavePoint()); -} - rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create( size_t reserved_bytes, unsigned char overwrite_key) { rocksdb_writebatch_wi_t* b = new rocksdb_writebatch_wi_t; @@ -3688,147 +4359,29 @@ void rocksdb_block_based_options_destroy( delete options; } -void rocksdb_block_based_options_set_checksum( - rocksdb_block_based_table_options_t* opt, char v) { - opt->rep.checksum = static_cast(v); -} +// BEGIN generated: c_generated_block_based_options_subset.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- -void rocksdb_block_based_options_set_block_size( - rocksdb_block_based_table_options_t* options, size_t block_size) { - options->rep.block_size = block_size; -} +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'BlockBasedOptions simple' +// --header-out +// c_api_gen/c_generated_block_based_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_block_based_options_subset.cc.inc -void rocksdb_block_based_options_set_block_size_deviation( - rocksdb_block_based_table_options_t* options, int block_size_deviation) { - options->rep.block_size_deviation = block_size_deviation; -} - -void rocksdb_block_based_options_set_block_restart_interval( - rocksdb_block_based_table_options_t* options, int block_restart_interval) { - options->rep.block_restart_interval = block_restart_interval; -} - -void rocksdb_block_based_options_set_index_block_restart_interval( - rocksdb_block_based_table_options_t* options, - int index_block_restart_interval) { - options->rep.index_block_restart_interval = index_block_restart_interval; -} - -void rocksdb_block_based_options_set_metadata_block_size( - rocksdb_block_based_table_options_t* options, - uint64_t metadata_block_size) { - options->rep.metadata_block_size = metadata_block_size; -} - -void rocksdb_block_based_options_set_partition_filters( - rocksdb_block_based_table_options_t* options, - unsigned char partition_filters) { - options->rep.partition_filters = partition_filters; -} - -void rocksdb_block_based_options_set_optimize_filters_for_memory( - rocksdb_block_based_table_options_t* options, - unsigned char optimize_filters_for_memory) { - options->rep.optimize_filters_for_memory = optimize_filters_for_memory; -} - -void rocksdb_block_based_options_set_use_delta_encoding( - rocksdb_block_based_table_options_t* options, - unsigned char use_delta_encoding) { - options->rep.use_delta_encoding = use_delta_encoding; -} - -void rocksdb_block_based_options_set_filter_policy( - rocksdb_block_based_table_options_t* options, - rocksdb_filterpolicy_t* filter_policy) { - options->rep.filter_policy.reset(filter_policy); -} - -void rocksdb_block_based_options_set_no_block_cache( - rocksdb_block_based_table_options_t* options, - unsigned char no_block_cache) { - options->rep.no_block_cache = no_block_cache; -} - -void rocksdb_block_based_options_set_block_cache( - rocksdb_block_based_table_options_t* options, - rocksdb_cache_t* block_cache) { - if (block_cache) { - options->rep.block_cache = block_cache->rep; - } -} - -void rocksdb_block_based_options_set_whole_key_filtering( - rocksdb_block_based_table_options_t* options, unsigned char v) { - options->rep.whole_key_filtering = v; -} - -void rocksdb_block_based_options_set_format_version( - rocksdb_block_based_table_options_t* options, int v) { - options->rep.format_version = v; -} - -void rocksdb_block_based_options_set_separate_key_value_in_data_block( - rocksdb_block_based_table_options_t* options, unsigned char v) { - options->rep.separate_key_value_in_data_block = v; -} - -void rocksdb_block_based_options_set_index_type( - rocksdb_block_based_table_options_t* options, int v) { - options->rep.index_type = static_cast(v); -} - -void rocksdb_block_based_options_set_data_block_index_type( - rocksdb_block_based_table_options_t* options, int v) { - options->rep.data_block_index_type = - static_cast(v); -} - -void rocksdb_block_based_options_set_index_block_search_type( - rocksdb_block_based_table_options_t* options, int v) { - options->rep.index_block_search_type = - static_cast(v); -} - -void rocksdb_block_based_options_set_uniform_cv_threshold( - rocksdb_block_based_table_options_t* options, double v) { - options->rep.uniform_cv_threshold = v; -} +/* BlockBasedOptions simple */ void rocksdb_block_based_options_set_data_block_hash_ratio( rocksdb_block_based_table_options_t* options, double v) { options->rep.data_block_hash_table_util_ratio = v; } -void rocksdb_block_based_options_set_cache_index_and_filter_blocks( - rocksdb_block_based_table_options_t* options, unsigned char v) { - options->rep.cache_index_and_filter_blocks = v; -} - -void rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority( - rocksdb_block_based_table_options_t* options, unsigned char v) { - options->rep.cache_index_and_filter_blocks_with_high_priority = v; -} - -void rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache( - rocksdb_block_based_table_options_t* options, unsigned char v) { - options->rep.pin_l0_filter_and_index_blocks_in_cache = v; -} - -void rocksdb_block_based_options_set_pin_top_level_index_and_filter( - rocksdb_block_based_table_options_t* options, unsigned char v) { - options->rep.pin_top_level_index_and_filter = v; -} - -void rocksdb_options_set_block_based_table_factory( - rocksdb_options_t* opt, - rocksdb_block_based_table_options_t* table_options) { - if (table_options) { - opt->rep.table_factory.reset( - ROCKSDB_NAMESPACE::NewBlockBasedTableFactory(table_options->rep)); - } -} - void rocksdb_block_based_options_set_top_level_index_pinning_tier( rocksdb_block_based_table_options_t* options, int v) { options->rep.metadata_cache_options.top_level_index_pinning = @@ -3846,14 +4399,95 @@ void rocksdb_block_based_options_set_unpartitioned_pinning_tier( options->rep.metadata_cache_options.unpartitioned_pinning = static_cast(v); } +// END generated: c_generated_block_based_options_subset.cc.inc -void rocksdb_block_based_options_set_block_align( - rocksdb_block_based_table_options_t* options, unsigned char v) { - options->rep.block_align = v; +void rocksdb_block_based_options_set_filter_policy( + rocksdb_block_based_table_options_t* options, + rocksdb_filterpolicy_t* filter_policy) { + options->rep.filter_policy.reset(filter_policy); +} + +void rocksdb_block_based_options_set_block_cache( + rocksdb_block_based_table_options_t* options, + rocksdb_cache_t* block_cache) { + if (block_cache) { + options->rep.block_cache = block_cache->rep; + } +} + +void rocksdb_block_based_options_set_user_defined_index_factory_from_string( + rocksdb_block_based_table_options_t* options, const char* value, + size_t value_len, char** errptr) { + options->user_defined_index_factory.reset(); + options->rep.user_defined_index_factory.reset(); + if (value == nullptr) { + return; + } + + std::shared_ptr factory; + Status s = LoadUserDefinedIndexFactoryFromString(value, value_len, &factory); + if (SaveError(errptr, s)) { + return; + } + options->user_defined_index_factory = std::move(factory); + options->rep.user_defined_index_factory = options->user_defined_index_factory; +} + +void rocksdb_block_based_options_clear_user_defined_index_factory( + rocksdb_block_based_table_options_t* options) { + options->user_defined_index_factory.reset(); + options->rep.user_defined_index_factory.reset(); +} + +const char* rocksdb_block_based_options_get_user_defined_index_factory_name( + const rocksdb_block_based_table_options_t* options, size_t* name_len) { + if (options->user_defined_index_factory == nullptr) { + if (name_len != nullptr) { + *name_len = 0; + } + return nullptr; + } + const char* name = options->user_defined_index_factory->Name(); + if (name_len != nullptr) { + *name_len = strlen(name); + } + return name; +} + +void rocksdb_options_set_block_based_table_factory( + rocksdb_options_t* opt, + rocksdb_block_based_table_options_t* table_options) { + if (table_options) { + opt->rep.table_factory.reset( + ROCKSDB_NAMESPACE::NewBlockBasedTableFactory(table_options->rep)); + } } /* FlushJobInfo */ +// BEGIN generated: c_generated_jobinfo_auto.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/listener.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered JobInfo metadata simple + +/* FlushJobInfo */ + +uint32_t rocksdb_flushjobinfo_cf_id(const rocksdb_flushjobinfo_t* info) { + return info->rep.cf_id; +} + const char* rocksdb_flushjobinfo_cf_name(const rocksdb_flushjobinfo_t* info, size_t* size) { *size = info->rep.cf_name.size(); @@ -3866,6 +4500,23 @@ const char* rocksdb_flushjobinfo_file_path(const rocksdb_flushjobinfo_t* info, return info->rep.file_path.data(); } +uint64_t rocksdb_flushjobinfo_file_number(const rocksdb_flushjobinfo_t* info) { + return info->rep.file_number; +} + +uint64_t rocksdb_flushjobinfo_oldest_blob_file_number( + const rocksdb_flushjobinfo_t* info) { + return info->rep.oldest_blob_file_number; +} + +uint64_t rocksdb_flushjobinfo_thread_id(const rocksdb_flushjobinfo_t* info) { + return info->rep.thread_id; +} + +int rocksdb_flushjobinfo_job_id(const rocksdb_flushjobinfo_t* info) { + return info->rep.job_id; +} + unsigned char rocksdb_flushjobinfo_triggered_writes_slowdown( const rocksdb_flushjobinfo_t* info) { return info->rep.triggered_writes_slowdown; @@ -3876,30 +4527,30 @@ unsigned char rocksdb_flushjobinfo_triggered_writes_stop( return info->rep.triggered_writes_stop; } -uint64_t rocksdb_flushjobinfo_largest_seqno( - const rocksdb_flushjobinfo_t* info) { - return info->rep.largest_seqno; -} - uint64_t rocksdb_flushjobinfo_smallest_seqno( const rocksdb_flushjobinfo_t* info) { return info->rep.smallest_seqno; } +uint64_t rocksdb_flushjobinfo_largest_seqno( + const rocksdb_flushjobinfo_t* info) { + return info->rep.largest_seqno; +} + uint32_t rocksdb_flushjobinfo_flush_reason(const rocksdb_flushjobinfo_t* info) { return static_cast(info->rep.flush_reason); } -void rocksdb_reset_status(rocksdb_status_ptr_t* status_ptr) { - auto ptr = status_ptr->rep; - *ptr = Status::OK(); +uint32_t rocksdb_flushjobinfo_blob_compression_type( + const rocksdb_flushjobinfo_t* info) { + return static_cast(info->rep.blob_compression_type); } /* CompactionJobInfo */ -void rocksdb_compactionjobinfo_status(const rocksdb_compactionjobinfo_t* info, - char** errptr) { - SaveError(errptr, info->rep.status); +uint32_t rocksdb_compactionjobinfo_cf_id( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.cf_id; } const char* rocksdb_compactionjobinfo_cf_name( @@ -3908,44 +4559,23 @@ const char* rocksdb_compactionjobinfo_cf_name( return info->rep.cf_name.data(); } -size_t rocksdb_compactionjobinfo_input_files_count( +void rocksdb_compactionjobinfo_status(const rocksdb_compactionjobinfo_t* info, + char** errptr) { + SaveError(errptr, info->rep.status); +} + +uint64_t rocksdb_compactionjobinfo_thread_id( const rocksdb_compactionjobinfo_t* info) { - return info->rep.input_files.size(); + return info->rep.thread_id; } -const char* rocksdb_compactionjobinfo_input_file_at( - const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size) { - assert(info != nullptr); - assert(pos < info->rep.input_files.size()); - - const std::string& path = info->rep.input_files[pos]; - *size = path.size(); - return path.data(); +int rocksdb_compactionjobinfo_job_id(const rocksdb_compactionjobinfo_t* info) { + return info->rep.job_id; } -size_t rocksdb_compactionjobinfo_output_files_count( +int rocksdb_compactionjobinfo_num_l0_files( const rocksdb_compactionjobinfo_t* info) { - return info->rep.output_files.size(); -} - -const char* rocksdb_compactionjobinfo_output_file_at( - const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size) { - assert(info != nullptr); - assert(pos < info->rep.output_files.size()); - - const std::string& path = info->rep.output_files[pos]; - *size = path.size(); - return path.data(); -} - -uint64_t rocksdb_compactionjobinfo_elapsed_micros( - const rocksdb_compactionjobinfo_t* info) { - return info->rep.stats.elapsed_micros; -} - -uint64_t rocksdb_compactionjobinfo_num_corrupt_keys( - const rocksdb_compactionjobinfo_t* info) { - return info->rep.stats.num_corrupt_keys; + return info->rep.num_l0_files; } int rocksdb_compactionjobinfo_base_input_level( @@ -3958,14 +4588,176 @@ int rocksdb_compactionjobinfo_output_level( return info->rep.output_level; } -size_t rocksdb_compactionjobinfo_num_input_files( +uint32_t rocksdb_compactionjobinfo_compaction_reason( const rocksdb_compactionjobinfo_t* info) { - return info->rep.stats.num_input_files; + return static_cast(info->rep.compaction_reason); } -size_t rocksdb_compactionjobinfo_num_input_files_at_output_level( +uint32_t rocksdb_compactionjobinfo_compression( const rocksdb_compactionjobinfo_t* info) { - return info->rep.stats.num_input_files_at_output_level; + return static_cast(info->rep.compression); +} + +uint32_t rocksdb_compactionjobinfo_blob_compression_type( + const rocksdb_compactionjobinfo_t* info) { + return static_cast(info->rep.blob_compression_type); +} + +unsigned char rocksdb_compactionjobinfo_aborted( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.aborted; +} + +/* SubcompactionJobInfo */ + +uint32_t rocksdb_subcompactionjobinfo_cf_id( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.cf_id; +} + +const char* rocksdb_subcompactionjobinfo_cf_name( + const rocksdb_subcompactionjobinfo_t* info, size_t* size) { + *size = info->rep.cf_name.size(); + return info->rep.cf_name.data(); +} + +void rocksdb_subcompactionjobinfo_status( + const rocksdb_subcompactionjobinfo_t* info, char** errptr) { + SaveError(errptr, info->rep.status); +} + +uint64_t rocksdb_subcompactionjobinfo_thread_id( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.thread_id; +} + +int rocksdb_subcompactionjobinfo_job_id( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.job_id; +} + +int rocksdb_subcompactionjobinfo_subcompaction_job_id( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.subcompaction_job_id; +} + +int rocksdb_subcompactionjobinfo_base_input_level( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.base_input_level; +} + +int rocksdb_subcompactionjobinfo_output_level( + const rocksdb_subcompactionjobinfo_t* info) { + return info->rep.output_level; +} + +uint32_t rocksdb_subcompactionjobinfo_compaction_reason( + const rocksdb_subcompactionjobinfo_t* info) { + return static_cast(info->rep.compaction_reason); +} + +uint32_t rocksdb_subcompactionjobinfo_compression( + const rocksdb_subcompactionjobinfo_t* info) { + return static_cast(info->rep.compression); +} + +uint32_t rocksdb_subcompactionjobinfo_blob_compression_type( + const rocksdb_subcompactionjobinfo_t* info) { + return static_cast(info->rep.blob_compression_type); +} + +/* ExternalFileIngestionInfo */ + +const char* rocksdb_externalfileingestioninfo_cf_name( + const rocksdb_externalfileingestioninfo_t* info, size_t* size) { + *size = info->rep.cf_name.size(); + return info->rep.cf_name.data(); +} + +const char* rocksdb_externalfileingestioninfo_external_file_path( + const rocksdb_externalfileingestioninfo_t* info, size_t* size) { + *size = info->rep.external_file_path.size(); + return info->rep.external_file_path.data(); +} + +const char* rocksdb_externalfileingestioninfo_internal_file_path( + const rocksdb_externalfileingestioninfo_t* info, size_t* size) { + *size = info->rep.internal_file_path.size(); + return info->rep.internal_file_path.data(); +} + +uint64_t rocksdb_externalfileingestioninfo_global_seqno( + const rocksdb_externalfileingestioninfo_t* info) { + return info->rep.global_seqno; +} + +/* MemTableInfo */ + +const char* rocksdb_memtableinfo_cf_name(const rocksdb_memtableinfo_t* info, + size_t* size) { + *size = info->rep.cf_name.size(); + return info->rep.cf_name.data(); +} + +uint64_t rocksdb_memtableinfo_first_seqno(const rocksdb_memtableinfo_t* info) { + return info->rep.first_seqno; +} + +uint64_t rocksdb_memtableinfo_earliest_seqno( + const rocksdb_memtableinfo_t* info) { + return info->rep.earliest_seqno; +} + +uint64_t rocksdb_memtableinfo_num_entries(const rocksdb_memtableinfo_t* info) { + return info->rep.num_entries; +} + +uint64_t rocksdb_memtableinfo_num_deletes(const rocksdb_memtableinfo_t* info) { + return info->rep.num_deletes; +} + +const char* rocksdb_memtableinfo_newest_udt(const rocksdb_memtableinfo_t* info, + size_t* size) { + *size = info->rep.newest_udt.size(); + return info->rep.newest_udt.data(); +} +// END generated: c_generated_jobinfo_auto.cc.inc +// BEGIN generated: c_generated_jobinfo_metadata_subset.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'JobInfo metadata simple' +// --header-out +// c_api_gen/c_generated_jobinfo_metadata_subset.h.inc +// --source-out +// c_api_gen/c_generated_jobinfo_metadata_subset.cc.inc + +/* JobInfo metadata simple */ + +size_t rocksdb_compactionjobinfo_input_files_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.input_files.size(); +} + +size_t rocksdb_compactionjobinfo_output_files_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.output_files.size(); +} + +uint64_t rocksdb_compactionjobinfo_elapsed_micros( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.elapsed_micros; +} + +uint64_t rocksdb_compactionjobinfo_num_corrupt_keys( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.num_corrupt_keys; } uint64_t rocksdb_compactionjobinfo_input_records( @@ -3988,61 +4780,18 @@ uint64_t rocksdb_compactionjobinfo_total_output_bytes( return info->rep.stats.total_output_bytes; } -uint32_t rocksdb_compactionjobinfo_compaction_reason( +size_t rocksdb_compactionjobinfo_num_input_files( const rocksdb_compactionjobinfo_t* info) { - return static_cast(info->rep.compaction_reason); + return info->rep.stats.num_input_files; } -/* SubcompactionJobInfo */ - -void rocksdb_subcompactionjobinfo_status( - const rocksdb_subcompactionjobinfo_t* info, char** errptr) { - SaveError(errptr, info->rep.status); +size_t rocksdb_compactionjobinfo_num_input_files_at_output_level( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.stats.num_input_files_at_output_level; } -const char* rocksdb_subcompactionjobinfo_cf_name( - const rocksdb_subcompactionjobinfo_t* info, size_t* size) { - *size = info->rep.cf_name.size(); - return info->rep.cf_name.data(); -} - -uint64_t rocksdb_subcompactionjobinfo_thread_id( - const rocksdb_subcompactionjobinfo_t* info) { - return info->rep.thread_id; -} - -int rocksdb_subcompactionjobinfo_base_input_level( - const rocksdb_subcompactionjobinfo_t* info) { - return info->rep.base_input_level; -} - -int rocksdb_subcompactionjobinfo_output_level( - const rocksdb_subcompactionjobinfo_t* info) { - return info->rep.output_level; -} - -uint32_t rocksdb_subcompactionjobinfo_compaction_reason( - const rocksdb_subcompactionjobinfo_t* info) { - return static_cast(info->rep.compaction_reason); -} - -/* ExternalFileIngestionInfo */ - -const char* rocksdb_externalfileingestioninfo_cf_name( - const rocksdb_externalfileingestioninfo_t* info, size_t* size) { - *size = info->rep.cf_name.size(); - return info->rep.cf_name.data(); -} - -const char* rocksdb_externalfileingestioninfo_internal_file_path( - const rocksdb_externalfileingestioninfo_t* info, size_t* size) { - *size = info->rep.internal_file_path.size(); - return info->rep.internal_file_path.data(); -} - -/* External write stall info */ -extern ROCKSDB_LIBRARY_API const char* rocksdb_writestallinfo_cf_name( - const rocksdb_writestallinfo_t* info, size_t* size) { +const char* rocksdb_writestallinfo_cf_name(const rocksdb_writestallinfo_t* info, + size_t* size) { *size = info->rep.cf_name.size(); return info->rep.cf_name.data(); } @@ -4058,25 +4807,760 @@ const rocksdb_writestallcondition_t* rocksdb_writestallinfo_prev( return reinterpret_cast( &info->rep.condition.prev); } +// END generated: c_generated_jobinfo_metadata_subset.cc.inc +// BEGIN generated: c_generated_metadata_structs_auto.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/compaction_job_stats.h +// - include/rocksdb/listener.h +// - include/rocksdb/table_properties.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- -const char* rocksdb_memtableinfo_cf_name(const rocksdb_memtableinfo_t* info, - size_t* size) { - *size = info->rep.cf_name.size(); - return info->rep.cf_name.data(); +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered metadata view structs simple + +/* TableProperties */ + +uint64_t rocksdb_table_properties_orig_file_number( + const rocksdb_table_properties_t* props) { + return props->rep.orig_file_number; } -uint64_t rocksdb_memtableinfo_first_seqno(const rocksdb_memtableinfo_t* info) { - return info->rep.first_seqno; +uint64_t rocksdb_table_properties_data_size( + const rocksdb_table_properties_t* props) { + return props->rep.data_size; } -uint64_t rocksdb_memtableinfo_earliest_seqno( - const rocksdb_memtableinfo_t* info) { - return info->rep.earliest_seqno; + +uint64_t rocksdb_table_properties_uncompressed_data_size( + const rocksdb_table_properties_t* props) { + return props->rep.uncompressed_data_size; } -uint64_t rocksdb_memtableinfo_num_entries(const rocksdb_memtableinfo_t* info) { - return info->rep.num_entries; + +uint64_t rocksdb_table_properties_index_size( + const rocksdb_table_properties_t* props) { + return props->rep.index_size; } -uint64_t rocksdb_memtableinfo_num_deletes(const rocksdb_memtableinfo_t* info) { - return info->rep.num_deletes; + +uint64_t rocksdb_table_properties_index_partitions( + const rocksdb_table_properties_t* props) { + return props->rep.index_partitions; +} + +uint64_t rocksdb_table_properties_top_level_index_size( + const rocksdb_table_properties_t* props) { + return props->rep.top_level_index_size; +} + +uint64_t rocksdb_table_properties_index_key_is_user_key( + const rocksdb_table_properties_t* props) { + return props->rep.index_key_is_user_key; +} + +uint64_t rocksdb_table_properties_index_value_is_delta_encoded( + const rocksdb_table_properties_t* props) { + return props->rep.index_value_is_delta_encoded; +} + +uint64_t rocksdb_table_properties_udi_is_primary_index( + const rocksdb_table_properties_t* props) { + return props->rep.udi_is_primary_index; +} + +uint64_t rocksdb_table_properties_filter_size( + const rocksdb_table_properties_t* props) { + return props->rep.filter_size; +} + +uint64_t rocksdb_table_properties_raw_key_size( + const rocksdb_table_properties_t* props) { + return props->rep.raw_key_size; +} + +uint64_t rocksdb_table_properties_raw_value_size( + const rocksdb_table_properties_t* props) { + return props->rep.raw_value_size; +} + +uint64_t rocksdb_table_properties_num_data_blocks( + const rocksdb_table_properties_t* props) { + return props->rep.num_data_blocks; +} + +uint64_t rocksdb_table_properties_num_data_blocks_compression_rejected( + const rocksdb_table_properties_t* props) { + return props->rep.num_data_blocks_compression_rejected; +} + +uint64_t rocksdb_table_properties_num_data_blocks_compression_bypassed( + const rocksdb_table_properties_t* props) { + return props->rep.num_data_blocks_compression_bypassed; +} + +uint64_t rocksdb_table_properties_num_uniform_blocks( + const rocksdb_table_properties_t* props) { + return props->rep.num_uniform_blocks; +} + +uint64_t rocksdb_table_properties_num_entries( + const rocksdb_table_properties_t* props) { + return props->rep.num_entries; +} + +uint64_t rocksdb_table_properties_num_filter_entries( + const rocksdb_table_properties_t* props) { + return props->rep.num_filter_entries; +} + +uint64_t rocksdb_table_properties_num_deletions( + const rocksdb_table_properties_t* props) { + return props->rep.num_deletions; +} + +uint64_t rocksdb_table_properties_num_merge_operands( + const rocksdb_table_properties_t* props) { + return props->rep.num_merge_operands; +} + +uint64_t rocksdb_table_properties_num_range_deletions( + const rocksdb_table_properties_t* props) { + return props->rep.num_range_deletions; +} + +uint64_t rocksdb_table_properties_format_version( + const rocksdb_table_properties_t* props) { + return props->rep.format_version; +} + +uint64_t rocksdb_table_properties_fixed_key_len( + const rocksdb_table_properties_t* props) { + return props->rep.fixed_key_len; +} + +uint64_t rocksdb_table_properties_column_family_id( + const rocksdb_table_properties_t* props) { + return props->rep.column_family_id; +} + +uint64_t rocksdb_table_properties_creation_time( + const rocksdb_table_properties_t* props) { + return props->rep.creation_time; +} + +uint64_t rocksdb_table_properties_oldest_key_time( + const rocksdb_table_properties_t* props) { + return props->rep.oldest_key_time; +} + +uint64_t rocksdb_table_properties_newest_key_time( + const rocksdb_table_properties_t* props) { + return props->rep.newest_key_time; +} + +uint64_t rocksdb_table_properties_file_creation_time( + const rocksdb_table_properties_t* props) { + return props->rep.file_creation_time; +} + +uint64_t rocksdb_table_properties_slow_compression_estimated_data_size( + const rocksdb_table_properties_t* props) { + return props->rep.slow_compression_estimated_data_size; +} + +uint64_t rocksdb_table_properties_fast_compression_estimated_data_size( + const rocksdb_table_properties_t* props) { + return props->rep.fast_compression_estimated_data_size; +} + +uint64_t rocksdb_table_properties_external_sst_file_global_seqno_offset( + const rocksdb_table_properties_t* props) { + return props->rep.external_sst_file_global_seqno_offset; +} + +uint64_t rocksdb_table_properties_tail_start_offset( + const rocksdb_table_properties_t* props) { + return props->rep.tail_start_offset; +} + +uint64_t rocksdb_table_properties_user_defined_timestamps_persisted( + const rocksdb_table_properties_t* props) { + return props->rep.user_defined_timestamps_persisted; +} + +uint64_t rocksdb_table_properties_key_largest_seqno( + const rocksdb_table_properties_t* props) { + return props->rep.key_largest_seqno; +} + +uint64_t rocksdb_table_properties_key_smallest_seqno( + const rocksdb_table_properties_t* props) { + return props->rep.key_smallest_seqno; +} + +uint64_t rocksdb_table_properties_data_block_restart_interval( + const rocksdb_table_properties_t* props) { + return props->rep.data_block_restart_interval; +} + +uint64_t rocksdb_table_properties_index_block_restart_interval( + const rocksdb_table_properties_t* props) { + return props->rep.index_block_restart_interval; +} + +uint64_t rocksdb_table_properties_separate_key_value_in_data_block( + const rocksdb_table_properties_t* props) { + return props->rep.separate_key_value_in_data_block; +} + +const char* rocksdb_table_properties_db_id( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.db_id.size(); + return props->rep.db_id.data(); +} + +const char* rocksdb_table_properties_db_session_id( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.db_session_id.size(); + return props->rep.db_session_id.data(); +} + +const char* rocksdb_table_properties_db_host_id( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.db_host_id.size(); + return props->rep.db_host_id.data(); +} + +const char* rocksdb_table_properties_column_family_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.column_family_name.size(); + return props->rep.column_family_name.data(); +} + +const char* rocksdb_table_properties_filter_policy_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.filter_policy_name.size(); + return props->rep.filter_policy_name.data(); +} + +const char* rocksdb_table_properties_comparator_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.comparator_name.size(); + return props->rep.comparator_name.data(); +} + +const char* rocksdb_table_properties_merge_operator_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.merge_operator_name.size(); + return props->rep.merge_operator_name.data(); +} + +const char* rocksdb_table_properties_prefix_extractor_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.prefix_extractor_name.size(); + return props->rep.prefix_extractor_name.data(); +} + +const char* rocksdb_table_properties_property_collectors_names( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.property_collectors_names.size(); + return props->rep.property_collectors_names.data(); +} + +const char* rocksdb_table_properties_compression_name( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.compression_name.size(); + return props->rep.compression_name.data(); +} + +const char* rocksdb_table_properties_compression_options( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.compression_options.size(); + return props->rep.compression_options.data(); +} + +const char* rocksdb_table_properties_seqno_to_time_mapping( + const rocksdb_table_properties_t* props, size_t* size) { + *size = props->rep.seqno_to_time_mapping.size(); + return props->rep.seqno_to_time_mapping.data(); +} + +/* CompactionJobStats */ + +uint64_t rocksdb_compaction_job_stats_elapsed_micros( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.elapsed_micros; +} + +uint64_t rocksdb_compaction_job_stats_cpu_micros( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.cpu_micros; +} + +unsigned char rocksdb_compaction_job_stats_has_accurate_num_input_records( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.has_accurate_num_input_records; +} + +uint64_t rocksdb_compaction_job_stats_num_input_records( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_input_records; +} + +uint64_t rocksdb_compaction_job_stats_num_blobs_read( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_blobs_read; +} + +size_t rocksdb_compaction_job_stats_num_input_files( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_input_files; +} + +size_t rocksdb_compaction_job_stats_num_input_files_trivially_moved( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_input_files_trivially_moved; +} + +size_t rocksdb_compaction_job_stats_num_input_files_at_output_level( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_input_files_at_output_level; +} + +size_t rocksdb_compaction_job_stats_num_filtered_input_files( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_filtered_input_files; +} + +size_t rocksdb_compaction_job_stats_num_filtered_input_files_at_output_level( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_filtered_input_files_at_output_level; +} + +uint64_t rocksdb_compaction_job_stats_num_output_records( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_output_records; +} + +size_t rocksdb_compaction_job_stats_num_output_files( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_output_files; +} + +size_t rocksdb_compaction_job_stats_num_output_files_blob( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_output_files_blob; +} + +unsigned char rocksdb_compaction_job_stats_is_full_compaction( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.is_full_compaction; +} + +unsigned char rocksdb_compaction_job_stats_is_manual_compaction( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.is_manual_compaction; +} + +unsigned char rocksdb_compaction_job_stats_is_remote_compaction( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.is_remote_compaction; +} + +uint64_t rocksdb_compaction_job_stats_total_input_bytes( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_input_bytes; +} + +uint64_t rocksdb_compaction_job_stats_total_blob_bytes_read( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_blob_bytes_read; +} + +uint64_t rocksdb_compaction_job_stats_total_output_bytes( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_output_bytes; +} + +uint64_t rocksdb_compaction_job_stats_total_output_bytes_blob( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_output_bytes_blob; +} + +uint64_t rocksdb_compaction_job_stats_total_skipped_input_bytes( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_skipped_input_bytes; +} + +uint64_t rocksdb_compaction_job_stats_num_records_replaced( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_records_replaced; +} + +uint64_t rocksdb_compaction_job_stats_total_input_raw_key_bytes( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_input_raw_key_bytes; +} + +uint64_t rocksdb_compaction_job_stats_total_input_raw_value_bytes( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.total_input_raw_value_bytes; +} + +uint64_t rocksdb_compaction_job_stats_num_input_deletion_records( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_input_deletion_records; +} + +uint64_t rocksdb_compaction_job_stats_num_expired_deletion_records( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_expired_deletion_records; +} + +uint64_t rocksdb_compaction_job_stats_num_corrupt_keys( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_corrupt_keys; +} + +uint64_t rocksdb_compaction_job_stats_file_write_nanos( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.file_write_nanos; +} + +uint64_t rocksdb_compaction_job_stats_file_range_sync_nanos( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.file_range_sync_nanos; +} + +uint64_t rocksdb_compaction_job_stats_file_fsync_nanos( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.file_fsync_nanos; +} + +uint64_t rocksdb_compaction_job_stats_file_prepare_write_nanos( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.file_prepare_write_nanos; +} + +const char* rocksdb_compaction_job_stats_smallest_output_key_prefix( + const rocksdb_compaction_job_stats_t* stats, size_t* size) { + *size = stats->rep.smallest_output_key_prefix.size(); + return stats->rep.smallest_output_key_prefix.data(); +} + +const char* rocksdb_compaction_job_stats_largest_output_key_prefix( + const rocksdb_compaction_job_stats_t* stats, size_t* size) { + *size = stats->rep.largest_output_key_prefix.size(); + return stats->rep.largest_output_key_prefix.data(); +} + +uint64_t rocksdb_compaction_job_stats_num_single_del_fallthru( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_single_del_fallthru; +} + +uint64_t rocksdb_compaction_job_stats_num_single_del_mismatch( + const rocksdb_compaction_job_stats_t* stats) { + return stats->rep.num_single_del_mismatch; +} + +/* CompactionFileInfo */ + +int rocksdb_compaction_file_info_level( + const rocksdb_compaction_file_info_t* info) { + return info->rep.level; +} + +uint64_t rocksdb_compaction_file_info_file_number( + const rocksdb_compaction_file_info_t* info) { + return info->rep.file_number; +} + +uint64_t rocksdb_compaction_file_info_oldest_blob_file_number( + const rocksdb_compaction_file_info_t* info) { + return info->rep.oldest_blob_file_number; +} + +/* BlobFileAdditionInfo */ + +uint64_t rocksdb_blob_file_addition_info_total_blob_count( + const rocksdb_blob_file_addition_info_t* info) { + return info->rep.total_blob_count; +} + +uint64_t rocksdb_blob_file_addition_info_total_blob_bytes( + const rocksdb_blob_file_addition_info_t* info) { + return info->rep.total_blob_bytes; +} + +/* BlobFileGarbageInfo */ + +uint64_t rocksdb_blob_file_garbage_info_garbage_blob_count( + const rocksdb_blob_file_garbage_info_t* info) { + return info->rep.garbage_blob_count; +} + +uint64_t rocksdb_blob_file_garbage_info_garbage_blob_bytes( + const rocksdb_blob_file_garbage_info_t* info) { + return info->rep.garbage_blob_bytes; +} +// END generated: c_generated_metadata_structs_auto.cc.inc + +rocksdb_compactionjobinfo_t* rocksdb_compactionjobinfo_create() { + return new rocksdb_compactionjobinfo_t; +} + +void rocksdb_compactionjobinfo_destroy(rocksdb_compactionjobinfo_t* info) { + delete info; +} + +void rocksdb_reset_status(rocksdb_status_ptr_t* status_ptr) { + auto ptr = status_ptr->rep; + *ptr = Status::OK(); +} + +unsigned char rocksdb_table_properties_has_key_largest_seqno( + const rocksdb_table_properties_t* props) { + return props->rep.HasKeyLargestSeqno(); +} + +unsigned char rocksdb_table_properties_has_key_smallest_seqno( + const rocksdb_table_properties_t* props) { + return props->rep.HasKeySmallestSeqno(); +} + +size_t rocksdb_table_properties_user_collected_properties_count( + const rocksdb_table_properties_t* props) { + return props->rep.user_collected_properties.size(); +} + +const char* rocksdb_table_properties_user_collected_properties_key_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* key_len) { + const auto it = GetMapEntryAt(props->rep.user_collected_properties, pos); + if (it == props->rep.user_collected_properties.cend()) { + if (key_len != nullptr) { + *key_len = 0; + } + return nullptr; + } + if (key_len != nullptr) { + *key_len = it->first.size(); + } + return it->first.data(); +} + +const char* rocksdb_table_properties_user_collected_properties_value_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* value_len) { + const auto it = GetMapEntryAt(props->rep.user_collected_properties, pos); + if (it == props->rep.user_collected_properties.cend()) { + if (value_len != nullptr) { + *value_len = 0; + } + return nullptr; + } + if (value_len != nullptr) { + *value_len = it->second.size(); + } + return it->second.data(); +} + +size_t rocksdb_table_properties_readable_properties_count( + const rocksdb_table_properties_t* props) { + return props->rep.readable_properties.size(); +} + +const char* rocksdb_table_properties_readable_properties_key_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* key_len) { + const auto it = GetMapEntryAt(props->rep.readable_properties, pos); + if (it == props->rep.readable_properties.cend()) { + if (key_len != nullptr) { + *key_len = 0; + } + return nullptr; + } + if (key_len != nullptr) { + *key_len = it->first.size(); + } + return it->first.data(); +} + +const char* rocksdb_table_properties_readable_properties_value_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* value_len) { + const auto it = GetMapEntryAt(props->rep.readable_properties, pos); + if (it == props->rep.readable_properties.cend()) { + if (value_len != nullptr) { + *value_len = 0; + } + return nullptr; + } + if (value_len != nullptr) { + *value_len = it->second.size(); + } + return it->second.data(); +} + +const rocksdb_table_properties_t* rocksdb_flushjobinfo_table_properties( + const rocksdb_flushjobinfo_t* info) { + return reinterpret_cast( + &info->rep.table_properties); +} + +size_t rocksdb_flushjobinfo_blob_file_addition_infos_count( + const rocksdb_flushjobinfo_t* info) { + return info->rep.blob_file_addition_infos.size(); +} + +const rocksdb_blob_file_addition_info_t* +rocksdb_flushjobinfo_blob_file_addition_info_at( + const rocksdb_flushjobinfo_t* info, size_t pos) { + assert(pos < info->rep.blob_file_addition_infos.size()); + return reinterpret_cast( + &info->rep.blob_file_addition_infos[pos]); +} + +/* CompactionJobInfo */ + +const char* rocksdb_compactionjobinfo_input_file_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size) { + assert(info != nullptr); + assert(pos < info->rep.input_files.size()); + + const std::string& path = info->rep.input_files[pos]; + *size = path.size(); + return path.data(); +} + +const char* rocksdb_compactionjobinfo_output_file_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size) { + assert(info != nullptr); + assert(pos < info->rep.output_files.size()); + + const std::string& path = info->rep.output_files[pos]; + *size = path.size(); + return path.data(); +} + +const rocksdb_compaction_job_stats_t* rocksdb_compactionjobinfo_stats( + const rocksdb_compactionjobinfo_t* info) { + return reinterpret_cast( + &info->rep.stats); +} + +size_t rocksdb_compactionjobinfo_input_file_infos_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.input_file_infos.size(); +} + +const rocksdb_compaction_file_info_t* +rocksdb_compactionjobinfo_input_file_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos) { + assert(pos < info->rep.input_file_infos.size()); + return reinterpret_cast( + &info->rep.input_file_infos[pos]); +} + +size_t rocksdb_compactionjobinfo_output_file_infos_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.output_file_infos.size(); +} + +const rocksdb_compaction_file_info_t* +rocksdb_compactionjobinfo_output_file_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos) { + assert(pos < info->rep.output_file_infos.size()); + return reinterpret_cast( + &info->rep.output_file_infos[pos]); +} + +size_t rocksdb_compactionjobinfo_table_properties_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.table_properties.size(); +} + +const char* rocksdb_compactionjobinfo_table_properties_key_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* key_len) { + const auto it = GetMapEntryAt(info->rep.table_properties, pos); + if (it == info->rep.table_properties.cend()) { + if (key_len != nullptr) { + *key_len = 0; + } + return nullptr; + } + if (key_len != nullptr) { + *key_len = it->first.size(); + } + return it->first.data(); +} + +const rocksdb_table_properties_t* +rocksdb_compactionjobinfo_table_properties_value_at( + const rocksdb_compactionjobinfo_t* info, size_t pos) { + const auto it = GetMapEntryAt(info->rep.table_properties, pos); + if (it == info->rep.table_properties.cend()) { + return nullptr; + } + return reinterpret_cast(it->second.get()); +} + +const rocksdb_table_properties_t* +rocksdb_compactionjobinfo_table_properties_for_file( + const rocksdb_compactionjobinfo_t* info, const char* file_name, + size_t file_name_len) { + const auto it = + info->rep.table_properties.find(std::string(file_name, file_name_len)); + if (it == info->rep.table_properties.end()) { + return nullptr; + } + return reinterpret_cast(it->second.get()); +} + +size_t rocksdb_compactionjobinfo_blob_file_addition_infos_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.blob_file_addition_infos.size(); +} + +const rocksdb_blob_file_addition_info_t* +rocksdb_compactionjobinfo_blob_file_addition_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos) { + assert(pos < info->rep.blob_file_addition_infos.size()); + return reinterpret_cast( + &info->rep.blob_file_addition_infos[pos]); +} + +size_t rocksdb_compactionjobinfo_blob_file_garbage_infos_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.blob_file_garbage_infos.size(); +} + +const rocksdb_blob_file_garbage_info_t* +rocksdb_compactionjobinfo_blob_file_garbage_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos) { + assert(pos < info->rep.blob_file_garbage_infos.size()); + return reinterpret_cast( + &info->rep.blob_file_garbage_infos[pos]); +} + +/* SubcompactionJobInfo */ + +const rocksdb_compaction_job_stats_t* rocksdb_subcompactionjobinfo_stats( + const rocksdb_subcompactionjobinfo_t* info) { + return reinterpret_cast( + &info->rep.stats); +} + +/* ExternalFileIngestionInfo */ + +const rocksdb_table_properties_t* +rocksdb_externalfileingestioninfo_table_properties( + const rocksdb_externalfileingestioninfo_t* info) { + return reinterpret_cast( + &info->rep.table_properties); } /* event listener */ @@ -4224,30 +5708,29 @@ void rocksdb_cuckoo_options_destroy(rocksdb_cuckoo_table_options_t* options) { delete options; } +// BEGIN generated: c_generated_cuckoo_options_subset.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'CuckooOptions simple' +// --header-out +// c_api_gen/c_generated_cuckoo_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_cuckoo_options_subset.cc.inc + +/* CuckooOptions simple */ + void rocksdb_cuckoo_options_set_hash_ratio( rocksdb_cuckoo_table_options_t* options, double v) { options->rep.hash_table_ratio = v; } - -void rocksdb_cuckoo_options_set_max_search_depth( - rocksdb_cuckoo_table_options_t* options, uint32_t v) { - options->rep.max_search_depth = v; -} - -void rocksdb_cuckoo_options_set_cuckoo_block_size( - rocksdb_cuckoo_table_options_t* options, uint32_t v) { - options->rep.cuckoo_block_size = v; -} - -void rocksdb_cuckoo_options_set_identity_as_first_hash( - rocksdb_cuckoo_table_options_t* options, unsigned char v) { - options->rep.identity_as_first_hash = v; -} - -void rocksdb_cuckoo_options_set_use_module_hash( - rocksdb_cuckoo_table_options_t* options, unsigned char v) { - options->rep.use_module_hash = v; -} +// END generated: c_generated_cuckoo_options_subset.cc.inc void rocksdb_options_set_cuckoo_table_factory( rocksdb_options_t* opt, rocksdb_cuckoo_table_options_t* table_options) { @@ -4314,15 +5797,6 @@ void rocksdb_options_optimize_universal_style_compaction( opt->rep.OptimizeUniversalStyleCompaction(memtable_memory_budget); } -void rocksdb_options_set_allow_ingest_behind(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.allow_ingest_behind = v; -} - -unsigned char rocksdb_options_get_allow_ingest_behind(rocksdb_options_t* opt) { - return opt->rep.allow_ingest_behind; -} - void rocksdb_options_set_compaction_filter(rocksdb_options_t* opt, rocksdb_compactionfilter_t* filter) { opt->rep.compaction_filter = filter; @@ -4334,15 +5808,6 @@ void rocksdb_options_set_compaction_filter_factory( std::shared_ptr(factory); } -void rocksdb_options_compaction_readahead_size(rocksdb_options_t* opt, - size_t s) { - opt->rep.compaction_readahead_size = s; -} - -size_t rocksdb_options_get_compaction_readahead_size(rocksdb_options_t* opt) { - return opt->rep.compaction_readahead_size; -} - void rocksdb_options_set_comparator(rocksdb_options_t* opt, rocksdb_comparator_t* cmp) { opt->rep.comparator = cmp; @@ -4353,50 +5818,167 @@ void rocksdb_options_set_merge_operator( opt->rep.merge_operator = std::shared_ptr(merge_operator); } -void rocksdb_options_set_create_if_missing(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.create_if_missing = v; +void rocksdb_options_set_wal_filter(rocksdb_options_t* opt, + rocksdb_walfilter_t* filter) { + opt->rep.wal_filter = filter; } -unsigned char rocksdb_options_get_create_if_missing(rocksdb_options_t* opt) { - return opt->rep.create_if_missing; +void rocksdb_options_clear_wal_filter(rocksdb_options_t* opt) { + opt->rep.wal_filter = nullptr; } -void rocksdb_options_set_create_missing_column_families(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.create_missing_column_families = v; +// BEGIN generated: c_generated_options_subset.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'Options simple' +// --header-out +// c_api_gen/c_generated_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_options_subset.cc.inc + +/* Options simple */ + +void rocksdb_options_set_compression_options_zstd_max_train_bytes( + rocksdb_options_t* opt, int zstd_max_train_bytes) { + opt->rep.compression_opts.zstd_max_train_bytes = zstd_max_train_bytes; } -unsigned char rocksdb_options_get_create_missing_column_families( +int rocksdb_options_get_compression_options_zstd_max_train_bytes( rocksdb_options_t* opt) { - return opt->rep.create_missing_column_families; + return opt->rep.compression_opts.zstd_max_train_bytes; } -void rocksdb_options_set_error_if_exists(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.error_if_exists = v; +void rocksdb_options_set_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer) { + opt->rep.compression_opts.use_zstd_dict_trainer = use_zstd_dict_trainer; } -unsigned char rocksdb_options_get_error_if_exists(rocksdb_options_t* opt) { - return opt->rep.error_if_exists; +unsigned char rocksdb_options_get_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt) { + return opt->rep.compression_opts.use_zstd_dict_trainer; } -void rocksdb_options_set_paranoid_checks(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.paranoid_checks = v; +void rocksdb_options_set_compression_options_parallel_threads( + rocksdb_options_t* opt, int value) { + opt->rep.compression_opts.parallel_threads = value; } -unsigned char rocksdb_options_get_paranoid_checks(rocksdb_options_t* opt) { - return opt->rep.paranoid_checks; +int rocksdb_options_get_compression_options_parallel_threads( + rocksdb_options_t* opt) { + return opt->rep.compression_opts.parallel_threads; } -void rocksdb_options_set_open_files_async(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.open_files_async = v; +void rocksdb_options_set_compression_options_max_dict_buffer_bytes( + rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes) { + opt->rep.compression_opts.max_dict_buffer_bytes = max_dict_buffer_bytes; } -unsigned char rocksdb_options_get_open_files_async(rocksdb_options_t* opt) { - return opt->rep.open_files_async; +uint64_t rocksdb_options_get_compression_options_max_dict_buffer_bytes( + rocksdb_options_t* opt) { + return opt->rep.compression_opts.max_dict_buffer_bytes; +} + +unsigned char +rocksdb_options_get_bottommost_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt) { + return opt->rep.bottommost_compression_opts.use_zstd_dict_trainer; +} + +void rocksdb_options_set_use_fsync(rocksdb_options_t* opt, int use_fsync) { + opt->rep.use_fsync = use_fsync; +} + +int rocksdb_options_get_use_fsync(rocksdb_options_t* opt) { + return opt->rep.use_fsync; +} + +void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt, + int disable) { + opt->rep.disable_auto_compactions = disable; +} + +void rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t* opt, + int v) { + opt->rep.optimize_filters_for_hits = v; +} + +void rocksdb_options_set_report_bg_io_stats(rocksdb_options_t* opt, int v) { + opt->rep.report_bg_io_stats = v; +} +// END generated: c_generated_options_subset.cc.inc + +void rocksdb_options_set_compression_per_level(rocksdb_options_t* opt, + const int* level_values, + size_t num_levels) { + opt->rep.compression_per_level.resize(num_levels); + for (size_t i = 0; i < num_levels; ++i) { + opt->rep.compression_per_level[i] = + static_cast(level_values[i]); + } +} + +void rocksdb_options_set_compression_options(rocksdb_options_t* opt, int w_bits, + int level, int strategy, + int max_dict_bytes) { + opt->rep.compression_opts.window_bits = w_bits; + opt->rep.compression_opts.level = level; + opt->rep.compression_opts.strategy = strategy; + opt->rep.compression_opts.max_dict_bytes = max_dict_bytes; +} + +// The bottommost_compression_opts setters below each write multiple fields of +// the nested CompressionOptions struct (and flip `enabled`), so they cannot be +// auto-generated as simple scalar field wrappers and are kept hand-written. +void rocksdb_options_set_bottommost_compression_options(rocksdb_options_t* opt, + int w_bits, int level, + int strategy, + int max_dict_bytes, + unsigned char enabled) { + opt->rep.bottommost_compression_opts.window_bits = w_bits; + opt->rep.bottommost_compression_opts.level = level; + opt->rep.bottommost_compression_opts.strategy = strategy; + opt->rep.bottommost_compression_opts.max_dict_bytes = max_dict_bytes; + opt->rep.bottommost_compression_opts.enabled = enabled; +} + +void rocksdb_options_set_bottommost_compression_options_zstd_max_train_bytes( + rocksdb_options_t* opt, int zstd_max_train_bytes, unsigned char enabled) { + opt->rep.bottommost_compression_opts.zstd_max_train_bytes = + zstd_max_train_bytes; + opt->rep.bottommost_compression_opts.enabled = enabled; +} + +void rocksdb_options_set_bottommost_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer, + unsigned char enabled) { + opt->rep.bottommost_compression_opts.use_zstd_dict_trainer = + use_zstd_dict_trainer; + opt->rep.bottommost_compression_opts.enabled = enabled; +} + +void rocksdb_options_set_bottommost_compression_options_max_dict_buffer_bytes( + rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes, + unsigned char enabled) { + opt->rep.bottommost_compression_opts.max_dict_buffer_bytes = + max_dict_buffer_bytes; + opt->rep.bottommost_compression_opts.enabled = enabled; +} + +// Takes a caller-owned array of per-level values, so it is hand-written rather +// than auto-generated. +void rocksdb_options_set_max_bytes_for_level_multiplier_additional( + rocksdb_options_t* opt, int* level_values, size_t num_levels) { + opt->rep.max_bytes_for_level_multiplier_additional.resize(num_levels); + for (size_t i = 0; i < num_levels; ++i) { + opt->rep.max_bytes_for_level_multiplier_additional[i] = level_values[i]; + } } void rocksdb_options_set_db_paths(rocksdb_options_t* opt, @@ -4467,6 +6049,59 @@ void rocksdb_options_set_file_checksum_gen_factory( } } +void rocksdb_options_checksum_handoff_file_types_clear(rocksdb_options_t* opt) { + opt->rep.checksum_handoff_file_types = {}; +} + +void rocksdb_options_checksum_handoff_file_types_add(rocksdb_options_t* opt, + int file_type) { + opt->rep.checksum_handoff_file_types.Add(static_cast(file_type)); +} + +void rocksdb_options_checksum_handoff_file_types_remove(rocksdb_options_t* opt, + int file_type) { + opt->rep.checksum_handoff_file_types.Remove(static_cast(file_type)); +} + +unsigned char rocksdb_options_checksum_handoff_file_types_contains( + rocksdb_options_t* opt, int file_type) { + return opt->rep.checksum_handoff_file_types.Contains( + static_cast(file_type)); +} + +size_t rocksdb_options_checksum_handoff_file_types_count( + rocksdb_options_t* opt) { + return opt->rep.checksum_handoff_file_types.count(); +} + +void rocksdb_options_calculate_sst_write_lifetime_hint_set_clear( + rocksdb_options_t* opt) { + opt->rep.calculate_sst_write_lifetime_hint_set = {}; +} + +void rocksdb_options_calculate_sst_write_lifetime_hint_set_add( + rocksdb_options_t* opt, int compaction_style) { + opt->rep.calculate_sst_write_lifetime_hint_set.Add( + static_cast(compaction_style)); +} + +void rocksdb_options_calculate_sst_write_lifetime_hint_set_remove( + rocksdb_options_t* opt, int compaction_style) { + opt->rep.calculate_sst_write_lifetime_hint_set.Remove( + static_cast(compaction_style)); +} + +unsigned char rocksdb_options_calculate_sst_write_lifetime_hint_set_contains( + rocksdb_options_t* opt, int compaction_style) { + return opt->rep.calculate_sst_write_lifetime_hint_set.Contains( + static_cast(compaction_style)); +} + +size_t rocksdb_options_calculate_sst_write_lifetime_hint_set_count( + rocksdb_options_t* opt) { + return opt->rep.calculate_sst_write_lifetime_hint_set.count(); +} + /* SST Partitioner Factory */ rocksdb_sst_partitioner_factory_t* @@ -4520,27 +6155,6 @@ rocksdb_logger_t* rocksdb_options_get_info_log(rocksdb_options_t* opt) { return info_log; } -void rocksdb_options_set_info_log_level(rocksdb_options_t* opt, int v) { - opt->rep.info_log_level = static_cast(v); -} - -int rocksdb_options_get_info_log_level(rocksdb_options_t* opt) { - return static_cast(opt->rep.info_log_level); -} - -void rocksdb_options_set_db_write_buffer_size(rocksdb_options_t* opt, - size_t s) { - opt->rep.db_write_buffer_size = s; -} - -size_t rocksdb_options_get_db_write_buffer_size(rocksdb_options_t* opt) { - return opt->rep.db_write_buffer_size; -} - -void rocksdb_options_set_write_buffer_size(rocksdb_options_t* opt, size_t s) { - opt->rep.write_buffer_size = s; -} - void rocksdb_options_set_write_buffer_manager( rocksdb_options_t* opt, rocksdb_write_buffer_manager_t* wbm) { opt->rep.write_buffer_manager = wbm->rep; @@ -4551,148 +6165,6 @@ void rocksdb_options_set_sst_file_manager(rocksdb_options_t* opt, opt->rep.sst_file_manager = sfm->rep; } -size_t rocksdb_options_get_write_buffer_size(rocksdb_options_t* opt) { - return opt->rep.write_buffer_size; -} - -void rocksdb_options_set_max_open_files(rocksdb_options_t* opt, int n) { - opt->rep.max_open_files = n; -} - -int rocksdb_options_get_max_open_files(rocksdb_options_t* opt) { - return opt->rep.max_open_files; -} - -void rocksdb_options_set_max_file_opening_threads(rocksdb_options_t* opt, - int n) { - opt->rep.max_file_opening_threads = n; -} - -int rocksdb_options_get_max_file_opening_threads(rocksdb_options_t* opt) { - return opt->rep.max_file_opening_threads; -} - -void rocksdb_options_set_max_total_wal_size(rocksdb_options_t* opt, - uint64_t n) { - opt->rep.max_total_wal_size = n; -} - -uint64_t rocksdb_options_get_max_total_wal_size(rocksdb_options_t* opt) { - return opt->rep.max_total_wal_size; -} - -void rocksdb_options_set_target_file_size_base(rocksdb_options_t* opt, - uint64_t n) { - opt->rep.target_file_size_base = n; -} - -uint64_t rocksdb_options_get_target_file_size_base(rocksdb_options_t* opt) { - return opt->rep.target_file_size_base; -} - -void rocksdb_options_set_target_file_size_multiplier(rocksdb_options_t* opt, - int n) { - opt->rep.target_file_size_multiplier = n; -} - -int rocksdb_options_get_target_file_size_multiplier(rocksdb_options_t* opt) { - return opt->rep.target_file_size_multiplier; -} - -void rocksdb_options_set_max_bytes_for_level_base(rocksdb_options_t* opt, - uint64_t n) { - opt->rep.max_bytes_for_level_base = n; -} - -uint64_t rocksdb_options_get_max_bytes_for_level_base(rocksdb_options_t* opt) { - return opt->rep.max_bytes_for_level_base; -} - -void rocksdb_options_set_level_compaction_dynamic_level_bytes( - rocksdb_options_t* opt, unsigned char v) { - opt->rep.level_compaction_dynamic_level_bytes = v; -} - -unsigned char rocksdb_options_get_level_compaction_dynamic_level_bytes( - rocksdb_options_t* opt) { - return opt->rep.level_compaction_dynamic_level_bytes; -} - -void rocksdb_options_set_max_bytes_for_level_multiplier(rocksdb_options_t* opt, - double n) { - opt->rep.max_bytes_for_level_multiplier = n; -} - -double rocksdb_options_get_max_bytes_for_level_multiplier( - rocksdb_options_t* opt) { - return opt->rep.max_bytes_for_level_multiplier; -} - -void rocksdb_options_set_max_compaction_bytes(rocksdb_options_t* opt, - uint64_t n) { - opt->rep.max_compaction_bytes = n; -} - -uint64_t rocksdb_options_get_max_compaction_bytes(rocksdb_options_t* opt) { - return opt->rep.max_compaction_bytes; -} - -void rocksdb_options_set_max_bytes_for_level_multiplier_additional( - rocksdb_options_t* opt, int* level_values, size_t num_levels) { - opt->rep.max_bytes_for_level_multiplier_additional.resize(num_levels); - for (size_t i = 0; i < num_levels; ++i) { - opt->rep.max_bytes_for_level_multiplier_additional[i] = level_values[i]; - } -} - -void rocksdb_options_set_ttl(rocksdb_options_t* opt, uint64_t seconds) { - opt->rep.ttl = seconds; -} - -uint64_t rocksdb_options_get_ttl(rocksdb_options_t* opt) { - return opt->rep.ttl; -} - -void rocksdb_options_set_periodic_compaction_seconds(rocksdb_options_t* opt, - uint64_t seconds) { - opt->rep.periodic_compaction_seconds = seconds; -} - -uint64_t rocksdb_options_get_periodic_compaction_seconds( - rocksdb_options_t* opt) { - return opt->rep.periodic_compaction_seconds; -} - -void rocksdb_options_set_memtable_op_scan_flush_trigger(rocksdb_options_t* opt, - uint32_t n) { - opt->rep.memtable_op_scan_flush_trigger = n; -} - -uint32_t rocksdb_options_get_memtable_op_scan_flush_trigger( - rocksdb_options_t* opt) { - return opt->rep.memtable_op_scan_flush_trigger; -} - -void rocksdb_options_set_memtable_avg_op_scan_flush_trigger( - rocksdb_options_t* opt, uint32_t n) { - opt->rep.memtable_avg_op_scan_flush_trigger = n; -} - -uint32_t rocksdb_options_get_memtable_avg_op_scan_flush_trigger( - rocksdb_options_t* opt) { - return opt->rep.memtable_avg_op_scan_flush_trigger; -} - -void rocksdb_options_set_min_tombstones_for_range_conversion( - rocksdb_options_t* opt, uint32_t n) { - opt->rep.min_tombstones_for_range_conversion = n; -} - -uint32_t rocksdb_options_get_min_tombstones_for_range_conversion( - rocksdb_options_t* opt) { - return opt->rep.min_tombstones_for_range_conversion; -} - void rocksdb_options_enable_statistics(rocksdb_options_t* opt) { opt->rep.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics(); } @@ -4720,735 +6192,23 @@ int rocksdb_options_get_statistics_level(rocksdb_options_t* opt) { return static_cast(opt->rep.statistics->get_stats_level()); } -void rocksdb_options_set_skip_stats_update_on_db_open(rocksdb_options_t* opt, - unsigned char val) { - opt->rep.skip_stats_update_on_db_open = val; -} - -unsigned char rocksdb_options_get_skip_stats_update_on_db_open( - rocksdb_options_t* opt) { - return opt->rep.skip_stats_update_on_db_open; -} - -/* Blob Options Settings */ -void rocksdb_options_set_enable_blob_files(rocksdb_options_t* opt, - unsigned char val) { - opt->rep.enable_blob_files = val; -} -ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_enable_blob_files( - rocksdb_options_t* opt) { - return opt->rep.enable_blob_files; -} - -void rocksdb_options_set_min_blob_size(rocksdb_options_t* opt, uint64_t val) { - opt->rep.min_blob_size = val; -} - -uint64_t rocksdb_options_get_min_blob_size(rocksdb_options_t* opt) { - return opt->rep.min_blob_size; -} - -void rocksdb_options_set_blob_file_size(rocksdb_options_t* opt, uint64_t val) { - opt->rep.blob_file_size = val; -} - -uint64_t rocksdb_options_get_blob_file_size(rocksdb_options_t* opt) { - return opt->rep.blob_file_size; -} - -void rocksdb_options_set_blob_compression_type(rocksdb_options_t* opt, - int val) { - opt->rep.blob_compression_type = static_cast(val); -} - -int rocksdb_options_get_blob_compression_type(rocksdb_options_t* opt) { - return opt->rep.blob_compression_type; -} - -void rocksdb_options_set_enable_blob_gc(rocksdb_options_t* opt, - unsigned char val) { - opt->rep.enable_blob_garbage_collection = val; -} - -unsigned char rocksdb_options_get_enable_blob_gc(rocksdb_options_t* opt) { - return opt->rep.enable_blob_garbage_collection; -} - -void rocksdb_options_set_blob_gc_age_cutoff(rocksdb_options_t* opt, - double val) { - opt->rep.blob_garbage_collection_age_cutoff = val; -} - -double rocksdb_options_get_blob_gc_age_cutoff(rocksdb_options_t* opt) { - return opt->rep.blob_garbage_collection_age_cutoff; -} - -void rocksdb_options_set_blob_gc_force_threshold(rocksdb_options_t* opt, - double val) { - opt->rep.blob_garbage_collection_force_threshold = val; -} - -double rocksdb_options_get_blob_gc_force_threshold(rocksdb_options_t* opt) { - return opt->rep.blob_garbage_collection_force_threshold; -} - -void rocksdb_options_set_read_triggered_compaction_threshold( - rocksdb_options_t* opt, double val) { - opt->rep.read_triggered_compaction_threshold = val; -} - -double rocksdb_options_get_read_triggered_compaction_threshold( - rocksdb_options_t* opt) { - return opt->rep.read_triggered_compaction_threshold; -} - -void rocksdb_options_set_max_compaction_trigger_wakeup_seconds( - rocksdb_options_t* opt, uint64_t val) { - opt->rep.max_compaction_trigger_wakeup_seconds = val; -} - -uint64_t rocksdb_options_get_max_compaction_trigger_wakeup_seconds( - rocksdb_options_t* opt) { - return opt->rep.max_compaction_trigger_wakeup_seconds; -} - -void rocksdb_options_set_blob_compaction_readahead_size(rocksdb_options_t* opt, - uint64_t val) { - opt->rep.blob_compaction_readahead_size = val; -} - -uint64_t rocksdb_options_get_blob_compaction_readahead_size( - rocksdb_options_t* opt) { - return opt->rep.blob_compaction_readahead_size; -} - -void rocksdb_options_set_blob_file_starting_level(rocksdb_options_t* opt, - int val) { - opt->rep.blob_file_starting_level = val; -} - -int rocksdb_options_get_blob_file_starting_level(rocksdb_options_t* opt) { - return opt->rep.blob_file_starting_level; -} - void rocksdb_options_set_blob_cache(rocksdb_options_t* opt, rocksdb_cache_t* blob_cache) { opt->rep.blob_cache = blob_cache->rep; } -void rocksdb_options_set_prepopulate_blob_cache(rocksdb_options_t* opt, int t) { - opt->rep.prepopulate_blob_cache = static_cast(t); -} - -int rocksdb_options_get_prepopulate_blob_cache(rocksdb_options_t* opt) { - return static_cast(opt->rep.prepopulate_blob_cache); -} - -void rocksdb_options_set_num_levels(rocksdb_options_t* opt, int n) { - opt->rep.num_levels = n; -} - -int rocksdb_options_get_num_levels(rocksdb_options_t* opt) { - return opt->rep.num_levels; -} - -void rocksdb_options_set_level0_file_num_compaction_trigger( - rocksdb_options_t* opt, int n) { - opt->rep.level0_file_num_compaction_trigger = n; -} - -int rocksdb_options_get_level0_file_num_compaction_trigger( - rocksdb_options_t* opt) { - return opt->rep.level0_file_num_compaction_trigger; -} - -void rocksdb_options_set_level0_slowdown_writes_trigger(rocksdb_options_t* opt, - int n) { - opt->rep.level0_slowdown_writes_trigger = n; -} - -int rocksdb_options_get_level0_slowdown_writes_trigger(rocksdb_options_t* opt) { - return opt->rep.level0_slowdown_writes_trigger; -} - -void rocksdb_options_set_level0_stop_writes_trigger(rocksdb_options_t* opt, - int n) { - opt->rep.level0_stop_writes_trigger = n; -} - -int rocksdb_options_get_level0_stop_writes_trigger(rocksdb_options_t* opt) { - return opt->rep.level0_stop_writes_trigger; -} - -void rocksdb_options_set_wal_recovery_mode(rocksdb_options_t* opt, int mode) { - opt->rep.wal_recovery_mode = static_cast(mode); -} - -int rocksdb_options_get_wal_recovery_mode(rocksdb_options_t* opt) { - return static_cast(opt->rep.wal_recovery_mode); -} - -void rocksdb_options_set_compression(rocksdb_options_t* opt, int t) { - opt->rep.compression = static_cast(t); -} - -int rocksdb_options_get_compression(rocksdb_options_t* opt) { - return opt->rep.compression; -} - -void rocksdb_options_set_bottommost_compression(rocksdb_options_t* opt, int t) { - opt->rep.bottommost_compression = static_cast(t); -} - -int rocksdb_options_get_bottommost_compression(rocksdb_options_t* opt) { - return opt->rep.bottommost_compression; -} - -void rocksdb_options_set_compression_per_level(rocksdb_options_t* opt, - const int* level_values, - size_t num_levels) { - opt->rep.compression_per_level.resize(num_levels); - for (size_t i = 0; i < num_levels; ++i) { - opt->rep.compression_per_level[i] = - static_cast(level_values[i]); - } -} - -void rocksdb_options_set_bottommost_compression_options(rocksdb_options_t* opt, - int w_bits, int level, - int strategy, - int max_dict_bytes, - unsigned char enabled) { - opt->rep.bottommost_compression_opts.window_bits = w_bits; - opt->rep.bottommost_compression_opts.level = level; - opt->rep.bottommost_compression_opts.strategy = strategy; - opt->rep.bottommost_compression_opts.max_dict_bytes = max_dict_bytes; - opt->rep.bottommost_compression_opts.enabled = enabled; -} - -void rocksdb_options_set_bottommost_compression_options_zstd_max_train_bytes( - rocksdb_options_t* opt, int zstd_max_train_bytes, unsigned char enabled) { - opt->rep.bottommost_compression_opts.zstd_max_train_bytes = - zstd_max_train_bytes; - opt->rep.bottommost_compression_opts.enabled = enabled; -} - -void rocksdb_options_set_bottommost_compression_options_use_zstd_dict_trainer( - rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer, - unsigned char enabled) { - opt->rep.bottommost_compression_opts.use_zstd_dict_trainer = - use_zstd_dict_trainer; - opt->rep.bottommost_compression_opts.enabled = enabled; -} - -unsigned char -rocksdb_options_get_bottommost_compression_options_use_zstd_dict_trainer( - rocksdb_options_t* opt) { - return opt->rep.bottommost_compression_opts.use_zstd_dict_trainer; -} - -void rocksdb_options_set_bottommost_compression_options_max_dict_buffer_bytes( - rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes, - unsigned char enabled) { - opt->rep.bottommost_compression_opts.max_dict_buffer_bytes = - max_dict_buffer_bytes; - opt->rep.bottommost_compression_opts.enabled = enabled; -} - -void rocksdb_options_set_compression_options(rocksdb_options_t* opt, int w_bits, - int level, int strategy, - int max_dict_bytes) { - opt->rep.compression_opts.window_bits = w_bits; - opt->rep.compression_opts.level = level; - opt->rep.compression_opts.strategy = strategy; - opt->rep.compression_opts.max_dict_bytes = max_dict_bytes; -} - -void rocksdb_options_set_compression_options_zstd_max_train_bytes( - rocksdb_options_t* opt, int zstd_max_train_bytes) { - opt->rep.compression_opts.zstd_max_train_bytes = zstd_max_train_bytes; -} - -int rocksdb_options_get_compression_options_zstd_max_train_bytes( - rocksdb_options_t* opt) { - return opt->rep.compression_opts.zstd_max_train_bytes; -} - -void rocksdb_options_set_compression_options_use_zstd_dict_trainer( - rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer) { - opt->rep.compression_opts.use_zstd_dict_trainer = use_zstd_dict_trainer; -} - -unsigned char rocksdb_options_get_compression_options_use_zstd_dict_trainer( - rocksdb_options_t* opt) { - return opt->rep.compression_opts.use_zstd_dict_trainer; -} - -void rocksdb_options_set_compression_options_parallel_threads( - rocksdb_options_t* opt, int value) { - opt->rep.compression_opts.parallel_threads = value; -} - -int rocksdb_options_get_compression_options_parallel_threads( - rocksdb_options_t* opt) { - return opt->rep.compression_opts.parallel_threads; -} - -void rocksdb_options_set_compression_options_max_dict_buffer_bytes( - rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes) { - opt->rep.compression_opts.max_dict_buffer_bytes = max_dict_buffer_bytes; -} - -uint64_t rocksdb_options_get_compression_options_max_dict_buffer_bytes( - rocksdb_options_t* opt) { - return opt->rep.compression_opts.max_dict_buffer_bytes; -} - void rocksdb_options_set_prefix_extractor( rocksdb_options_t* opt, rocksdb_slicetransform_t* prefix_extractor) { opt->rep.prefix_extractor.reset(prefix_extractor); } -void rocksdb_options_set_use_fsync(rocksdb_options_t* opt, int use_fsync) { - opt->rep.use_fsync = use_fsync; -} - -int rocksdb_options_get_use_fsync(rocksdb_options_t* opt) { - return opt->rep.use_fsync; -} - -void rocksdb_options_set_db_log_dir(rocksdb_options_t* opt, - const char* db_log_dir) { - opt->rep.db_log_dir = db_log_dir; -} - -void rocksdb_options_set_wal_dir(rocksdb_options_t* opt, const char* v) { - opt->rep.wal_dir = v; -} - -void rocksdb_options_set_WAL_ttl_seconds(rocksdb_options_t* opt, uint64_t ttl) { - opt->rep.WAL_ttl_seconds = ttl; -} - -uint64_t rocksdb_options_get_WAL_ttl_seconds(rocksdb_options_t* opt) { - return opt->rep.WAL_ttl_seconds; -} - -void rocksdb_options_set_WAL_size_limit_MB(rocksdb_options_t* opt, - uint64_t limit) { - opt->rep.WAL_size_limit_MB = limit; -} - -uint64_t rocksdb_options_get_WAL_size_limit_MB(rocksdb_options_t* opt) { - return opt->rep.WAL_size_limit_MB; -} - -void rocksdb_options_set_manifest_preallocation_size(rocksdb_options_t* opt, - size_t v) { - opt->rep.manifest_preallocation_size = v; -} - -size_t rocksdb_options_get_manifest_preallocation_size(rocksdb_options_t* opt) { - return opt->rep.manifest_preallocation_size; -} - -void rocksdb_options_set_use_direct_reads(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.use_direct_reads = v; -} - -unsigned char rocksdb_options_get_use_direct_reads(rocksdb_options_t* opt) { - return opt->rep.use_direct_reads; -} - -void rocksdb_options_set_use_direct_io_for_flush_and_compaction( - rocksdb_options_t* opt, unsigned char v) { - opt->rep.use_direct_io_for_flush_and_compaction = v; -} - -unsigned char rocksdb_options_get_use_direct_io_for_flush_and_compaction( - rocksdb_options_t* opt) { - return opt->rep.use_direct_io_for_flush_and_compaction; -} - -void rocksdb_options_set_use_direct_io_for_compaction_reads( - rocksdb_options_t* opt, unsigned char v) { - opt->rep.use_direct_io_for_compaction_reads = v; -} - -unsigned char rocksdb_options_get_use_direct_io_for_compaction_reads( - rocksdb_options_t* opt) { - return opt->rep.use_direct_io_for_compaction_reads; -} - -void rocksdb_options_set_allow_mmap_reads(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.allow_mmap_reads = v; -} - -unsigned char rocksdb_options_get_allow_mmap_reads(rocksdb_options_t* opt) { - return opt->rep.allow_mmap_reads; -} - -void rocksdb_options_set_allow_mmap_writes(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.allow_mmap_writes = v; -} - -unsigned char rocksdb_options_get_allow_mmap_writes(rocksdb_options_t* opt) { - return opt->rep.allow_mmap_writes; -} - -void rocksdb_options_set_is_fd_close_on_exec(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.is_fd_close_on_exec = v; -} - -unsigned char rocksdb_options_get_is_fd_close_on_exec(rocksdb_options_t* opt) { - return opt->rep.is_fd_close_on_exec; -} - -void rocksdb_options_set_stats_dump_period_sec(rocksdb_options_t* opt, - unsigned int v) { - opt->rep.stats_dump_period_sec = v; -} - -unsigned int rocksdb_options_get_stats_dump_period_sec(rocksdb_options_t* opt) { - return opt->rep.stats_dump_period_sec; -} - -void rocksdb_options_set_stats_persist_period_sec(rocksdb_options_t* opt, - unsigned int v) { - opt->rep.stats_persist_period_sec = v; -} - -unsigned int rocksdb_options_get_stats_persist_period_sec( - rocksdb_options_t* opt) { - return opt->rep.stats_persist_period_sec; -} - -void rocksdb_options_set_advise_random_on_open(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.advise_random_on_open = v; -} - -unsigned char rocksdb_options_get_advise_random_on_open( - rocksdb_options_t* opt) { - return opt->rep.advise_random_on_open; -} - -void rocksdb_options_set_use_adaptive_mutex(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.use_adaptive_mutex = v; -} - -unsigned char rocksdb_options_get_use_adaptive_mutex(rocksdb_options_t* opt) { - return opt->rep.use_adaptive_mutex; -} - -void rocksdb_options_set_wal_bytes_per_sync(rocksdb_options_t* opt, - uint64_t v) { - opt->rep.wal_bytes_per_sync = v; -} - -uint64_t rocksdb_options_get_wal_bytes_per_sync(rocksdb_options_t* opt) { - return opt->rep.wal_bytes_per_sync; -} - -void rocksdb_options_set_bytes_per_sync(rocksdb_options_t* opt, uint64_t v) { - opt->rep.bytes_per_sync = v; -} - -uint64_t rocksdb_options_get_bytes_per_sync(rocksdb_options_t* opt) { - return opt->rep.bytes_per_sync; -} - -void rocksdb_options_set_writable_file_max_buffer_size(rocksdb_options_t* opt, - uint64_t v) { - opt->rep.writable_file_max_buffer_size = static_cast(v); -} - -uint64_t rocksdb_options_get_writable_file_max_buffer_size( - rocksdb_options_t* opt) { - return opt->rep.writable_file_max_buffer_size; -} - -void rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.allow_concurrent_memtable_write = v; -} - -unsigned char rocksdb_options_get_allow_concurrent_memtable_write( - rocksdb_options_t* opt) { - return opt->rep.allow_concurrent_memtable_write; -} - -void rocksdb_options_set_enable_write_thread_adaptive_yield( - rocksdb_options_t* opt, unsigned char v) { - opt->rep.enable_write_thread_adaptive_yield = v; -} - -unsigned char rocksdb_options_get_enable_write_thread_adaptive_yield( - rocksdb_options_t* opt) { - return opt->rep.enable_write_thread_adaptive_yield; -} - -void rocksdb_options_set_max_sequential_skip_in_iterations( - rocksdb_options_t* opt, uint64_t v) { - opt->rep.max_sequential_skip_in_iterations = v; -} - -uint64_t rocksdb_options_get_max_sequential_skip_in_iterations( - rocksdb_options_t* opt) { - return opt->rep.max_sequential_skip_in_iterations; -} - -void rocksdb_options_set_max_write_buffer_number(rocksdb_options_t* opt, - int n) { - opt->rep.max_write_buffer_number = n; -} - -int rocksdb_options_get_max_write_buffer_number(rocksdb_options_t* opt) { - return opt->rep.max_write_buffer_number; -} - -void rocksdb_options_set_min_write_buffer_number_to_merge( - rocksdb_options_t* opt, int n) { - opt->rep.min_write_buffer_number_to_merge = n; -} - -int rocksdb_options_get_min_write_buffer_number_to_merge( - rocksdb_options_t* opt) { - return opt->rep.min_write_buffer_number_to_merge; -} - -void rocksdb_options_set_max_write_buffer_size_to_maintain( - rocksdb_options_t* opt, int64_t n) { - opt->rep.max_write_buffer_size_to_maintain = n; -} - -int64_t rocksdb_options_get_max_write_buffer_size_to_maintain( - rocksdb_options_t* opt) { - return opt->rep.max_write_buffer_size_to_maintain; -} - -void rocksdb_options_set_enable_pipelined_write(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.enable_pipelined_write = v; -} - -unsigned char rocksdb_options_get_enable_pipelined_write( - rocksdb_options_t* opt) { - return opt->rep.enable_pipelined_write; -} - -void rocksdb_options_set_unordered_write(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.unordered_write = v; -} - -unsigned char rocksdb_options_get_unordered_write(rocksdb_options_t* opt) { - return opt->rep.unordered_write; -} - -void rocksdb_options_set_max_subcompactions(rocksdb_options_t* opt, - uint32_t n) { - opt->rep.max_subcompactions = n; -} - -uint32_t rocksdb_options_get_max_subcompactions(rocksdb_options_t* opt) { - return opt->rep.max_subcompactions; -} - -void rocksdb_options_set_max_background_jobs(rocksdb_options_t* opt, int n) { - opt->rep.max_background_jobs = n; -} - -int rocksdb_options_get_max_background_jobs(rocksdb_options_t* opt) { - return opt->rep.max_background_jobs; -} - -void rocksdb_options_set_max_background_compactions(rocksdb_options_t* opt, - int n) { - opt->rep.max_background_compactions = n; -} - -int rocksdb_options_get_max_background_compactions(rocksdb_options_t* opt) { - return opt->rep.max_background_compactions; -} - -void rocksdb_options_set_max_background_flushes(rocksdb_options_t* opt, int n) { - opt->rep.max_background_flushes = n; -} - -int rocksdb_options_get_max_background_flushes(rocksdb_options_t* opt) { - return opt->rep.max_background_flushes; -} - -void rocksdb_options_set_experimental_mempurge_threshold(rocksdb_options_t* opt, - double v) { - opt->rep.experimental_mempurge_threshold = v; -} - -double rocksdb_options_get_experimental_mempurge_threshold( - rocksdb_options_t* opt) { - return opt->rep.experimental_mempurge_threshold; -} - -void rocksdb_options_set_max_log_file_size(rocksdb_options_t* opt, size_t v) { - opt->rep.max_log_file_size = v; -} - -size_t rocksdb_options_get_max_log_file_size(rocksdb_options_t* opt) { - return opt->rep.max_log_file_size; -} - -void rocksdb_options_set_log_file_time_to_roll(rocksdb_options_t* opt, - size_t v) { - opt->rep.log_file_time_to_roll = v; -} - -size_t rocksdb_options_get_log_file_time_to_roll(rocksdb_options_t* opt) { - return opt->rep.log_file_time_to_roll; -} - -void rocksdb_options_set_keep_log_file_num(rocksdb_options_t* opt, size_t v) { - opt->rep.keep_log_file_num = v; -} - -size_t rocksdb_options_get_keep_log_file_num(rocksdb_options_t* opt) { - return opt->rep.keep_log_file_num; -} - -void rocksdb_options_set_recycle_log_file_num(rocksdb_options_t* opt, - size_t v) { - opt->rep.recycle_log_file_num = v; -} - -size_t rocksdb_options_get_recycle_log_file_num(rocksdb_options_t* opt) { - return opt->rep.recycle_log_file_num; -} - -void rocksdb_options_set_async_wal_precreate(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.async_wal_precreate = v; -} - -unsigned char rocksdb_options_get_async_wal_precreate(rocksdb_options_t* opt) { - return opt->rep.async_wal_precreate; -} - -void rocksdb_options_set_soft_pending_compaction_bytes_limit( - rocksdb_options_t* opt, size_t v) { - opt->rep.soft_pending_compaction_bytes_limit = v; -} - -size_t rocksdb_options_get_soft_pending_compaction_bytes_limit( - rocksdb_options_t* opt) { - return opt->rep.soft_pending_compaction_bytes_limit; -} - -void rocksdb_options_set_hard_pending_compaction_bytes_limit( - rocksdb_options_t* opt, size_t v) { - opt->rep.hard_pending_compaction_bytes_limit = v; -} - -size_t rocksdb_options_get_hard_pending_compaction_bytes_limit( - rocksdb_options_t* opt) { - return opt->rep.hard_pending_compaction_bytes_limit; -} - -void rocksdb_options_set_max_manifest_file_size(rocksdb_options_t* opt, - size_t v) { - opt->rep.max_manifest_file_size = v; -} - -size_t rocksdb_options_get_max_manifest_file_size(rocksdb_options_t* opt) { - return opt->rep.max_manifest_file_size; -} - -void rocksdb_options_set_table_cache_numshardbits(rocksdb_options_t* opt, - int v) { - opt->rep.table_cache_numshardbits = v; -} - -int rocksdb_options_get_table_cache_numshardbits(rocksdb_options_t* opt) { - return opt->rep.table_cache_numshardbits; -} - -void rocksdb_options_set_arena_block_size(rocksdb_options_t* opt, size_t v) { - opt->rep.arena_block_size = v; -} - -size_t rocksdb_options_get_arena_block_size(rocksdb_options_t* opt) { - return opt->rep.arena_block_size; -} - -void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt, - int disable) { - opt->rep.disable_auto_compactions = disable; -} - -unsigned char rocksdb_options_get_disable_auto_compactions( - rocksdb_options_t* opt) { - return opt->rep.disable_auto_compactions; -} - -void rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t* opt, - int v) { - opt->rep.optimize_filters_for_hits = v; -} - -unsigned char rocksdb_options_get_optimize_filters_for_hits( - rocksdb_options_t* opt) { - return opt->rep.optimize_filters_for_hits; -} - -void rocksdb_options_set_delete_obsolete_files_period_micros( - rocksdb_options_t* opt, uint64_t v) { - opt->rep.delete_obsolete_files_period_micros = v; -} - -uint64_t rocksdb_options_get_delete_obsolete_files_period_micros( - rocksdb_options_t* opt) { - return opt->rep.delete_obsolete_files_period_micros; -} - void rocksdb_options_prepare_for_bulk_load(rocksdb_options_t* opt) { opt->rep.PrepareForBulkLoad(); } void rocksdb_options_set_memtable_vector_rep(rocksdb_options_t* opt) { - opt->rep.memtable_factory.reset(new ROCKSDB_NAMESPACE::VectorRepFactory); -} - -void rocksdb_options_set_memtable_prefix_bloom_size_ratio( - rocksdb_options_t* opt, double v) { - opt->rep.memtable_prefix_bloom_size_ratio = v; -} - -double rocksdb_options_get_memtable_prefix_bloom_size_ratio( - rocksdb_options_t* opt) { - return opt->rep.memtable_prefix_bloom_size_ratio; -} - -void rocksdb_options_set_memtable_huge_page_size(rocksdb_options_t* opt, - size_t v) { - opt->rep.memtable_huge_page_size = v; -} - -size_t rocksdb_options_get_memtable_huge_page_size(rocksdb_options_t* opt) { - return opt->rep.memtable_huge_page_size; -} - -void rocksdb_options_set_memtable_batch_lookup_optimization( - rocksdb_options_t* opt, unsigned char v) { - opt->rep.memtable_batch_lookup_optimization = v; -} - -unsigned char rocksdb_options_get_memtable_batch_lookup_optimization( - rocksdb_options_t* opt) { - return opt->rep.memtable_batch_lookup_optimization; + opt->rep.memtable_factory = + std::make_shared(); } void rocksdb_options_set_hash_skip_list_rep(rocksdb_options_t* opt, @@ -5488,89 +6248,6 @@ void rocksdb_options_set_plain_table_factory( opt->rep.table_factory.reset(factory); } -unsigned char rocksdb_options_get_write_dbid_to_manifest( - rocksdb_options_t* opt) { - return opt->rep.write_dbid_to_manifest; -} - -void rocksdb_options_set_write_dbid_to_manifest( - rocksdb_options_t* opt, unsigned char write_dbid_to_manifest) { - opt->rep.write_dbid_to_manifest = write_dbid_to_manifest; -} - -unsigned char rocksdb_options_get_write_identity_file(rocksdb_options_t* opt) { - return opt->rep.write_identity_file; -} - -void rocksdb_options_set_write_identity_file( - rocksdb_options_t* opt, unsigned char write_identity_file) { - opt->rep.write_identity_file = write_identity_file; -} - -unsigned char rocksdb_options_get_track_and_verify_wals_in_manifest( - rocksdb_options_t* opt) { - return opt->rep.track_and_verify_wals_in_manifest; -} - -void rocksdb_options_set_track_and_verify_wals_in_manifest( - rocksdb_options_t* opt, unsigned char track_and_verify_wals_in_manifest) { - opt->rep.track_and_verify_wals_in_manifest = - track_and_verify_wals_in_manifest; -} - -void rocksdb_options_set_max_successive_merges(rocksdb_options_t* opt, - size_t v) { - opt->rep.max_successive_merges = v; -} - -size_t rocksdb_options_get_max_successive_merges(rocksdb_options_t* opt) { - return opt->rep.max_successive_merges; -} - -void rocksdb_options_set_bloom_locality(rocksdb_options_t* opt, uint32_t v) { - opt->rep.bloom_locality = v; -} - -uint32_t rocksdb_options_get_bloom_locality(rocksdb_options_t* opt) { - return opt->rep.bloom_locality; -} - -void rocksdb_options_set_inplace_update_support(rocksdb_options_t* opt, - unsigned char v) { - opt->rep.inplace_update_support = v; -} - -unsigned char rocksdb_options_get_inplace_update_support( - rocksdb_options_t* opt) { - return opt->rep.inplace_update_support; -} - -void rocksdb_options_set_inplace_update_num_locks(rocksdb_options_t* opt, - size_t v) { - opt->rep.inplace_update_num_locks = v; -} - -size_t rocksdb_options_get_inplace_update_num_locks(rocksdb_options_t* opt) { - return opt->rep.inplace_update_num_locks; -} - -void rocksdb_options_set_report_bg_io_stats(rocksdb_options_t* opt, int v) { - opt->rep.report_bg_io_stats = v; -} - -unsigned char rocksdb_options_get_report_bg_io_stats(rocksdb_options_t* opt) { - return opt->rep.report_bg_io_stats; -} - -void rocksdb_options_set_compaction_style(rocksdb_options_t* opt, int style) { - opt->rep.compaction_style = - static_cast(style); -} - -int rocksdb_options_get_compaction_style(rocksdb_options_t* opt) { - return opt->rep.compaction_style; -} - void rocksdb_options_set_universal_compaction_options( rocksdb_options_t* opt, rocksdb_universal_compaction_options_t* uco) { opt->rep.compaction_options_universal = *(uco->rep); @@ -5581,14 +6258,6 @@ void rocksdb_options_set_fifo_compaction_options( opt->rep.compaction_options_fifo = fifo->rep; } -void rocksdb_options_set_compaction_pri(rocksdb_options_t* opt, int pri) { - opt->rep.compaction_pri = static_cast(pri); -} - -int rocksdb_options_get_compaction_pri(rocksdb_options_t* opt) { - return opt->rep.compaction_pri; -} - char* rocksdb_options_statistics_get_string(rocksdb_options_t* opt) { ROCKSDB_NAMESPACE::Statistics* statistics = opt->rep.statistics.get(); if (statistics) { @@ -5624,32 +6293,6 @@ void rocksdb_options_set_ratelimiter(rocksdb_options_t* opt, } } -void rocksdb_options_set_atomic_flush(rocksdb_options_t* opt, - unsigned char atomic_flush) { - opt->rep.atomic_flush = atomic_flush; -} - -unsigned char rocksdb_options_get_atomic_flush(rocksdb_options_t* opt) { - return opt->rep.atomic_flush; -} - -void rocksdb_options_set_manual_wal_flush(rocksdb_options_t* opt, - unsigned char manual_wal_flush) { - opt->rep.manual_wal_flush = manual_wal_flush; -} - -unsigned char rocksdb_options_get_manual_wal_flush(rocksdb_options_t* opt) { - return opt->rep.manual_wal_flush; -} - -void rocksdb_options_set_wal_compression(rocksdb_options_t* opt, int val) { - opt->rep.wal_compression = static_cast(val); -} - -int rocksdb_options_get_wal_compression(rocksdb_options_t* opt) { - return opt->rep.wal_compression; -} - rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(int64_t rate_bytes_per_sec, int64_t refill_period_us, int32_t fairness) { @@ -5882,8 +6525,6 @@ uint64_t rocksdb_perfcontext_metric(rocksdb_perfcontext_t* context, return rep->number_async_seek; case rocksdb_blob_cache_hit_count: return rep->blob_cache_hit_count; - case rocksdb_blob_cache_read_byte: - return rep->blob_cache_read_byte; case rocksdb_blob_read_count: return rep->blob_read_count; case rocksdb_blob_read_byte: @@ -5953,6 +6594,23 @@ void rocksdb_compactionfilter_destroy(rocksdb_compactionfilter_t* filter) { delete filter; } +rocksdb_walfilter_t* rocksdb_walfilter_create( + void* state, void (*destructor)(void*), + rocksdb_walfilter_column_family_log_number_map_cb + column_family_log_number_map, + rocksdb_walfilter_log_record_found_cb log_record_found, + const char* (*name)(void*)) { + rocksdb_walfilter_t* result = new rocksdb_walfilter_t; + result->state_ = state; + result->destructor_ = destructor; + result->column_family_log_number_map_ = column_family_log_number_map; + result->log_record_found_ = log_record_found; + result->name_ = name; + return result; +} + +void rocksdb_walfilter_destroy(rocksdb_walfilter_t* filter) { delete filter; } + unsigned char rocksdb_compactionfiltercontext_is_full_compaction( rocksdb_compactionfiltercontext_t* context) { return context->rep.is_full_compaction; @@ -6140,6 +6798,71 @@ rocksdb_readoptions_t* rocksdb_readoptions_create() { void rocksdb_readoptions_destroy(rocksdb_readoptions_t* opt) { delete opt; } +// BEGIN generated: c_generated_readoptions_auto.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/options.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered ReadOptions simple + +/* ReadOptions */ + +void rocksdb_readoptions_set_deadline(rocksdb_readoptions_t* opt, + uint64_t microseconds) { + opt->rep.deadline = std::chrono::microseconds(microseconds); +} + +uint64_t rocksdb_readoptions_get_deadline(rocksdb_readoptions_t* opt) { + return opt->rep.deadline.count(); +} + +void rocksdb_readoptions_set_io_timeout(rocksdb_readoptions_t* opt, + uint64_t microseconds) { + opt->rep.io_timeout = std::chrono::microseconds(microseconds); +} + +uint64_t rocksdb_readoptions_get_io_timeout(rocksdb_readoptions_t* opt) { + return opt->rep.io_timeout.count(); +} + +void rocksdb_readoptions_set_read_tier(rocksdb_readoptions_t* opt, int v) { + opt->rep.read_tier = static_castrep.read_tier)>(v); +} + +int rocksdb_readoptions_get_read_tier(rocksdb_readoptions_t* opt) { + return static_cast(opt->rep.read_tier); +} + +void rocksdb_readoptions_set_rate_limiter_priority(rocksdb_readoptions_t* opt, + int v) { + opt->rep.rate_limiter_priority = + static_castrep.rate_limiter_priority)>(v); +} + +int rocksdb_readoptions_get_rate_limiter_priority(rocksdb_readoptions_t* opt) { + return static_cast(opt->rep.rate_limiter_priority); +} + +void rocksdb_readoptions_set_value_size_soft_limit(rocksdb_readoptions_t* opt, + uint64_t v) { + opt->rep.value_size_soft_limit = v; +} + +uint64_t rocksdb_readoptions_get_value_size_soft_limit( + rocksdb_readoptions_t* opt) { + return opt->rep.value_size_soft_limit; +} + void rocksdb_readoptions_set_verify_checksums(rocksdb_readoptions_t* opt, unsigned char v) { opt->rep.verify_checksums = v; @@ -6159,6 +6882,161 @@ unsigned char rocksdb_readoptions_get_fill_cache(rocksdb_readoptions_t* opt) { return opt->rep.fill_cache; } +void rocksdb_readoptions_set_ignore_range_deletions(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.ignore_range_deletions = v; +} + +unsigned char rocksdb_readoptions_get_ignore_range_deletions( + rocksdb_readoptions_t* opt) { + return opt->rep.ignore_range_deletions; +} + +void rocksdb_readoptions_set_async_io(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.async_io = v; +} + +unsigned char rocksdb_readoptions_get_async_io(rocksdb_readoptions_t* opt) { + return opt->rep.async_io; +} + +void rocksdb_readoptions_set_optimize_multiget_for_io( + rocksdb_readoptions_t* opt, unsigned char v) { + opt->rep.optimize_multiget_for_io = v; +} + +unsigned char rocksdb_readoptions_get_optimize_multiget_for_io( + rocksdb_readoptions_t* opt) { + return opt->rep.optimize_multiget_for_io; +} + +void rocksdb_readoptions_set_readahead_size(rocksdb_readoptions_t* opt, + size_t v) { + opt->rep.readahead_size = v; +} + +size_t rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t* opt) { + return opt->rep.readahead_size; +} + +void rocksdb_readoptions_set_max_skippable_internal_keys( + rocksdb_readoptions_t* opt, uint64_t v) { + opt->rep.max_skippable_internal_keys = v; +} + +uint64_t rocksdb_readoptions_get_max_skippable_internal_keys( + rocksdb_readoptions_t* opt) { + return opt->rep.max_skippable_internal_keys; +} + +void rocksdb_readoptions_set_tailing(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.tailing = v; +} + +unsigned char rocksdb_readoptions_get_tailing(rocksdb_readoptions_t* opt) { + return opt->rep.tailing; +} + +void rocksdb_readoptions_set_total_order_seek(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.total_order_seek = v; +} + +unsigned char rocksdb_readoptions_get_total_order_seek( + rocksdb_readoptions_t* opt) { + return opt->rep.total_order_seek; +} + +void rocksdb_readoptions_set_auto_prefix_mode(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.auto_prefix_mode = v; +} + +unsigned char rocksdb_readoptions_get_auto_prefix_mode( + rocksdb_readoptions_t* opt) { + return opt->rep.auto_prefix_mode; +} + +void rocksdb_readoptions_set_prefix_same_as_start(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.prefix_same_as_start = v; +} + +unsigned char rocksdb_readoptions_get_prefix_same_as_start( + rocksdb_readoptions_t* opt) { + return opt->rep.prefix_same_as_start; +} + +void rocksdb_readoptions_set_pin_data(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.pin_data = v; +} + +unsigned char rocksdb_readoptions_get_pin_data(rocksdb_readoptions_t* opt) { + return opt->rep.pin_data; +} + +void rocksdb_readoptions_set_adaptive_readahead(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.adaptive_readahead = v; +} + +unsigned char rocksdb_readoptions_get_adaptive_readahead( + rocksdb_readoptions_t* opt) { + return opt->rep.adaptive_readahead; +} + +void rocksdb_readoptions_set_background_purge_on_iterator_cleanup( + rocksdb_readoptions_t* opt, unsigned char v) { + opt->rep.background_purge_on_iterator_cleanup = v; +} + +unsigned char rocksdb_readoptions_get_background_purge_on_iterator_cleanup( + rocksdb_readoptions_t* opt) { + return opt->rep.background_purge_on_iterator_cleanup; +} + +void rocksdb_readoptions_set_auto_readahead_size(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.auto_readahead_size = v; +} + +unsigned char rocksdb_readoptions_get_auto_readahead_size( + rocksdb_readoptions_t* opt) { + return opt->rep.auto_readahead_size; +} + +void rocksdb_readoptions_set_allow_unprepared_value(rocksdb_readoptions_t* opt, + unsigned char v) { + opt->rep.allow_unprepared_value = v; +} + +unsigned char rocksdb_readoptions_get_allow_unprepared_value( + rocksdb_readoptions_t* opt) { + return opt->rep.allow_unprepared_value; +} + +void rocksdb_readoptions_set_auto_refresh_iterator_with_snapshot( + rocksdb_readoptions_t* opt, unsigned char v) { + opt->rep.auto_refresh_iterator_with_snapshot = v; +} + +unsigned char rocksdb_readoptions_get_auto_refresh_iterator_with_snapshot( + rocksdb_readoptions_t* opt) { + return opt->rep.auto_refresh_iterator_with_snapshot; +} + +void rocksdb_readoptions_set_io_activity(rocksdb_readoptions_t* opt, int v) { + opt->rep.io_activity = static_castrep.io_activity)>(v); +} + +int rocksdb_readoptions_get_io_activity(rocksdb_readoptions_t* opt) { + return static_cast(opt->rep.io_activity); +} +// END generated: c_generated_readoptions_auto.cc.inc + void rocksdb_readoptions_set_snapshot(rocksdb_readoptions_t* opt, const rocksdb_snapshot_t* snap) { opt->rep.snapshot = (snap ? snap->rep : nullptr); @@ -6189,129 +7067,6 @@ void rocksdb_readoptions_set_iterate_lower_bound(rocksdb_readoptions_t* opt, } } -void rocksdb_readoptions_set_read_tier(rocksdb_readoptions_t* opt, int v) { - opt->rep.read_tier = static_cast(v); -} - -int rocksdb_readoptions_get_read_tier(rocksdb_readoptions_t* opt) { - return static_cast(opt->rep.read_tier); -} - -void rocksdb_readoptions_set_tailing(rocksdb_readoptions_t* opt, - unsigned char v) { - opt->rep.tailing = v; -} - -unsigned char rocksdb_readoptions_get_tailing(rocksdb_readoptions_t* opt) { - return opt->rep.tailing; -} - -void rocksdb_readoptions_set_readahead_size(rocksdb_readoptions_t* opt, - size_t v) { - opt->rep.readahead_size = v; -} - -size_t rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t* opt) { - return opt->rep.readahead_size; -} - -void rocksdb_readoptions_set_prefix_same_as_start(rocksdb_readoptions_t* opt, - unsigned char v) { - opt->rep.prefix_same_as_start = v; -} - -unsigned char rocksdb_readoptions_get_prefix_same_as_start( - rocksdb_readoptions_t* opt) { - return opt->rep.prefix_same_as_start; -} - -void rocksdb_readoptions_set_pin_data(rocksdb_readoptions_t* opt, - unsigned char v) { - opt->rep.pin_data = v; -} - -unsigned char rocksdb_readoptions_get_pin_data(rocksdb_readoptions_t* opt) { - return opt->rep.pin_data; -} - -void rocksdb_readoptions_set_total_order_seek(rocksdb_readoptions_t* opt, - unsigned char v) { - opt->rep.total_order_seek = v; -} - -unsigned char rocksdb_readoptions_get_total_order_seek( - rocksdb_readoptions_t* opt) { - return opt->rep.total_order_seek; -} - -void rocksdb_readoptions_set_max_skippable_internal_keys( - rocksdb_readoptions_t* opt, uint64_t v) { - opt->rep.max_skippable_internal_keys = v; -} - -uint64_t rocksdb_readoptions_get_max_skippable_internal_keys( - rocksdb_readoptions_t* opt) { - return opt->rep.max_skippable_internal_keys; -} - -void rocksdb_readoptions_set_background_purge_on_iterator_cleanup( - rocksdb_readoptions_t* opt, unsigned char v) { - opt->rep.background_purge_on_iterator_cleanup = v; -} - -unsigned char rocksdb_readoptions_get_background_purge_on_iterator_cleanup( - rocksdb_readoptions_t* opt) { - return opt->rep.background_purge_on_iterator_cleanup; -} - -void rocksdb_readoptions_set_ignore_range_deletions(rocksdb_readoptions_t* opt, - unsigned char v) { - opt->rep.ignore_range_deletions = v; -} - -unsigned char rocksdb_readoptions_get_ignore_range_deletions( - rocksdb_readoptions_t* opt) { - return opt->rep.ignore_range_deletions; -} - -void rocksdb_readoptions_set_deadline(rocksdb_readoptions_t* opt, - uint64_t microseconds) { - opt->rep.deadline = std::chrono::microseconds(microseconds); -} - -uint64_t rocksdb_readoptions_get_deadline(rocksdb_readoptions_t* opt) { - return opt->rep.deadline.count(); -} - -void rocksdb_readoptions_set_io_timeout(rocksdb_readoptions_t* opt, - uint64_t microseconds) { - opt->rep.io_timeout = std::chrono::microseconds(microseconds); -} - -ROCKSDB_LIBRARY_API uint64_t -rocksdb_readoptions_get_io_timeout(rocksdb_readoptions_t* opt) { - return opt->rep.io_timeout.count(); -} - -void rocksdb_readoptions_set_async_io(rocksdb_readoptions_t* opt, - unsigned char v) { - opt->rep.async_io = v; -} - -unsigned char rocksdb_readoptions_get_async_io(rocksdb_readoptions_t* opt) { - return opt->rep.async_io; -} - -void rocksdb_readoptions_set_optimize_multiget_for_io( - rocksdb_readoptions_t* opt, unsigned char v) { - opt->rep.optimize_multiget_for_io = v; -} - -unsigned char rocksdb_readoptions_get_optimize_multiget_for_io( - rocksdb_readoptions_t* opt) { - return opt->rep.optimize_multiget_for_io; -} - void rocksdb_readoptions_set_timestamp(rocksdb_readoptions_t* opt, const char* ts, size_t tslen) { if (ts == nullptr) { @@ -6334,9 +7089,111 @@ void rocksdb_readoptions_set_iter_start_ts(rocksdb_readoptions_t* opt, } } -void rocksdb_readoptions_set_auto_readahead_size(rocksdb_readoptions_t* opt, - unsigned char v) { - opt->rep.auto_readahead_size = v; +void rocksdb_readoptions_set_merge_operand_count_threshold( + rocksdb_readoptions_t* opt, size_t threshold) { + opt->rep.merge_operand_count_threshold = threshold; +} + +void rocksdb_readoptions_clear_merge_operand_count_threshold( + rocksdb_readoptions_t* opt) { + opt->rep.merge_operand_count_threshold.reset(); +} + +unsigned char rocksdb_readoptions_has_merge_operand_count_threshold( + rocksdb_readoptions_t* opt) { + return opt->rep.merge_operand_count_threshold.has_value(); +} + +size_t rocksdb_readoptions_get_merge_operand_count_threshold( + rocksdb_readoptions_t* opt) { + return opt->rep.merge_operand_count_threshold.value_or(0); +} + +void rocksdb_readoptions_set_request_id(rocksdb_readoptions_t* opt, + const char* request_id, + size_t request_id_len) { + if (request_id == nullptr) { + opt->request_id.reset(); + opt->rep.request_id = nullptr; + return; + } + if (!opt->request_id) { + opt->request_id = std::make_unique(); + } + opt->request_id->assign(request_id, request_id_len); + opt->rep.request_id = opt->request_id.get(); +} + +void rocksdb_readoptions_clear_request_id(rocksdb_readoptions_t* opt) { + opt->request_id.reset(); + opt->rep.request_id = nullptr; +} + +const char* rocksdb_readoptions_get_request_id(rocksdb_readoptions_t* opt, + size_t* request_id_len) { + if (opt->rep.request_id == nullptr) { + if (request_id_len != nullptr) { + *request_id_len = 0; + } + return nullptr; + } + if (request_id_len != nullptr) { + *request_id_len = opt->rep.request_id->size(); + } + return opt->rep.request_id->data(); +} + +void rocksdb_readoptions_set_table_filter( + rocksdb_readoptions_t* opt, void* state, void (*destructor)(void*), + rocksdb_readoptions_table_filter_cb table_filter) { + opt->SetTableFilter(state, destructor, table_filter); +} + +void rocksdb_readoptions_clear_table_filter(rocksdb_readoptions_t* opt) { + opt->ClearTableFilter(); +} + +unsigned char rocksdb_readoptions_has_table_filter( + const rocksdb_readoptions_t* opt) { + return opt->table_filter_callback != nullptr; +} + +void rocksdb_readoptions_set_table_index_factory_from_string( + rocksdb_readoptions_t* opt, const char* value, size_t value_len, + char** errptr) { + opt->table_index_factory.reset(); + opt->rep.table_index_factory = nullptr; + if (value == nullptr) { + return; + } + + std::shared_ptr factory; + Status s = LoadUserDefinedIndexFactoryFromString(value, value_len, &factory); + if (SaveError(errptr, s)) { + return; + } + opt->table_index_factory = std::move(factory); + opt->rep.table_index_factory = opt->table_index_factory.get(); +} + +void rocksdb_readoptions_clear_table_index_factory(rocksdb_readoptions_t* opt) { + opt->table_index_factory.reset(); + opt->rep.table_index_factory = nullptr; +} + +const char* rocksdb_readoptions_get_table_index_factory_name( + const rocksdb_readoptions_t* opt, size_t* name_len) { + if (opt->table_index_factory == nullptr) { + if (name_len != nullptr) { + *name_len = 0; + } + return nullptr; + } + const char* name = opt->table_index_factory->Name(); + if (name_len != nullptr) { + *name_len = strlen(name); + } + return name; } rocksdb_writeoptions_t* rocksdb_writeoptions_create() { @@ -6345,62 +7202,36 @@ rocksdb_writeoptions_t* rocksdb_writeoptions_create() { void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t* opt) { delete opt; } -void rocksdb_writeoptions_set_sync(rocksdb_writeoptions_t* opt, - unsigned char v) { - opt->rep.sync = v; +rocksdb_compaction_options_t* rocksdb_compaction_options_create() { + return new rocksdb_compaction_options_t; } -unsigned char rocksdb_writeoptions_get_sync(rocksdb_writeoptions_t* opt) { - return opt->rep.sync; +void rocksdb_compaction_options_destroy(rocksdb_compaction_options_t* opt) { + delete opt; } -void rocksdb_writeoptions_disable_WAL(rocksdb_writeoptions_t* opt, - int disable) { - opt->rep.disableWAL = disable; +unsigned char* rocksdb_compaction_options_canceled_create() { + return reinterpret_cast(new std::atomic(false)); } -unsigned char rocksdb_writeoptions_get_disable_WAL( - rocksdb_writeoptions_t* opt) { - return opt->rep.disableWAL; +void rocksdb_compaction_options_canceled_destroy(unsigned char* canceled) { + if (canceled != nullptr) { + delete reinterpret_cast*>(canceled); + } } -void rocksdb_writeoptions_set_ignore_missing_column_families( - rocksdb_writeoptions_t* opt, unsigned char v) { - opt->rep.ignore_missing_column_families = v; +void rocksdb_compaction_options_canceled_set(unsigned char* canceled, + unsigned char value) { + if (canceled != nullptr) { + reinterpret_cast*>(canceled)->store(value != 0); + } } -unsigned char rocksdb_writeoptions_get_ignore_missing_column_families( - rocksdb_writeoptions_t* opt) { - return opt->rep.ignore_missing_column_families; -} - -void rocksdb_writeoptions_set_no_slowdown(rocksdb_writeoptions_t* opt, - unsigned char v) { - opt->rep.no_slowdown = v; -} - -unsigned char rocksdb_writeoptions_get_no_slowdown( - rocksdb_writeoptions_t* opt) { - return opt->rep.no_slowdown; -} - -void rocksdb_writeoptions_set_low_pri(rocksdb_writeoptions_t* opt, - unsigned char v) { - opt->rep.low_pri = v; -} - -unsigned char rocksdb_writeoptions_get_low_pri(rocksdb_writeoptions_t* opt) { - return opt->rep.low_pri; -} - -void rocksdb_writeoptions_set_memtable_insert_hint_per_batch( - rocksdb_writeoptions_t* opt, unsigned char v) { - opt->rep.memtable_insert_hint_per_batch = v; -} - -unsigned char rocksdb_writeoptions_get_memtable_insert_hint_per_batch( - rocksdb_writeoptions_t* opt) { - return opt->rep.memtable_insert_hint_per_batch; +void rocksdb_compaction_options_set_canceled( + rocksdb_compaction_options_t* options, unsigned char* canceled) { + options->rep.canceled = canceled != nullptr + ? reinterpret_cast*>(canceled) + : nullptr; } rocksdb_compactoptions_t* rocksdb_compactoptions_create() { @@ -6497,13 +7328,20 @@ rocksdb_flushoptions_t* rocksdb_flushoptions_create() { void rocksdb_flushoptions_destroy(rocksdb_flushoptions_t* opt) { delete opt; } -void rocksdb_flushoptions_set_wait(rocksdb_flushoptions_t* opt, - unsigned char v) { - opt->rep.wait = v; +rocksdb_flushwaloptions_t* rocksdb_flushwaloptions_create() { + return new rocksdb_flushwaloptions_t; } -unsigned char rocksdb_flushoptions_get_wait(rocksdb_flushoptions_t* opt) { - return opt->rep.wait; +void rocksdb_flushwaloptions_destroy(rocksdb_flushwaloptions_t* opt) { + delete opt; +} + +void rocksdb_flush_wal_with_options(rocksdb_t* db, + const rocksdb_flushwaloptions_t* options, + char** errptr) { + FlushWALOptions default_options; + SaveError(errptr, + db->rep->FlushWAL(GetFlushWALOptions(options, &default_options))); } rocksdb_memory_allocator_t* rocksdb_jemalloc_nodump_allocator_create( @@ -6643,14 +7481,16 @@ size_t rocksdb_cache_get_occupancy_count(const rocksdb_cache_t* cache) { rocksdb_write_buffer_manager_t* rocksdb_write_buffer_manager_create( size_t buffer_size, bool allow_stall) { rocksdb_write_buffer_manager_t* wbm = new rocksdb_write_buffer_manager_t; - wbm->rep.reset(new WriteBufferManager(buffer_size, {}, allow_stall)); + wbm->rep = std::make_shared( + buffer_size, std::shared_ptr{}, allow_stall); return wbm; } rocksdb_write_buffer_manager_t* rocksdb_write_buffer_manager_create_with_cache( size_t buffer_size, const rocksdb_cache_t* cache, bool allow_stall) { rocksdb_write_buffer_manager_t* wbm = new rocksdb_write_buffer_manager_t; - wbm->rep.reset(new WriteBufferManager(buffer_size, cache->rep, allow_stall)); + wbm->rep = std::make_shared(buffer_size, cache->rep, + allow_stall); return wbm; } @@ -6850,6 +7690,303 @@ rocksdb_envoptions_t* rocksdb_envoptions_create() { void rocksdb_envoptions_destroy(rocksdb_envoptions_t* opt) { delete opt; } +void rocksdb_envoptions_set_rate_limiter(rocksdb_envoptions_t* opt, + rocksdb_ratelimiter_t* rate_limiter) { + opt->rate_limiter = rate_limiter != nullptr ? rate_limiter->rep : nullptr; + opt->rep.rate_limiter = opt->rate_limiter.get(); +} + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4190) // C-linkage function returning C++ type +#endif +static Status CreateFileTraceWriter( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const char* trace_path, + std::unique_ptr* trace_writer, + Env** trace_env_out) { + Env* trace_env = env != nullptr ? env->rep : db->rep->GetEnv(); + EnvOptions default_env_options; + const EnvOptions& resolved_env_options = + env_options != nullptr ? env_options->rep : default_env_options; + *trace_env_out = trace_env; + return NewFileTraceWriter(trace_env, resolved_env_options, + std::string(trace_path), trace_writer); +} + +static Status CreateFileTraceReader( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const char* trace_path, std::unique_ptr* trace_reader) { + Env* trace_env = env != nullptr ? env->rep : db->rep->GetEnv(); + EnvOptions default_env_options; + const EnvOptions& resolved_env_options = + env_options != nullptr ? env_options->rep : default_env_options; + return NewFileTraceReader(trace_env, resolved_env_options, + std::string(trace_path), trace_reader); +} +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +rocksdb_trace_options_t* rocksdb_trace_options_create() { + return new rocksdb_trace_options_t; +} + +void rocksdb_trace_options_destroy(rocksdb_trace_options_t* options) { + delete options; +} + +rocksdb_trace_reader_t* rocksdb_trace_reader_create( + rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const char* trace_path, char** errptr) { + if (env == nullptr) { + SaveError(errptr, Status::InvalidArgument("env must not be null")); + return nullptr; + } + auto* result = new rocksdb_trace_reader_t; + EnvOptions default_env_options; + const EnvOptions& resolved_env_options = + env_options != nullptr ? env_options->rep : default_env_options; + if (SaveError(errptr, + NewFileTraceReader(env->rep, resolved_env_options, + std::string(trace_path), &result->rep))) { + delete result; + return nullptr; + } + return result; +} + +char* rocksdb_trace_reader_read(rocksdb_trace_reader_t* reader, size_t* size, + char** errptr) { + std::string data; + Status s = reader->rep->Read(&data); + if (s.IsIncomplete()) { + *size = 0; + return nullptr; + } + if (SaveError(errptr, s)) { + *size = 0; + return nullptr; + } + *size = data.size(); + return CopyString(Slice(data)); +} + +void rocksdb_trace_reader_reset(rocksdb_trace_reader_t* reader, char** errptr) { + SaveError(errptr, reader->rep->Reset()); +} + +void rocksdb_trace_reader_close(rocksdb_trace_reader_t* reader, char** errptr) { + SaveError(errptr, reader->rep->Close()); +} + +void rocksdb_trace_reader_destroy(rocksdb_trace_reader_t* reader) { + delete reader; +} + +rocksdb_replay_options_t* rocksdb_replay_options_create() { + return new rocksdb_replay_options_t; +} + +void rocksdb_replay_options_destroy(rocksdb_replay_options_t* options) { + delete options; +} + +void rocksdb_replay_options_set_num_threads(rocksdb_replay_options_t* options, + uint32_t num_threads) { + options->rep.num_threads = num_threads; +} + +uint32_t rocksdb_replay_options_get_num_threads( + rocksdb_replay_options_t* options) { + return options->rep.num_threads; +} + +void rocksdb_replay_options_set_fast_forward(rocksdb_replay_options_t* options, + double fast_forward) { + options->rep.fast_forward = fast_forward; +} + +double rocksdb_replay_options_get_fast_forward( + rocksdb_replay_options_t* options) { + return options->rep.fast_forward; +} + +rocksdb_replayer_t* rocksdb_new_default_replayer( + rocksdb_t* db, rocksdb_column_family_handle_t** column_families, + size_t num_column_families, rocksdb_env_t* env, + const rocksdb_envoptions_t* env_options, const char* trace_path, + char** errptr) { + if (column_families == nullptr && num_column_families > 0) { + SaveError(errptr, Status::InvalidArgument( + "column_families must not be null when count > 0")); + return nullptr; + } + + auto* result = new rocksdb_replayer_t; + std::vector handles; + if (num_column_families == 0) { + handles.push_back(db->rep->DefaultColumnFamily()); + } else { + handles.reserve(num_column_families); + for (size_t i = 0; i < num_column_families; ++i) { + handles.push_back(column_families[i]->rep); + } + } + + std::unique_ptr trace_reader; + if (SaveError(errptr, CreateFileTraceReader(db, env, env_options, trace_path, + &trace_reader))) { + delete result; + return nullptr; + } + if (SaveError(errptr, db->rep->NewDefaultReplayer( + handles, std::move(trace_reader), &result->rep))) { + delete result; + return nullptr; + } + return result; +} + +void rocksdb_replayer_prepare(rocksdb_replayer_t* replayer, char** errptr) { + SaveError(errptr, replayer->rep->Prepare()); +} + +uint64_t rocksdb_replayer_get_header_timestamp( + const rocksdb_replayer_t* replayer) { + return replayer->rep->GetHeaderTimestamp(); +} + +void rocksdb_replayer_replay(rocksdb_replayer_t* replayer, + const rocksdb_replay_options_t* options, + char** errptr) { + ReplayOptions default_options; + const ReplayOptions& replay_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, replayer->rep->Replay(replay_options, nullptr)); +} + +void rocksdb_replayer_destroy(rocksdb_replayer_t* replayer) { delete replayer; } + +rocksdb_block_cache_trace_options_t* +rocksdb_block_cache_trace_options_create() { + return new rocksdb_block_cache_trace_options_t; +} + +void rocksdb_block_cache_trace_options_destroy( + rocksdb_block_cache_trace_options_t* options) { + delete options; +} + +rocksdb_block_cache_trace_writer_options_t* +rocksdb_block_cache_trace_writer_options_create() { + return new rocksdb_block_cache_trace_writer_options_t; +} + +void rocksdb_block_cache_trace_writer_options_destroy( + rocksdb_block_cache_trace_writer_options_t* options) { + delete options; +} + +void rocksdb_start_trace(rocksdb_t* db, rocksdb_env_t* env, + const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, + const char* trace_path, char** errptr) { + std::unique_ptr trace_writer; + Env* trace_env = nullptr; + Status s = CreateFileTraceWriter(db, env, env_options, trace_path, + &trace_writer, &trace_env); + if (SaveError(errptr, s)) { + return; + } + (void)trace_env; + + TraceOptions default_options; + const TraceOptions& trace_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, + db->rep->StartTrace(trace_options, std::move(trace_writer))); +} + +void rocksdb_end_trace(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->EndTrace()); +} + +void rocksdb_start_io_trace(rocksdb_t* db, rocksdb_env_t* env, + const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, + const char* trace_path, char** errptr) { + std::unique_ptr trace_writer; + Env* trace_env = nullptr; + Status s = CreateFileTraceWriter(db, env, env_options, trace_path, + &trace_writer, &trace_env); + if (SaveError(errptr, s)) { + return; + } + (void)trace_env; + + TraceOptions default_options; + const TraceOptions& trace_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, + db->rep->StartIOTrace(trace_options, std::move(trace_writer))); +} + +void rocksdb_end_io_trace(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->EndIOTrace()); +} + +void rocksdb_start_block_cache_trace(rocksdb_t* db, rocksdb_env_t* env, + const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, + const char* trace_path, char** errptr) { + std::unique_ptr trace_writer; + Env* trace_env = nullptr; + Status s = CreateFileTraceWriter(db, env, env_options, trace_path, + &trace_writer, &trace_env); + if (SaveError(errptr, s)) { + return; + } + (void)trace_env; + + TraceOptions default_options; + const TraceOptions& trace_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, db->rep->StartBlockCacheTrace(trace_options, + std::move(trace_writer))); +} + +void rocksdb_start_block_cache_trace_with_options( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const rocksdb_block_cache_trace_options_t* options, + const rocksdb_block_cache_trace_writer_options_t* writer_options, + const char* trace_path, char** errptr) { + std::unique_ptr trace_writer; + Env* trace_env = nullptr; + Status s = CreateFileTraceWriter(db, env, env_options, trace_path, + &trace_writer, &trace_env); + if (SaveError(errptr, s)) { + return; + } + + BlockCacheTraceOptions default_options; + const BlockCacheTraceOptions& block_cache_trace_options = + options != nullptr ? options->rep : default_options; + BlockCacheTraceWriterOptions default_writer_options; + const BlockCacheTraceWriterOptions& block_cache_trace_writer_options = + writer_options != nullptr ? writer_options->rep : default_writer_options; + auto block_trace_writer = NewBlockCacheTraceWriter( + trace_env->GetSystemClock().get(), block_cache_trace_writer_options, + std::move(trace_writer)); + SaveError(errptr, + db->rep->StartBlockCacheTrace(block_cache_trace_options, + std::move(block_trace_writer))); +} + +void rocksdb_end_block_cache_trace(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->EndBlockCacheTrace()); +} + rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create( const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options) { rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t; @@ -7029,8 +8166,14 @@ rocksdb_slicetransform_t* rocksdb_slicetransform_create( void rocksdb_slicetransform_destroy(rocksdb_slicetransform_t* st) { delete st; } struct SliceTransformWrapper : public rocksdb_slicetransform_t { - const SliceTransform* rep_; + const SliceTransform* rep_ = nullptr; + SliceTransformWrapper() = default; ~SliceTransformWrapper() override { delete rep_; } + // Owns rep_ (deleted in the destructor); not copyable or movable. + SliceTransformWrapper(const SliceTransformWrapper&) = delete; + SliceTransformWrapper& operator=(const SliceTransformWrapper&) = delete; + SliceTransformWrapper(SliceTransformWrapper&&) = delete; + SliceTransformWrapper& operator=(SliceTransformWrapper&&) = delete; const char* Name() const override { return rep_->Name(); } std::string GetId() const override { return rep_->GetId(); } Slice Transform(const Slice& src) const override { @@ -7267,6 +8410,92 @@ uint64_t rocksdb_livefiles_deletions(const rocksdb_livefiles_t* lf, int index) { void rocksdb_livefiles_destroy(const rocksdb_livefiles_t* lf) { delete lf; } +rocksdb_livefiles_storage_info_options_t* +rocksdb_livefiles_storage_info_options_create() { + return new rocksdb_livefiles_storage_info_options_t; +} + +void rocksdb_livefiles_storage_info_options_destroy( + rocksdb_livefiles_storage_info_options_t* options) { + delete options; +} + +rocksdb_livefiles_storage_info_t* rocksdb_get_livefiles_storage_info( + rocksdb_t* db, const rocksdb_livefiles_storage_info_options_t* options, + char** errptr) { + auto* result = new rocksdb_livefiles_storage_info_t; + LiveFilesStorageInfoOptions default_options; + const LiveFilesStorageInfoOptions& storage_options = + options != nullptr ? options->rep : default_options; + if (SaveError(errptr, db->rep->GetLiveFilesStorageInfo(storage_options, + &result->rep))) { + delete result; + return nullptr; + } + return result; +} + +size_t rocksdb_livefiles_storage_info_count( + const rocksdb_livefiles_storage_info_t* info) { + return info->rep.size(); +} + +const char* rocksdb_livefiles_storage_info_relative_filename( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].relative_filename.c_str(); +} + +const char* rocksdb_livefiles_storage_info_directory( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].directory.c_str(); +} + +uint64_t rocksdb_livefiles_storage_info_file_number( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].file_number; +} + +int rocksdb_livefiles_storage_info_file_type( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return static_cast(info->rep[index].file_type); +} + +uint64_t rocksdb_livefiles_storage_info_size( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].size; +} + +int rocksdb_livefiles_storage_info_temperature( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return static_cast(info->rep[index].temperature); +} + +const char* rocksdb_livefiles_storage_info_file_checksum( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].file_checksum.c_str(); +} + +const char* rocksdb_livefiles_storage_info_file_checksum_func_name( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].file_checksum_func_name.c_str(); +} + +const char* rocksdb_livefiles_storage_info_replacement_contents( + const rocksdb_livefiles_storage_info_t* info, size_t index, size_t* size) { + *size = info->rep[index].replacement_contents.size(); + return info->rep[index].replacement_contents.data(); +} + +unsigned char rocksdb_livefiles_storage_info_trim_to_size( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].trim_to_size; +} + +void rocksdb_livefiles_storage_info_destroy( + rocksdb_livefiles_storage_info_t* info) { + delete info; +} + rocksdb_livefile_t* rocksdb_livefile_create() { return new rocksdb_livefile_t; } void rocksdb_livefile_set_column_family_name(rocksdb_livefile_t* lf, @@ -7344,7 +8573,8 @@ void rocksdb_get_options_from_string(const rocksdb_options_t* base_options, void rocksdb_delete_file_in_range(rocksdb_t* db, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len, char** errptr) { - Slice a, b; + Slice a; + Slice b; SaveError( errptr, DeleteFilesInRange( @@ -7357,7 +8587,8 @@ void rocksdb_delete_file_in_range_cf( rocksdb_t* db, rocksdb_column_family_handle_t* column_family, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len, char** errptr) { - Slice a, b; + Slice a; + Slice b; SaveError( errptr, DeleteFilesInRange( @@ -7375,6 +8606,83 @@ rocksdb_column_family_metadata_t* rocksdb_get_column_family_metadata( return meta; } +rocksdb_column_family_metadata_t* +rocksdb_get_column_family_metadata_with_options( + rocksdb_t* db, const rocksdb_column_family_metadata_options_t* options) { + rocksdb_column_family_metadata_t* meta = new rocksdb_column_family_metadata_t; + GetColumnFamilyMetaDataOptions default_options; + const GetColumnFamilyMetaDataOptions& metadata_options = + options != nullptr ? options->rep : default_options; + db->rep->GetColumnFamilyMetaData(metadata_options, &meta->rep); + return meta; +} + +rocksdb_column_family_metadata_options_t* +rocksdb_column_family_metadata_options_create() { + auto* options = new rocksdb_column_family_metadata_options_t; + SyncColumnFamilyMetadataOptionsRange(options); + return options; +} + +void rocksdb_column_family_metadata_options_destroy( + rocksdb_column_family_metadata_options_t* options) { + delete options; +} + +void rocksdb_column_family_metadata_options_set_start_key( + rocksdb_column_family_metadata_options_t* options, const char* key, + size_t key_len) { + if (key == nullptr) { + options->start_key.clear(); + options->has_start_key = false; + } else { + options->start_key.assign(key, key_len); + options->has_start_key = true; + } + SyncColumnFamilyMetadataOptionsRange(options); +} + +const char* rocksdb_column_family_metadata_options_get_start_key( + const rocksdb_column_family_metadata_options_t* options, size_t* key_len) { + if (!options->has_start_key) { + if (key_len != nullptr) { + *key_len = 0; + } + return nullptr; + } + if (key_len != nullptr) { + *key_len = options->start_key.size(); + } + return options->start_key.data(); +} + +void rocksdb_column_family_metadata_options_set_end_key( + rocksdb_column_family_metadata_options_t* options, const char* key, + size_t key_len) { + if (key == nullptr) { + options->end_key.clear(); + options->has_end_key = false; + } else { + options->end_key.assign(key, key_len); + options->has_end_key = true; + } + SyncColumnFamilyMetadataOptionsRange(options); +} + +const char* rocksdb_column_family_metadata_options_get_end_key( + const rocksdb_column_family_metadata_options_t* options, size_t* key_len) { + if (!options->has_end_key) { + if (key_len != nullptr) { + *key_len = 0; + } + return nullptr; + } + if (key_len != nullptr) { + *key_len = options->end_key.size(); + } + return options->end_key.data(); +} + rocksdb_column_family_metadata_t* rocksdb_get_column_family_metadata_cf( rocksdb_t* db, rocksdb_column_family_handle_t* column_family) { rocksdb_column_family_metadata_t* meta = new rocksdb_column_family_metadata_t; @@ -7382,6 +8690,19 @@ rocksdb_column_family_metadata_t* rocksdb_get_column_family_metadata_cf( return meta; } +rocksdb_column_family_metadata_t* +rocksdb_get_column_family_metadata_cf_with_options( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const rocksdb_column_family_metadata_options_t* options) { + rocksdb_column_family_metadata_t* meta = new rocksdb_column_family_metadata_t; + GetColumnFamilyMetaDataOptions default_options; + const GetColumnFamilyMetaDataOptions& metadata_options = + options != nullptr ? options->rep : default_options; + db->rep->GetColumnFamilyMetaData(column_family->rep, metadata_options, + &meta->rep); + return meta; +} + void rocksdb_column_family_metadata_destroy( rocksdb_column_family_metadata_t* cf_meta) { delete cf_meta; @@ -7545,36 +8866,6 @@ void rocksdb_transactiondb_options_destroy( delete opt; } -void rocksdb_transactiondb_options_set_max_num_locks( - rocksdb_transactiondb_options_t* opt, int64_t max_num_locks) { - opt->rep.max_num_locks = max_num_locks; -} - -void rocksdb_transactiondb_options_set_num_stripes( - rocksdb_transactiondb_options_t* opt, size_t num_stripes) { - opt->rep.num_stripes = num_stripes; -} - -void rocksdb_transactiondb_options_set_transaction_lock_timeout( - rocksdb_transactiondb_options_t* opt, int64_t txn_lock_timeout) { - opt->rep.transaction_lock_timeout = txn_lock_timeout; -} - -void rocksdb_transactiondb_options_set_default_lock_timeout( - rocksdb_transactiondb_options_t* opt, int64_t default_lock_timeout) { - opt->rep.default_lock_timeout = default_lock_timeout; -} - -void rocksdb_transactiondb_options_set_write_policy( - rocksdb_transactiondb_options_t* opt, int write_policy) { - opt->rep.write_policy = static_cast(write_policy); -} - -void rocksdb_transactiondb_options_set_use_per_key_point_lock_mgr( - rocksdb_transactiondb_options_t* opt, int use_per_key_point_lock_mgr) { - opt->rep.use_per_key_point_lock_mgr = use_per_key_point_lock_mgr; -} - rocksdb_transaction_options_t* rocksdb_transaction_options_create() { return new rocksdb_transaction_options_t; } @@ -7583,34 +8874,3213 @@ void rocksdb_transaction_options_destroy(rocksdb_transaction_options_t* opt) { delete opt; } +rocksdb_optimistictransactiondb_lock_buckets_t* +rocksdb_optimistictransactiondb_lock_buckets_create( + size_t bucket_count, unsigned char cache_aligned) { + auto* lock_buckets = new rocksdb_optimistictransactiondb_lock_buckets_t; + lock_buckets->rep = + MakeSharedOccLockBuckets(bucket_count, cache_aligned != 0); + return lock_buckets; +} + +size_t rocksdb_optimistictransactiondb_lock_buckets_approximate_memory_usage( + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets) { + return lock_buckets->rep->ApproximateMemoryUsage(); +} + +void rocksdb_optimistictransactiondb_lock_buckets_destroy( + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets) { + delete lock_buckets; +} + +rocksdb_optimistictransactiondb_options_t* +rocksdb_optimistictransactiondb_options_create() { + return new rocksdb_optimistictransactiondb_options_t; +} + +void rocksdb_optimistictransactiondb_options_destroy( + rocksdb_optimistictransactiondb_options_t* opt) { + delete opt; +} + +void rocksdb_optimistictransactiondb_options_set_shared_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt, + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets) { + opt->rep.shared_lock_buckets = + lock_buckets != nullptr ? lock_buckets->rep : nullptr; +} + +// Hand-written bindings for ABI-frozen options with type mismatches between +// the legacy C API and the underlying C++ field types. These are blocklisted +// from auto-generation to avoid conflicting declarations. +void rocksdb_options_set_writable_file_max_buffer_size(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.writable_file_max_buffer_size = static_cast(v); +} +uint64_t rocksdb_options_get_writable_file_max_buffer_size( + rocksdb_options_t* opt) { + return opt->rep.writable_file_max_buffer_size; +} +void rocksdb_options_set_soft_pending_compaction_bytes_limit( + rocksdb_options_t* opt, size_t v) { + opt->rep.soft_pending_compaction_bytes_limit = v; +} +size_t rocksdb_options_get_soft_pending_compaction_bytes_limit( + rocksdb_options_t* opt) { + return opt->rep.soft_pending_compaction_bytes_limit; +} +void rocksdb_options_set_hard_pending_compaction_bytes_limit( + rocksdb_options_t* opt, size_t v) { + opt->rep.hard_pending_compaction_bytes_limit = v; +} +size_t rocksdb_options_get_hard_pending_compaction_bytes_limit( + rocksdb_options_t* opt) { + return opt->rep.hard_pending_compaction_bytes_limit; +} +void rocksdb_options_set_max_manifest_file_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.max_manifest_file_size = v; +} +size_t rocksdb_options_get_max_manifest_file_size(rocksdb_options_t* opt) { + return opt->rep.max_manifest_file_size; +} + +// BEGIN generated: c_generated_option_structs_auto.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/advanced_options.h +// - include/rocksdb/block_cache_trace_writer.h +// - include/rocksdb/env.h +// - include/rocksdb/metadata.h +// - include/rocksdb/options.h +// - include/rocksdb/table.h +// - include/rocksdb/universal_compaction.h +// - include/rocksdb/utilities/backup_engine.h +// - include/rocksdb/utilities/optimistic_transaction_db.h +// - include/rocksdb/utilities/transaction_db.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered option structs simple + +/* DBOptions */ + +void rocksdb_options_set_create_if_missing(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.create_if_missing = v; +} + +unsigned char rocksdb_options_get_create_if_missing(rocksdb_options_t* opt) { + return opt->rep.create_if_missing; +} + +void rocksdb_options_set_create_missing_column_families(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.create_missing_column_families = v; +} + +unsigned char rocksdb_options_get_create_missing_column_families( + rocksdb_options_t* opt) { + return opt->rep.create_missing_column_families; +} + +void rocksdb_options_set_error_if_exists(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.error_if_exists = v; +} + +unsigned char rocksdb_options_get_error_if_exists(rocksdb_options_t* opt) { + return opt->rep.error_if_exists; +} + +void rocksdb_options_set_paranoid_checks(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.paranoid_checks = v; +} + +unsigned char rocksdb_options_get_paranoid_checks(rocksdb_options_t* opt) { + return opt->rep.paranoid_checks; +} + +void rocksdb_options_set_flush_verify_memtable_count(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.flush_verify_memtable_count = v; +} + +unsigned char rocksdb_options_get_flush_verify_memtable_count( + rocksdb_options_t* opt) { + return opt->rep.flush_verify_memtable_count; +} + +void rocksdb_options_set_compaction_verify_record_count(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.compaction_verify_record_count = v; +} + +unsigned char rocksdb_options_get_compaction_verify_record_count( + rocksdb_options_t* opt) { + return opt->rep.compaction_verify_record_count; +} + +void rocksdb_options_set_track_and_verify_wals_in_manifest( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.track_and_verify_wals_in_manifest = v; +} + +unsigned char rocksdb_options_get_track_and_verify_wals_in_manifest( + rocksdb_options_t* opt) { + return opt->rep.track_and_verify_wals_in_manifest; +} + +void rocksdb_options_set_track_and_verify_wals(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.track_and_verify_wals = v; +} + +unsigned char rocksdb_options_get_track_and_verify_wals( + rocksdb_options_t* opt) { + return opt->rep.track_and_verify_wals; +} + +void rocksdb_options_set_verify_sst_unique_id_in_manifest( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.verify_sst_unique_id_in_manifest = v; +} + +unsigned char rocksdb_options_get_verify_sst_unique_id_in_manifest( + rocksdb_options_t* opt) { + return opt->rep.verify_sst_unique_id_in_manifest; +} + +void rocksdb_options_set_info_log_level(rocksdb_options_t* opt, int v) { + opt->rep.info_log_level = static_castrep.info_log_level)>(v); +} + +int rocksdb_options_get_info_log_level(rocksdb_options_t* opt) { + return static_cast(opt->rep.info_log_level); +} + +void rocksdb_options_set_max_open_files(rocksdb_options_t* opt, int v) { + opt->rep.max_open_files = v; +} + +int rocksdb_options_get_max_open_files(rocksdb_options_t* opt) { + return opt->rep.max_open_files; +} + +void rocksdb_options_set_max_file_opening_threads(rocksdb_options_t* opt, + int v) { + opt->rep.max_file_opening_threads = v; +} + +int rocksdb_options_get_max_file_opening_threads(rocksdb_options_t* opt) { + return opt->rep.max_file_opening_threads; +} + +void rocksdb_options_set_open_files_async(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.open_files_async = v; +} + +unsigned char rocksdb_options_get_open_files_async(rocksdb_options_t* opt) { + return opt->rep.open_files_async; +} + +void rocksdb_options_set_max_total_wal_size(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.max_total_wal_size = v; +} + +uint64_t rocksdb_options_get_max_total_wal_size(rocksdb_options_t* opt) { + return opt->rep.max_total_wal_size; +} + +void rocksdb_options_set_db_log_dir(rocksdb_options_t* opt, const char* v) { + opt->rep.db_log_dir = v; +} + +const char* rocksdb_options_get_db_log_dir(rocksdb_options_t* opt, + size_t* size) { + *size = opt->rep.db_log_dir.size(); + return opt->rep.db_log_dir.data(); +} + +void rocksdb_options_set_wal_dir(rocksdb_options_t* opt, const char* v) { + opt->rep.wal_dir = v; +} + +const char* rocksdb_options_get_wal_dir(rocksdb_options_t* opt, size_t* size) { + *size = opt->rep.wal_dir.size(); + return opt->rep.wal_dir.data(); +} + +void rocksdb_options_set_delete_obsolete_files_period_micros( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.delete_obsolete_files_period_micros = v; +} + +uint64_t rocksdb_options_get_delete_obsolete_files_period_micros( + rocksdb_options_t* opt) { + return opt->rep.delete_obsolete_files_period_micros; +} + +void rocksdb_options_set_max_background_jobs(rocksdb_options_t* opt, int v) { + opt->rep.max_background_jobs = v; +} + +int rocksdb_options_get_max_background_jobs(rocksdb_options_t* opt) { + return opt->rep.max_background_jobs; +} + +void rocksdb_options_set_max_background_compactions(rocksdb_options_t* opt, + int v) { + opt->rep.max_background_compactions = v; +} + +int rocksdb_options_get_max_background_compactions(rocksdb_options_t* opt) { + return opt->rep.max_background_compactions; +} + +void rocksdb_options_set_max_subcompactions(rocksdb_options_t* opt, + uint32_t v) { + opt->rep.max_subcompactions = v; +} + +uint32_t rocksdb_options_get_max_subcompactions(rocksdb_options_t* opt) { + return opt->rep.max_subcompactions; +} + +void rocksdb_options_set_max_background_flushes(rocksdb_options_t* opt, int v) { + opt->rep.max_background_flushes = v; +} + +int rocksdb_options_get_max_background_flushes(rocksdb_options_t* opt) { + return opt->rep.max_background_flushes; +} + +void rocksdb_options_set_max_log_file_size(rocksdb_options_t* opt, size_t v) { + opt->rep.max_log_file_size = v; +} + +size_t rocksdb_options_get_max_log_file_size(rocksdb_options_t* opt) { + return opt->rep.max_log_file_size; +} + +void rocksdb_options_set_log_file_time_to_roll(rocksdb_options_t* opt, + size_t v) { + opt->rep.log_file_time_to_roll = v; +} + +size_t rocksdb_options_get_log_file_time_to_roll(rocksdb_options_t* opt) { + return opt->rep.log_file_time_to_roll; +} + +void rocksdb_options_set_keep_log_file_num(rocksdb_options_t* opt, size_t v) { + opt->rep.keep_log_file_num = v; +} + +size_t rocksdb_options_get_keep_log_file_num(rocksdb_options_t* opt) { + return opt->rep.keep_log_file_num; +} + +void rocksdb_options_set_recycle_log_file_num(rocksdb_options_t* opt, + size_t v) { + opt->rep.recycle_log_file_num = v; +} + +size_t rocksdb_options_get_recycle_log_file_num(rocksdb_options_t* opt) { + return opt->rep.recycle_log_file_num; +} + +void rocksdb_options_set_async_wal_precreate(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.async_wal_precreate = v; +} + +unsigned char rocksdb_options_get_async_wal_precreate(rocksdb_options_t* opt) { + return opt->rep.async_wal_precreate; +} + +void rocksdb_options_set_verify_manifest_content_on_close( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.verify_manifest_content_on_close = v; +} + +unsigned char rocksdb_options_get_verify_manifest_content_on_close( + rocksdb_options_t* opt) { + return opt->rep.verify_manifest_content_on_close; +} + +void rocksdb_options_set_optimize_manifest_for_recovery(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.optimize_manifest_for_recovery = v; +} + +unsigned char rocksdb_options_get_optimize_manifest_for_recovery( + rocksdb_options_t* opt) { + return opt->rep.optimize_manifest_for_recovery; +} + +void rocksdb_options_set_reuse_manifest_on_open(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.reuse_manifest_on_open = v; +} + +unsigned char rocksdb_options_get_reuse_manifest_on_open( + rocksdb_options_t* opt) { + return opt->rep.reuse_manifest_on_open; +} + +void rocksdb_options_set_max_manifest_space_amp_pct(rocksdb_options_t* opt, + int v) { + opt->rep.max_manifest_space_amp_pct = v; +} + +int rocksdb_options_get_max_manifest_space_amp_pct(rocksdb_options_t* opt) { + return opt->rep.max_manifest_space_amp_pct; +} + +void rocksdb_options_set_table_cache_numshardbits(rocksdb_options_t* opt, + int v) { + opt->rep.table_cache_numshardbits = v; +} + +int rocksdb_options_get_table_cache_numshardbits(rocksdb_options_t* opt) { + return opt->rep.table_cache_numshardbits; +} + +void rocksdb_options_set_WAL_ttl_seconds(rocksdb_options_t* opt, uint64_t v) { + opt->rep.WAL_ttl_seconds = v; +} + +uint64_t rocksdb_options_get_WAL_ttl_seconds(rocksdb_options_t* opt) { + return opt->rep.WAL_ttl_seconds; +} + +void rocksdb_options_set_WAL_size_limit_MB(rocksdb_options_t* opt, uint64_t v) { + opt->rep.WAL_size_limit_MB = v; +} + +uint64_t rocksdb_options_get_WAL_size_limit_MB(rocksdb_options_t* opt) { + return opt->rep.WAL_size_limit_MB; +} + +void rocksdb_options_set_manifest_preallocation_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.manifest_preallocation_size = v; +} + +size_t rocksdb_options_get_manifest_preallocation_size(rocksdb_options_t* opt) { + return opt->rep.manifest_preallocation_size; +} + +void rocksdb_options_set_allow_mmap_reads(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_mmap_reads = v; +} + +unsigned char rocksdb_options_get_allow_mmap_reads(rocksdb_options_t* opt) { + return opt->rep.allow_mmap_reads; +} + +void rocksdb_options_set_allow_mmap_writes(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_mmap_writes = v; +} + +unsigned char rocksdb_options_get_allow_mmap_writes(rocksdb_options_t* opt) { + return opt->rep.allow_mmap_writes; +} + +void rocksdb_options_set_use_direct_reads(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.use_direct_reads = v; +} + +unsigned char rocksdb_options_get_use_direct_reads(rocksdb_options_t* opt) { + return opt->rep.use_direct_reads; +} + +void rocksdb_options_set_use_direct_io_for_compaction_reads( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.use_direct_io_for_compaction_reads = v; +} + +unsigned char rocksdb_options_get_use_direct_io_for_compaction_reads( + rocksdb_options_t* opt) { + return opt->rep.use_direct_io_for_compaction_reads; +} + +void rocksdb_options_set_use_direct_io_for_flush_and_compaction( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.use_direct_io_for_flush_and_compaction = v; +} + +unsigned char rocksdb_options_get_use_direct_io_for_flush_and_compaction( + rocksdb_options_t* opt) { + return opt->rep.use_direct_io_for_flush_and_compaction; +} + +void rocksdb_options_set_allow_fallocate(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_fallocate = v; +} + +unsigned char rocksdb_options_get_allow_fallocate(rocksdb_options_t* opt) { + return opt->rep.allow_fallocate; +} + +void rocksdb_options_set_is_fd_close_on_exec(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.is_fd_close_on_exec = v; +} + +unsigned char rocksdb_options_get_is_fd_close_on_exec(rocksdb_options_t* opt) { + return opt->rep.is_fd_close_on_exec; +} + +void rocksdb_options_set_stats_dump_period_sec(rocksdb_options_t* opt, + unsigned int v) { + opt->rep.stats_dump_period_sec = v; +} + +unsigned int rocksdb_options_get_stats_dump_period_sec(rocksdb_options_t* opt) { + return opt->rep.stats_dump_period_sec; +} + +void rocksdb_options_set_stats_persist_period_sec(rocksdb_options_t* opt, + unsigned int v) { + opt->rep.stats_persist_period_sec = v; +} + +unsigned int rocksdb_options_get_stats_persist_period_sec( + rocksdb_options_t* opt) { + return opt->rep.stats_persist_period_sec; +} + +void rocksdb_options_set_persist_stats_to_disk(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.persist_stats_to_disk = v; +} + +unsigned char rocksdb_options_get_persist_stats_to_disk( + rocksdb_options_t* opt) { + return opt->rep.persist_stats_to_disk; +} + +void rocksdb_options_set_stats_history_buffer_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.stats_history_buffer_size = v; +} + +size_t rocksdb_options_get_stats_history_buffer_size(rocksdb_options_t* opt) { + return opt->rep.stats_history_buffer_size; +} + +void rocksdb_options_set_advise_random_on_open(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.advise_random_on_open = v; +} + +unsigned char rocksdb_options_get_advise_random_on_open( + rocksdb_options_t* opt) { + return opt->rep.advise_random_on_open; +} + +void rocksdb_options_set_db_write_buffer_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.db_write_buffer_size = v; +} + +size_t rocksdb_options_get_db_write_buffer_size(rocksdb_options_t* opt) { + return opt->rep.db_write_buffer_size; +} + +void rocksdb_options_compaction_readahead_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.compaction_readahead_size = v; +} + +size_t rocksdb_options_get_compaction_readahead_size(rocksdb_options_t* opt) { + return opt->rep.compaction_readahead_size; +} + +void rocksdb_options_set_use_adaptive_mutex(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.use_adaptive_mutex = v; +} + +unsigned char rocksdb_options_get_use_adaptive_mutex(rocksdb_options_t* opt) { + return opt->rep.use_adaptive_mutex; +} + +void rocksdb_options_set_bytes_per_sync(rocksdb_options_t* opt, uint64_t v) { + opt->rep.bytes_per_sync = v; +} + +uint64_t rocksdb_options_get_bytes_per_sync(rocksdb_options_t* opt) { + return opt->rep.bytes_per_sync; +} + +void rocksdb_options_set_wal_bytes_per_sync(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.wal_bytes_per_sync = v; +} + +uint64_t rocksdb_options_get_wal_bytes_per_sync(rocksdb_options_t* opt) { + return opt->rep.wal_bytes_per_sync; +} + +void rocksdb_options_set_strict_bytes_per_sync(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.strict_bytes_per_sync = v; +} + +unsigned char rocksdb_options_get_strict_bytes_per_sync( + rocksdb_options_t* opt) { + return opt->rep.strict_bytes_per_sync; +} + +void rocksdb_options_set_enable_thread_tracking(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enable_thread_tracking = v; +} + +unsigned char rocksdb_options_get_enable_thread_tracking( + rocksdb_options_t* opt) { + return opt->rep.enable_thread_tracking; +} + +void rocksdb_options_set_delayed_write_rate(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.delayed_write_rate = v; +} + +uint64_t rocksdb_options_get_delayed_write_rate(rocksdb_options_t* opt) { + return opt->rep.delayed_write_rate; +} + +void rocksdb_options_set_enable_pipelined_write(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enable_pipelined_write = v; +} + +unsigned char rocksdb_options_get_enable_pipelined_write( + rocksdb_options_t* opt) { + return opt->rep.enable_pipelined_write; +} + +void rocksdb_options_set_unordered_write(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.unordered_write = v; +} + +unsigned char rocksdb_options_get_unordered_write(rocksdb_options_t* opt) { + return opt->rep.unordered_write; +} + +void rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_concurrent_memtable_write = v; +} + +unsigned char rocksdb_options_get_allow_concurrent_memtable_write( + rocksdb_options_t* opt) { + return opt->rep.allow_concurrent_memtable_write; +} + +void rocksdb_options_set_enable_write_thread_adaptive_yield( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.enable_write_thread_adaptive_yield = v; +} + +unsigned char rocksdb_options_get_enable_write_thread_adaptive_yield( + rocksdb_options_t* opt) { + return opt->rep.enable_write_thread_adaptive_yield; +} + +void rocksdb_options_set_max_write_batch_group_size_bytes( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.max_write_batch_group_size_bytes = v; +} + +uint64_t rocksdb_options_get_max_write_batch_group_size_bytes( + rocksdb_options_t* opt) { + return opt->rep.max_write_batch_group_size_bytes; +} + +void rocksdb_options_set_write_thread_max_yield_usec(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.write_thread_max_yield_usec = v; +} + +uint64_t rocksdb_options_get_write_thread_max_yield_usec( + rocksdb_options_t* opt) { + return opt->rep.write_thread_max_yield_usec; +} + +void rocksdb_options_set_write_thread_slow_yield_usec(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.write_thread_slow_yield_usec = v; +} + +uint64_t rocksdb_options_get_write_thread_slow_yield_usec( + rocksdb_options_t* opt) { + return opt->rep.write_thread_slow_yield_usec; +} + +void rocksdb_options_set_skip_stats_update_on_db_open(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.skip_stats_update_on_db_open = v; +} + +unsigned char rocksdb_options_get_skip_stats_update_on_db_open( + rocksdb_options_t* opt) { + return opt->rep.skip_stats_update_on_db_open; +} + +void rocksdb_options_set_wal_recovery_mode(rocksdb_options_t* opt, int v) { + opt->rep.wal_recovery_mode = + static_castrep.wal_recovery_mode)>(v); +} + +int rocksdb_options_get_wal_recovery_mode(rocksdb_options_t* opt) { + return static_cast(opt->rep.wal_recovery_mode); +} + +void rocksdb_options_set_allow_2pc(rocksdb_options_t* opt, unsigned char v) { + opt->rep.allow_2pc = v; +} + +unsigned char rocksdb_options_get_allow_2pc(rocksdb_options_t* opt) { + return opt->rep.allow_2pc; +} + +void rocksdb_options_set_dump_malloc_stats(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.dump_malloc_stats = v; +} + +unsigned char rocksdb_options_get_dump_malloc_stats(rocksdb_options_t* opt) { + return opt->rep.dump_malloc_stats; +} + +void rocksdb_options_set_avoid_flush_during_recovery(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.avoid_flush_during_recovery = v; +} + +unsigned char rocksdb_options_get_avoid_flush_during_recovery( + rocksdb_options_t* opt) { + return opt->rep.avoid_flush_during_recovery; +} + +void rocksdb_options_set_enforce_write_buffer_manager_during_recovery( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.enforce_write_buffer_manager_during_recovery = v; +} + +unsigned char rocksdb_options_get_enforce_write_buffer_manager_during_recovery( + rocksdb_options_t* opt) { + return opt->rep.enforce_write_buffer_manager_during_recovery; +} + +void rocksdb_options_set_avoid_flush_during_shutdown(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.avoid_flush_during_shutdown = v; +} + +unsigned char rocksdb_options_get_avoid_flush_during_shutdown( + rocksdb_options_t* opt) { + return opt->rep.avoid_flush_during_shutdown; +} + +void rocksdb_options_set_allow_ingest_behind(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_ingest_behind = v; +} + +unsigned char rocksdb_options_get_allow_ingest_behind(rocksdb_options_t* opt) { + return opt->rep.allow_ingest_behind; +} + +void rocksdb_options_set_two_write_queues(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.two_write_queues = v; +} + +unsigned char rocksdb_options_get_two_write_queues(rocksdb_options_t* opt) { + return opt->rep.two_write_queues; +} + +void rocksdb_options_set_manual_wal_flush(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.manual_wal_flush = v; +} + +unsigned char rocksdb_options_get_manual_wal_flush(rocksdb_options_t* opt) { + return opt->rep.manual_wal_flush; +} + +void rocksdb_options_set_wal_compression(rocksdb_options_t* opt, int v) { + opt->rep.wal_compression = static_castrep.wal_compression)>(v); +} + +int rocksdb_options_get_wal_compression(rocksdb_options_t* opt) { + return static_cast(opt->rep.wal_compression); +} + +void rocksdb_options_set_background_close_inactive_wals(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.background_close_inactive_wals = v; +} + +unsigned char rocksdb_options_get_background_close_inactive_wals( + rocksdb_options_t* opt) { + return opt->rep.background_close_inactive_wals; +} + +void rocksdb_options_set_atomic_flush(rocksdb_options_t* opt, unsigned char v) { + opt->rep.atomic_flush = v; +} + +unsigned char rocksdb_options_get_atomic_flush(rocksdb_options_t* opt) { + return opt->rep.atomic_flush; +} + +void rocksdb_options_set_avoid_unnecessary_blocking_io(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.avoid_unnecessary_blocking_io = v; +} + +unsigned char rocksdb_options_get_avoid_unnecessary_blocking_io( + rocksdb_options_t* opt) { + return opt->rep.avoid_unnecessary_blocking_io; +} + +void rocksdb_options_set_write_dbid_to_manifest(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.write_dbid_to_manifest = v; +} + +unsigned char rocksdb_options_get_write_dbid_to_manifest( + rocksdb_options_t* opt) { + return opt->rep.write_dbid_to_manifest; +} + +void rocksdb_options_set_write_identity_file(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.write_identity_file = v; +} + +unsigned char rocksdb_options_get_write_identity_file(rocksdb_options_t* opt) { + return opt->rep.write_identity_file; +} + +void rocksdb_options_set_prefix_seek_opt_in_only(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.prefix_seek_opt_in_only = v; +} + +unsigned char rocksdb_options_get_prefix_seek_opt_in_only( + rocksdb_options_t* opt) { + return opt->rep.prefix_seek_opt_in_only; +} + +void rocksdb_options_set_log_readahead_size(rocksdb_options_t* opt, size_t v) { + opt->rep.log_readahead_size = v; +} + +size_t rocksdb_options_get_log_readahead_size(rocksdb_options_t* opt) { + return opt->rep.log_readahead_size; +} + +void rocksdb_options_set_best_efforts_recovery(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.best_efforts_recovery = v; +} + +unsigned char rocksdb_options_get_best_efforts_recovery( + rocksdb_options_t* opt) { + return opt->rep.best_efforts_recovery; +} + +void rocksdb_options_set_max_bgerror_resume_count(rocksdb_options_t* opt, + int v) { + opt->rep.max_bgerror_resume_count = v; +} + +int rocksdb_options_get_max_bgerror_resume_count(rocksdb_options_t* opt) { + return opt->rep.max_bgerror_resume_count; +} + +void rocksdb_options_set_bgerror_resume_retry_interval(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.bgerror_resume_retry_interval = v; +} + +uint64_t rocksdb_options_get_bgerror_resume_retry_interval( + rocksdb_options_t* opt) { + return opt->rep.bgerror_resume_retry_interval; +} + +void rocksdb_options_set_allow_data_in_errors(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.allow_data_in_errors = v; +} + +unsigned char rocksdb_options_get_allow_data_in_errors(rocksdb_options_t* opt) { + return opt->rep.allow_data_in_errors; +} + +void rocksdb_options_set_db_host_id(rocksdb_options_t* opt, const char* v) { + opt->rep.db_host_id = v; +} + +const char* rocksdb_options_get_db_host_id(rocksdb_options_t* opt, + size_t* size) { + *size = opt->rep.db_host_id.size(); + return opt->rep.db_host_id.data(); +} + +void rocksdb_options_set_lowest_used_cache_tier(rocksdb_options_t* opt, int v) { + opt->rep.lowest_used_cache_tier = + static_castrep.lowest_used_cache_tier)>(v); +} + +int rocksdb_options_get_lowest_used_cache_tier(rocksdb_options_t* opt) { + return static_cast(opt->rep.lowest_used_cache_tier); +} + +void rocksdb_options_set_enforce_single_del_contracts(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enforce_single_del_contracts = v; +} + +unsigned char rocksdb_options_get_enforce_single_del_contracts( + rocksdb_options_t* opt) { + return opt->rep.enforce_single_del_contracts; +} + +void rocksdb_options_set_daily_offpeak_time_utc(rocksdb_options_t* opt, + const char* v) { + opt->rep.daily_offpeak_time_utc = v; +} + +const char* rocksdb_options_get_daily_offpeak_time_utc(rocksdb_options_t* opt, + size_t* size) { + *size = opt->rep.daily_offpeak_time_utc.size(); + return opt->rep.daily_offpeak_time_utc.data(); +} + +void rocksdb_options_set_max_compaction_trigger_wakeup_seconds( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.max_compaction_trigger_wakeup_seconds = v; +} + +uint64_t rocksdb_options_get_max_compaction_trigger_wakeup_seconds( + rocksdb_options_t* opt) { + return opt->rep.max_compaction_trigger_wakeup_seconds; +} + +void rocksdb_options_set_follower_refresh_catchup_period_ms( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.follower_refresh_catchup_period_ms = v; +} + +uint64_t rocksdb_options_get_follower_refresh_catchup_period_ms( + rocksdb_options_t* opt) { + return opt->rep.follower_refresh_catchup_period_ms; +} + +void rocksdb_options_set_follower_catchup_retry_count(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.follower_catchup_retry_count = v; +} + +uint64_t rocksdb_options_get_follower_catchup_retry_count( + rocksdb_options_t* opt) { + return opt->rep.follower_catchup_retry_count; +} + +void rocksdb_options_set_follower_catchup_retry_wait_ms(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.follower_catchup_retry_wait_ms = v; +} + +uint64_t rocksdb_options_get_follower_catchup_retry_wait_ms( + rocksdb_options_t* opt) { + return opt->rep.follower_catchup_retry_wait_ms; +} + +void rocksdb_options_set_metadata_write_temperature(rocksdb_options_t* opt, + int v) { + opt->rep.metadata_write_temperature = + static_castrep.metadata_write_temperature)>(v); +} + +int rocksdb_options_get_metadata_write_temperature(rocksdb_options_t* opt) { + return static_cast(opt->rep.metadata_write_temperature); +} + +void rocksdb_options_set_wal_write_temperature(rocksdb_options_t* opt, int v) { + opt->rep.wal_write_temperature = + static_castrep.wal_write_temperature)>(v); +} + +int rocksdb_options_get_wal_write_temperature(rocksdb_options_t* opt) { + return static_cast(opt->rep.wal_write_temperature); +} + +void rocksdb_options_set_fast_sst_open(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.fast_sst_open = v; +} + +unsigned char rocksdb_options_get_fast_sst_open(rocksdb_options_t* opt) { + return opt->rep.fast_sst_open; +} + +/* AdvancedColumnFamilyOptions */ + +void rocksdb_options_set_max_write_buffer_number(rocksdb_options_t* opt, + int v) { + opt->rep.max_write_buffer_number = v; +} + +int rocksdb_options_get_max_write_buffer_number(rocksdb_options_t* opt) { + return opt->rep.max_write_buffer_number; +} + +void rocksdb_options_set_min_write_buffer_number_to_merge( + rocksdb_options_t* opt, int v) { + opt->rep.min_write_buffer_number_to_merge = v; +} + +int rocksdb_options_get_min_write_buffer_number_to_merge( + rocksdb_options_t* opt) { + return opt->rep.min_write_buffer_number_to_merge; +} + +void rocksdb_options_set_max_write_buffer_size_to_maintain( + rocksdb_options_t* opt, int64_t v) { + opt->rep.max_write_buffer_size_to_maintain = v; +} + +int64_t rocksdb_options_get_max_write_buffer_size_to_maintain( + rocksdb_options_t* opt) { + return opt->rep.max_write_buffer_size_to_maintain; +} + +void rocksdb_options_set_inplace_update_support(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.inplace_update_support = v; +} + +unsigned char rocksdb_options_get_inplace_update_support( + rocksdb_options_t* opt) { + return opt->rep.inplace_update_support; +} + +void rocksdb_options_set_inplace_update_num_locks(rocksdb_options_t* opt, + size_t v) { + opt->rep.inplace_update_num_locks = v; +} + +size_t rocksdb_options_get_inplace_update_num_locks(rocksdb_options_t* opt) { + return opt->rep.inplace_update_num_locks; +} + +void rocksdb_options_set_experimental_mempurge_threshold(rocksdb_options_t* opt, + double v) { + opt->rep.experimental_mempurge_threshold = v; +} + +double rocksdb_options_get_experimental_mempurge_threshold( + rocksdb_options_t* opt) { + return opt->rep.experimental_mempurge_threshold; +} + +void rocksdb_options_set_memtable_prefix_bloom_size_ratio( + rocksdb_options_t* opt, double v) { + opt->rep.memtable_prefix_bloom_size_ratio = v; +} + +double rocksdb_options_get_memtable_prefix_bloom_size_ratio( + rocksdb_options_t* opt) { + return opt->rep.memtable_prefix_bloom_size_ratio; +} + +void rocksdb_options_set_memtable_whole_key_filtering(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.memtable_whole_key_filtering = v; +} + +unsigned char rocksdb_options_get_memtable_whole_key_filtering( + rocksdb_options_t* opt) { + return opt->rep.memtable_whole_key_filtering; +} + +void rocksdb_options_set_memtable_huge_page_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.memtable_huge_page_size = v; +} + +size_t rocksdb_options_get_memtable_huge_page_size(rocksdb_options_t* opt) { + return opt->rep.memtable_huge_page_size; +} + +void rocksdb_options_set_bloom_locality(rocksdb_options_t* opt, uint32_t v) { + opt->rep.bloom_locality = v; +} + +uint32_t rocksdb_options_get_bloom_locality(rocksdb_options_t* opt) { + return opt->rep.bloom_locality; +} + +void rocksdb_options_set_arena_block_size(rocksdb_options_t* opt, size_t v) { + opt->rep.arena_block_size = v; +} + +size_t rocksdb_options_get_arena_block_size(rocksdb_options_t* opt) { + return opt->rep.arena_block_size; +} + +void rocksdb_options_set_num_levels(rocksdb_options_t* opt, int v) { + opt->rep.num_levels = v; +} + +int rocksdb_options_get_num_levels(rocksdb_options_t* opt) { + return opt->rep.num_levels; +} + +void rocksdb_options_set_level0_slowdown_writes_trigger(rocksdb_options_t* opt, + int v) { + opt->rep.level0_slowdown_writes_trigger = v; +} + +int rocksdb_options_get_level0_slowdown_writes_trigger(rocksdb_options_t* opt) { + return opt->rep.level0_slowdown_writes_trigger; +} + +void rocksdb_options_set_level0_stop_writes_trigger(rocksdb_options_t* opt, + int v) { + opt->rep.level0_stop_writes_trigger = v; +} + +int rocksdb_options_get_level0_stop_writes_trigger(rocksdb_options_t* opt) { + return opt->rep.level0_stop_writes_trigger; +} + +void rocksdb_options_set_target_file_size_base(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.target_file_size_base = v; +} + +uint64_t rocksdb_options_get_target_file_size_base(rocksdb_options_t* opt) { + return opt->rep.target_file_size_base; +} + +void rocksdb_options_set_target_file_size_multiplier(rocksdb_options_t* opt, + int v) { + opt->rep.target_file_size_multiplier = v; +} + +int rocksdb_options_get_target_file_size_multiplier(rocksdb_options_t* opt) { + return opt->rep.target_file_size_multiplier; +} + +void rocksdb_options_set_target_file_size_is_upper_bound(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.target_file_size_is_upper_bound = v; +} + +unsigned char rocksdb_options_get_target_file_size_is_upper_bound( + rocksdb_options_t* opt) { + return opt->rep.target_file_size_is_upper_bound; +} + +void rocksdb_options_set_level_compaction_dynamic_level_bytes( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.level_compaction_dynamic_level_bytes = v; +} + +unsigned char rocksdb_options_get_level_compaction_dynamic_level_bytes( + rocksdb_options_t* opt) { + return opt->rep.level_compaction_dynamic_level_bytes; +} + +void rocksdb_options_set_max_bytes_for_level_multiplier(rocksdb_options_t* opt, + double v) { + opt->rep.max_bytes_for_level_multiplier = v; +} + +double rocksdb_options_get_max_bytes_for_level_multiplier( + rocksdb_options_t* opt) { + return opt->rep.max_bytes_for_level_multiplier; +} + +void rocksdb_options_set_max_compaction_bytes(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.max_compaction_bytes = v; +} + +uint64_t rocksdb_options_get_max_compaction_bytes(rocksdb_options_t* opt) { + return opt->rep.max_compaction_bytes; +} + +void rocksdb_options_set_compaction_style(rocksdb_options_t* opt, int v) { + opt->rep.compaction_style = + static_castrep.compaction_style)>(v); +} + +int rocksdb_options_get_compaction_style(rocksdb_options_t* opt) { + return static_cast(opt->rep.compaction_style); +} + +void rocksdb_options_set_compaction_pri(rocksdb_options_t* opt, int v) { + opt->rep.compaction_pri = static_castrep.compaction_pri)>(v); +} + +int rocksdb_options_get_compaction_pri(rocksdb_options_t* opt) { + return static_cast(opt->rep.compaction_pri); +} + +void rocksdb_options_set_max_sequential_skip_in_iterations( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.max_sequential_skip_in_iterations = v; +} + +uint64_t rocksdb_options_get_max_sequential_skip_in_iterations( + rocksdb_options_t* opt) { + return opt->rep.max_sequential_skip_in_iterations; +} + +void rocksdb_options_set_max_successive_merges(rocksdb_options_t* opt, + size_t v) { + opt->rep.max_successive_merges = v; +} + +size_t rocksdb_options_get_max_successive_merges(rocksdb_options_t* opt) { + return opt->rep.max_successive_merges; +} + +void rocksdb_options_set_strict_max_successive_merges(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.strict_max_successive_merges = v; +} + +unsigned char rocksdb_options_get_strict_max_successive_merges( + rocksdb_options_t* opt) { + return opt->rep.strict_max_successive_merges; +} + +unsigned char rocksdb_options_get_optimize_filters_for_hits( + rocksdb_options_t* opt) { + return opt->rep.optimize_filters_for_hits; +} + +void rocksdb_options_set_paranoid_file_checks(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.paranoid_file_checks = v; +} + +unsigned char rocksdb_options_get_paranoid_file_checks(rocksdb_options_t* opt) { + return opt->rep.paranoid_file_checks; +} + +void rocksdb_options_set_verify_output_flags(rocksdb_options_t* opt, int v) { + opt->rep.verify_output_flags = + static_castrep.verify_output_flags)>(v); +} + +int rocksdb_options_get_verify_output_flags(rocksdb_options_t* opt) { + return static_cast(opt->rep.verify_output_flags); +} + +void rocksdb_options_set_force_consistency_checks(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.force_consistency_checks = v; +} + +unsigned char rocksdb_options_get_force_consistency_checks( + rocksdb_options_t* opt) { + return opt->rep.force_consistency_checks; +} + +unsigned char rocksdb_options_get_report_bg_io_stats(rocksdb_options_t* opt) { + return opt->rep.report_bg_io_stats; +} + +void rocksdb_options_set_disallow_memtable_writes(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.disallow_memtable_writes = v; +} + +unsigned char rocksdb_options_get_disallow_memtable_writes( + rocksdb_options_t* opt) { + return opt->rep.disallow_memtable_writes; +} + +void rocksdb_options_set_ttl(rocksdb_options_t* opt, uint64_t v) { + opt->rep.ttl = v; +} + +uint64_t rocksdb_options_get_ttl(rocksdb_options_t* opt) { + return opt->rep.ttl; +} + +void rocksdb_options_set_periodic_compaction_seconds(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.periodic_compaction_seconds = v; +} + +uint64_t rocksdb_options_get_periodic_compaction_seconds( + rocksdb_options_t* opt) { + return opt->rep.periodic_compaction_seconds; +} + +void rocksdb_options_set_read_triggered_compaction_threshold( + rocksdb_options_t* opt, double v) { + opt->rep.read_triggered_compaction_threshold = v; +} + +double rocksdb_options_get_read_triggered_compaction_threshold( + rocksdb_options_t* opt) { + return opt->rep.read_triggered_compaction_threshold; +} + +void rocksdb_options_set_sample_for_compression(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.sample_for_compression = v; +} + +uint64_t rocksdb_options_get_sample_for_compression(rocksdb_options_t* opt) { + return opt->rep.sample_for_compression; +} + +void rocksdb_options_set_last_level_temperature(rocksdb_options_t* opt, int v) { + opt->rep.last_level_temperature = + static_castrep.last_level_temperature)>(v); +} + +int rocksdb_options_get_last_level_temperature(rocksdb_options_t* opt) { + return static_cast(opt->rep.last_level_temperature); +} + +void rocksdb_options_set_default_write_temperature(rocksdb_options_t* opt, + int v) { + opt->rep.default_write_temperature = + static_castrep.default_write_temperature)>(v); +} + +int rocksdb_options_get_default_write_temperature(rocksdb_options_t* opt) { + return static_cast(opt->rep.default_write_temperature); +} + +void rocksdb_options_set_default_temperature(rocksdb_options_t* opt, int v) { + opt->rep.default_temperature = + static_castrep.default_temperature)>(v); +} + +int rocksdb_options_get_default_temperature(rocksdb_options_t* opt) { + return static_cast(opt->rep.default_temperature); +} + +void rocksdb_options_set_preclude_last_level_data_seconds( + rocksdb_options_t* opt, uint64_t v) { + opt->rep.preclude_last_level_data_seconds = v; +} + +uint64_t rocksdb_options_get_preclude_last_level_data_seconds( + rocksdb_options_t* opt) { + return opt->rep.preclude_last_level_data_seconds; +} + +void rocksdb_options_set_preserve_internal_time_seconds(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.preserve_internal_time_seconds = v; +} + +uint64_t rocksdb_options_get_preserve_internal_time_seconds( + rocksdb_options_t* opt) { + return opt->rep.preserve_internal_time_seconds; +} + +void rocksdb_options_set_enable_blob_files(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enable_blob_files = v; +} + +unsigned char rocksdb_options_get_enable_blob_files(rocksdb_options_t* opt) { + return opt->rep.enable_blob_files; +} + +void rocksdb_options_set_min_blob_size(rocksdb_options_t* opt, uint64_t v) { + opt->rep.min_blob_size = v; +} + +uint64_t rocksdb_options_get_min_blob_size(rocksdb_options_t* opt) { + return opt->rep.min_blob_size; +} + +void rocksdb_options_set_blob_file_size(rocksdb_options_t* opt, uint64_t v) { + opt->rep.blob_file_size = v; +} + +uint64_t rocksdb_options_get_blob_file_size(rocksdb_options_t* opt) { + return opt->rep.blob_file_size; +} + +void rocksdb_options_set_blob_compression_type(rocksdb_options_t* opt, int v) { + opt->rep.blob_compression_type = + static_castrep.blob_compression_type)>(v); +} + +int rocksdb_options_get_blob_compression_type(rocksdb_options_t* opt) { + return static_cast(opt->rep.blob_compression_type); +} + +void rocksdb_options_set_enable_blob_gc(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enable_blob_garbage_collection = v; +} + +unsigned char rocksdb_options_get_enable_blob_gc(rocksdb_options_t* opt) { + return opt->rep.enable_blob_garbage_collection; +} + +void rocksdb_options_set_blob_gc_age_cutoff(rocksdb_options_t* opt, double v) { + opt->rep.blob_garbage_collection_age_cutoff = v; +} + +double rocksdb_options_get_blob_gc_age_cutoff(rocksdb_options_t* opt) { + return opt->rep.blob_garbage_collection_age_cutoff; +} + +void rocksdb_options_set_blob_gc_force_threshold(rocksdb_options_t* opt, + double v) { + opt->rep.blob_garbage_collection_force_threshold = v; +} + +double rocksdb_options_get_blob_gc_force_threshold(rocksdb_options_t* opt) { + return opt->rep.blob_garbage_collection_force_threshold; +} + +void rocksdb_options_set_blob_compaction_readahead_size(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.blob_compaction_readahead_size = v; +} + +uint64_t rocksdb_options_get_blob_compaction_readahead_size( + rocksdb_options_t* opt) { + return opt->rep.blob_compaction_readahead_size; +} + +void rocksdb_options_set_blob_file_starting_level(rocksdb_options_t* opt, + int v) { + opt->rep.blob_file_starting_level = v; +} + +int rocksdb_options_get_blob_file_starting_level(rocksdb_options_t* opt) { + return opt->rep.blob_file_starting_level; +} + +void rocksdb_options_set_prepopulate_blob_cache(rocksdb_options_t* opt, int v) { + opt->rep.prepopulate_blob_cache = + static_castrep.prepopulate_blob_cache)>(v); +} + +int rocksdb_options_get_prepopulate_blob_cache(rocksdb_options_t* opt) { + return static_cast(opt->rep.prepopulate_blob_cache); +} + +void rocksdb_options_set_enable_blob_direct_write(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.enable_blob_direct_write = v; +} + +unsigned char rocksdb_options_get_enable_blob_direct_write( + rocksdb_options_t* opt) { + return opt->rep.enable_blob_direct_write; +} + +void rocksdb_options_set_blob_direct_write_partitions(rocksdb_options_t* opt, + uint32_t v) { + opt->rep.blob_direct_write_partitions = v; +} + +uint32_t rocksdb_options_get_blob_direct_write_partitions( + rocksdb_options_t* opt) { + return opt->rep.blob_direct_write_partitions; +} + +void rocksdb_options_set_memtable_protection_bytes_per_key( + rocksdb_options_t* opt, uint32_t v) { + opt->rep.memtable_protection_bytes_per_key = v; +} + +uint32_t rocksdb_options_get_memtable_protection_bytes_per_key( + rocksdb_options_t* opt) { + return opt->rep.memtable_protection_bytes_per_key; +} + +void rocksdb_options_set_persist_user_defined_timestamps(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.persist_user_defined_timestamps = v; +} + +unsigned char rocksdb_options_get_persist_user_defined_timestamps( + rocksdb_options_t* opt) { + return opt->rep.persist_user_defined_timestamps; +} + +void rocksdb_options_set_block_protection_bytes_per_key(rocksdb_options_t* opt, + uint8_t v) { + opt->rep.block_protection_bytes_per_key = v; +} + +uint8_t rocksdb_options_get_block_protection_bytes_per_key( + rocksdb_options_t* opt) { + return opt->rep.block_protection_bytes_per_key; +} + +void rocksdb_options_set_bottommost_file_compaction_delay( + rocksdb_options_t* opt, uint32_t v) { + opt->rep.bottommost_file_compaction_delay = v; +} + +uint32_t rocksdb_options_get_bottommost_file_compaction_delay( + rocksdb_options_t* opt) { + return opt->rep.bottommost_file_compaction_delay; +} + +void rocksdb_options_set_paranoid_memory_checks(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.paranoid_memory_checks = v; +} + +unsigned char rocksdb_options_get_paranoid_memory_checks( + rocksdb_options_t* opt) { + return opt->rep.paranoid_memory_checks; +} + +void rocksdb_options_set_memtable_verify_per_key_checksum_on_seek( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.memtable_verify_per_key_checksum_on_seek = v; +} + +unsigned char rocksdb_options_get_memtable_verify_per_key_checksum_on_seek( + rocksdb_options_t* opt) { + return opt->rep.memtable_verify_per_key_checksum_on_seek; +} + +void rocksdb_options_set_memtable_op_scan_flush_trigger(rocksdb_options_t* opt, + uint32_t v) { + opt->rep.memtable_op_scan_flush_trigger = v; +} + +uint32_t rocksdb_options_get_memtable_op_scan_flush_trigger( + rocksdb_options_t* opt) { + return opt->rep.memtable_op_scan_flush_trigger; +} + +void rocksdb_options_set_memtable_avg_op_scan_flush_trigger( + rocksdb_options_t* opt, uint32_t v) { + opt->rep.memtable_avg_op_scan_flush_trigger = v; +} + +uint32_t rocksdb_options_get_memtable_avg_op_scan_flush_trigger( + rocksdb_options_t* opt) { + return opt->rep.memtable_avg_op_scan_flush_trigger; +} + +void rocksdb_options_set_min_tombstones_for_range_conversion( + rocksdb_options_t* opt, uint32_t v) { + opt->rep.min_tombstones_for_range_conversion = v; +} + +uint32_t rocksdb_options_get_min_tombstones_for_range_conversion( + rocksdb_options_t* opt) { + return opt->rep.min_tombstones_for_range_conversion; +} + +void rocksdb_options_set_cf_allow_ingest_behind(rocksdb_options_t* opt, + unsigned char v) { + opt->rep.cf_allow_ingest_behind = v; +} + +unsigned char rocksdb_options_get_cf_allow_ingest_behind( + rocksdb_options_t* opt) { + return opt->rep.cf_allow_ingest_behind; +} + +void rocksdb_options_set_memtable_batch_lookup_optimization( + rocksdb_options_t* opt, unsigned char v) { + opt->rep.memtable_batch_lookup_optimization = v; +} + +unsigned char rocksdb_options_get_memtable_batch_lookup_optimization( + rocksdb_options_t* opt) { + return opt->rep.memtable_batch_lookup_optimization; +} + +/* ColumnFamilyOptions */ + +void rocksdb_options_set_write_buffer_size(rocksdb_options_t* opt, size_t v) { + opt->rep.write_buffer_size = v; +} + +size_t rocksdb_options_get_write_buffer_size(rocksdb_options_t* opt) { + return opt->rep.write_buffer_size; +} + +void rocksdb_options_set_compression(rocksdb_options_t* opt, int v) { + opt->rep.compression = static_castrep.compression)>(v); +} + +int rocksdb_options_get_compression(rocksdb_options_t* opt) { + return static_cast(opt->rep.compression); +} + +void rocksdb_options_set_bottommost_compression(rocksdb_options_t* opt, int v) { + opt->rep.bottommost_compression = + static_castrep.bottommost_compression)>(v); +} + +int rocksdb_options_get_bottommost_compression(rocksdb_options_t* opt) { + return static_cast(opt->rep.bottommost_compression); +} + +void rocksdb_options_set_level0_file_num_compaction_trigger( + rocksdb_options_t* opt, int v) { + opt->rep.level0_file_num_compaction_trigger = v; +} + +int rocksdb_options_get_level0_file_num_compaction_trigger( + rocksdb_options_t* opt) { + return opt->rep.level0_file_num_compaction_trigger; +} + +void rocksdb_options_set_max_bytes_for_level_base(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.max_bytes_for_level_base = v; +} + +uint64_t rocksdb_options_get_max_bytes_for_level_base(rocksdb_options_t* opt) { + return opt->rep.max_bytes_for_level_base; +} + +unsigned char rocksdb_options_get_disable_auto_compactions( + rocksdb_options_t* opt) { + return opt->rep.disable_auto_compactions; +} + +void rocksdb_options_set_memtable_max_range_deletions(rocksdb_options_t* opt, + uint32_t v) { + opt->rep.memtable_max_range_deletions = v; +} + +uint32_t rocksdb_options_get_memtable_max_range_deletions( + rocksdb_options_t* opt) { + return opt->rep.memtable_max_range_deletions; +} + +void rocksdb_options_set_uncache_aggressiveness(rocksdb_options_t* opt, + uint32_t v) { + opt->rep.uncache_aggressiveness = v; +} + +uint32_t rocksdb_options_get_uncache_aggressiveness(rocksdb_options_t* opt) { + return opt->rep.uncache_aggressiveness; +} + +/* WriteOptions */ + +void rocksdb_writeoptions_set_sync(rocksdb_writeoptions_t* opt, + unsigned char v) { + opt->rep.sync = v; +} + +unsigned char rocksdb_writeoptions_get_sync(rocksdb_writeoptions_t* opt) { + return opt->rep.sync; +} + +void rocksdb_writeoptions_disable_WAL(rocksdb_writeoptions_t* opt, int v) { + opt->rep.disableWAL = static_castrep.disableWAL)>(v); +} + +unsigned char rocksdb_writeoptions_get_disable_WAL( + rocksdb_writeoptions_t* opt) { + return opt->rep.disableWAL; +} + +void rocksdb_writeoptions_set_ignore_missing_column_families( + rocksdb_writeoptions_t* opt, unsigned char v) { + opt->rep.ignore_missing_column_families = v; +} + +unsigned char rocksdb_writeoptions_get_ignore_missing_column_families( + rocksdb_writeoptions_t* opt) { + return opt->rep.ignore_missing_column_families; +} + +void rocksdb_writeoptions_set_no_slowdown(rocksdb_writeoptions_t* opt, + unsigned char v) { + opt->rep.no_slowdown = v; +} + +unsigned char rocksdb_writeoptions_get_no_slowdown( + rocksdb_writeoptions_t* opt) { + return opt->rep.no_slowdown; +} + +void rocksdb_writeoptions_set_low_pri(rocksdb_writeoptions_t* opt, + unsigned char v) { + opt->rep.low_pri = v; +} + +unsigned char rocksdb_writeoptions_get_low_pri(rocksdb_writeoptions_t* opt) { + return opt->rep.low_pri; +} + +void rocksdb_writeoptions_set_memtable_insert_hint_per_batch( + rocksdb_writeoptions_t* opt, unsigned char v) { + opt->rep.memtable_insert_hint_per_batch = v; +} + +unsigned char rocksdb_writeoptions_get_memtable_insert_hint_per_batch( + rocksdb_writeoptions_t* opt) { + return opt->rep.memtable_insert_hint_per_batch; +} + +void rocksdb_writeoptions_set_rate_limiter_priority(rocksdb_writeoptions_t* opt, + int v) { + opt->rep.rate_limiter_priority = + static_castrep.rate_limiter_priority)>(v); +} + +int rocksdb_writeoptions_get_rate_limiter_priority( + rocksdb_writeoptions_t* opt) { + return static_cast(opt->rep.rate_limiter_priority); +} + +void rocksdb_writeoptions_set_protection_bytes_per_key( + rocksdb_writeoptions_t* opt, size_t v) { + opt->rep.protection_bytes_per_key = v; +} + +size_t rocksdb_writeoptions_get_protection_bytes_per_key( + rocksdb_writeoptions_t* opt) { + return opt->rep.protection_bytes_per_key; +} + +void rocksdb_writeoptions_set_io_activity(rocksdb_writeoptions_t* opt, int v) { + opt->rep.io_activity = static_castrep.io_activity)>(v); +} + +int rocksdb_writeoptions_get_io_activity(rocksdb_writeoptions_t* opt) { + return static_cast(opt->rep.io_activity); +} + +/* FlushOptions */ + +void rocksdb_flushoptions_set_wait(rocksdb_flushoptions_t* opt, + unsigned char v) { + opt->rep.wait = v; +} + +unsigned char rocksdb_flushoptions_get_wait(rocksdb_flushoptions_t* opt) { + return opt->rep.wait; +} + +void rocksdb_flushoptions_set_allow_write_stall(rocksdb_flushoptions_t* opt, + unsigned char v) { + opt->rep.allow_write_stall = v; +} + +unsigned char rocksdb_flushoptions_get_allow_write_stall( + rocksdb_flushoptions_t* opt) { + return opt->rep.allow_write_stall; +} + +void rocksdb_flushoptions_set_force_atomic_flush(rocksdb_flushoptions_t* opt, + unsigned char v) { + opt->rep.force_atomic_flush = v; +} + +unsigned char rocksdb_flushoptions_get_force_atomic_flush( + rocksdb_flushoptions_t* opt) { + return opt->rep.force_atomic_flush; +} + +/* FlushWALOptions */ + +void rocksdb_flushwaloptions_set_sync(rocksdb_flushwaloptions_t* opt, + unsigned char v) { + opt->rep.sync = v; +} + +unsigned char rocksdb_flushwaloptions_get_sync(rocksdb_flushwaloptions_t* opt) { + return opt->rep.sync; +} + +void rocksdb_flushwaloptions_set_rate_limiter_priority( + rocksdb_flushwaloptions_t* opt, int v) { + opt->rep.rate_limiter_priority = + static_castrep.rate_limiter_priority)>(v); +} + +int rocksdb_flushwaloptions_get_rate_limiter_priority( + rocksdb_flushwaloptions_t* opt) { + return static_cast(opt->rep.rate_limiter_priority); +} + +/* EnvOptions */ + +void rocksdb_envoptions_set_use_mmap_reads(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.use_mmap_reads = v; +} + +unsigned char rocksdb_envoptions_get_use_mmap_reads(rocksdb_envoptions_t* opt) { + return opt->rep.use_mmap_reads; +} + +void rocksdb_envoptions_set_use_mmap_writes(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.use_mmap_writes = v; +} + +unsigned char rocksdb_envoptions_get_use_mmap_writes( + rocksdb_envoptions_t* opt) { + return opt->rep.use_mmap_writes; +} + +void rocksdb_envoptions_set_use_direct_reads(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.use_direct_reads = v; +} + +unsigned char rocksdb_envoptions_get_use_direct_reads( + rocksdb_envoptions_t* opt) { + return opt->rep.use_direct_reads; +} + +void rocksdb_envoptions_set_use_direct_writes(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.use_direct_writes = v; +} + +unsigned char rocksdb_envoptions_get_use_direct_writes( + rocksdb_envoptions_t* opt) { + return opt->rep.use_direct_writes; +} + +void rocksdb_envoptions_set_allow_fallocate(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.allow_fallocate = v; +} + +unsigned char rocksdb_envoptions_get_allow_fallocate( + rocksdb_envoptions_t* opt) { + return opt->rep.allow_fallocate; +} + +void rocksdb_envoptions_set_fd_cloexec(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.set_fd_cloexec = v; +} + +unsigned char rocksdb_envoptions_get_fd_cloexec(rocksdb_envoptions_t* opt) { + return opt->rep.set_fd_cloexec; +} + +void rocksdb_envoptions_set_bytes_per_sync(rocksdb_envoptions_t* opt, + uint64_t v) { + opt->rep.bytes_per_sync = v; +} + +uint64_t rocksdb_envoptions_get_bytes_per_sync(rocksdb_envoptions_t* opt) { + return opt->rep.bytes_per_sync; +} + +void rocksdb_envoptions_set_strict_bytes_per_sync(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.strict_bytes_per_sync = v; +} + +unsigned char rocksdb_envoptions_get_strict_bytes_per_sync( + rocksdb_envoptions_t* opt) { + return opt->rep.strict_bytes_per_sync; +} + +void rocksdb_envoptions_set_fallocate_with_keep_size(rocksdb_envoptions_t* opt, + unsigned char v) { + opt->rep.fallocate_with_keep_size = v; +} + +unsigned char rocksdb_envoptions_get_fallocate_with_keep_size( + rocksdb_envoptions_t* opt) { + return opt->rep.fallocate_with_keep_size; +} + +void rocksdb_envoptions_set_compaction_readahead_size(rocksdb_envoptions_t* opt, + size_t v) { + opt->rep.compaction_readahead_size = v; +} + +size_t rocksdb_envoptions_get_compaction_readahead_size( + rocksdb_envoptions_t* opt) { + return opt->rep.compaction_readahead_size; +} + +void rocksdb_envoptions_set_writable_file_max_buffer_size( + rocksdb_envoptions_t* opt, size_t v) { + opt->rep.writable_file_max_buffer_size = v; +} + +size_t rocksdb_envoptions_get_writable_file_max_buffer_size( + rocksdb_envoptions_t* opt) { + return opt->rep.writable_file_max_buffer_size; +} + +/* TraceOptions */ + +void rocksdb_trace_options_set_max_trace_file_size(rocksdb_trace_options_t* opt, + uint64_t v) { + opt->rep.max_trace_file_size = v; +} + +uint64_t rocksdb_trace_options_get_max_trace_file_size( + rocksdb_trace_options_t* opt) { + return opt->rep.max_trace_file_size; +} + +void rocksdb_trace_options_set_sampling_frequency(rocksdb_trace_options_t* opt, + uint64_t v) { + opt->rep.sampling_frequency = v; +} + +uint64_t rocksdb_trace_options_get_sampling_frequency( + rocksdb_trace_options_t* opt) { + return opt->rep.sampling_frequency; +} + +void rocksdb_trace_options_set_filter(rocksdb_trace_options_t* opt, + uint64_t v) { + opt->rep.filter = v; +} + +uint64_t rocksdb_trace_options_get_filter(rocksdb_trace_options_t* opt) { + return opt->rep.filter; +} + +void rocksdb_trace_options_set_preserve_write_order( + rocksdb_trace_options_t* opt, unsigned char v) { + opt->rep.preserve_write_order = v; +} + +unsigned char rocksdb_trace_options_get_preserve_write_order( + rocksdb_trace_options_t* opt) { + return opt->rep.preserve_write_order; +} + +/* BlockCacheTraceOptions */ + +void rocksdb_block_cache_trace_options_set_sampling_frequency( + rocksdb_block_cache_trace_options_t* opt, uint64_t v) { + opt->rep.sampling_frequency = v; +} + +uint64_t rocksdb_block_cache_trace_options_get_sampling_frequency( + rocksdb_block_cache_trace_options_t* opt) { + return opt->rep.sampling_frequency; +} + +/* BlockCacheTraceWriterOptions */ + +void rocksdb_block_cache_trace_writer_options_set_max_trace_file_size( + rocksdb_block_cache_trace_writer_options_t* opt, uint64_t v) { + opt->rep.max_trace_file_size = v; +} + +uint64_t rocksdb_block_cache_trace_writer_options_get_max_trace_file_size( + rocksdb_block_cache_trace_writer_options_t* opt) { + return opt->rep.max_trace_file_size; +} + +/* CompactionOptions */ + +void rocksdb_compaction_options_set_compression( + rocksdb_compaction_options_t* opt, int v) { + opt->rep.compression = static_castrep.compression)>(v); +} + +int rocksdb_compaction_options_get_compression( + rocksdb_compaction_options_t* opt) { + return static_cast(opt->rep.compression); +} + +void rocksdb_compaction_options_set_output_file_size_limit( + rocksdb_compaction_options_t* opt, uint64_t v) { + opt->rep.output_file_size_limit = v; +} + +uint64_t rocksdb_compaction_options_get_output_file_size_limit( + rocksdb_compaction_options_t* opt) { + return opt->rep.output_file_size_limit; +} + +void rocksdb_compaction_options_set_max_subcompactions( + rocksdb_compaction_options_t* opt, uint32_t v) { + opt->rep.max_subcompactions = v; +} + +uint32_t rocksdb_compaction_options_get_max_subcompactions( + rocksdb_compaction_options_t* opt) { + return opt->rep.max_subcompactions; +} + +void rocksdb_compaction_options_set_output_temperature_override( + rocksdb_compaction_options_t* opt, int v) { + opt->rep.output_temperature_override = + static_castrep.output_temperature_override)>(v); +} + +int rocksdb_compaction_options_get_output_temperature_override( + rocksdb_compaction_options_t* opt) { + return static_cast(opt->rep.output_temperature_override); +} + +void rocksdb_compaction_options_set_allow_trivial_move( + rocksdb_compaction_options_t* opt, unsigned char v) { + opt->rep.allow_trivial_move = v; +} + +unsigned char rocksdb_compaction_options_get_allow_trivial_move( + rocksdb_compaction_options_t* opt) { + return opt->rep.allow_trivial_move; +} + +/* CompactRangeOptions */ + +void rocksdb_compactoptions_set_blob_garbage_collection_policy( + rocksdb_compactoptions_t* opt, int v) { + opt->rep.blob_garbage_collection_policy = + static_castrep.blob_garbage_collection_policy)>(v); +} + +int rocksdb_compactoptions_get_blob_garbage_collection_policy( + rocksdb_compactoptions_t* opt) { + return static_cast(opt->rep.blob_garbage_collection_policy); +} + +void rocksdb_compactoptions_set_blob_garbage_collection_age_cutoff( + rocksdb_compactoptions_t* opt, double v) { + opt->rep.blob_garbage_collection_age_cutoff = v; +} + +double rocksdb_compactoptions_get_blob_garbage_collection_age_cutoff( + rocksdb_compactoptions_t* opt) { + return opt->rep.blob_garbage_collection_age_cutoff; +} + +/* IngestExternalFileOptions */ + +unsigned char rocksdb_ingestexternalfileoptions_get_move_files( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.move_files; +} + +void rocksdb_ingestexternalfileoptions_set_link_files( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.link_files = v; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_link_files( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.link_files; +} + +void rocksdb_ingestexternalfileoptions_set_failed_move_fall_back_to_copy( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.failed_move_fall_back_to_copy = v; +} + +unsigned char +rocksdb_ingestexternalfileoptions_get_failed_move_fall_back_to_copy( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.failed_move_fall_back_to_copy; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_snapshot_consistency( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.snapshot_consistency; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_allow_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.allow_global_seqno; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_allow_blocking_flush( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.allow_blocking_flush; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_ingest_behind( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.ingest_behind; +} + +void rocksdb_ingestexternalfileoptions_set_write_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.write_global_seqno = v; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_write_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.write_global_seqno; +} + +void rocksdb_ingestexternalfileoptions_set_verify_checksums_before_ingest( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.verify_checksums_before_ingest = v; +} + +unsigned char +rocksdb_ingestexternalfileoptions_get_verify_checksums_before_ingest( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.verify_checksums_before_ingest; +} + +void rocksdb_ingestexternalfileoptions_set_verify_checksums_readahead_size( + rocksdb_ingestexternalfileoptions_t* opt, size_t v) { + opt->rep.verify_checksums_readahead_size = v; +} + +size_t rocksdb_ingestexternalfileoptions_get_verify_checksums_readahead_size( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.verify_checksums_readahead_size; +} + +void rocksdb_ingestexternalfileoptions_set_verify_file_checksum( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.verify_file_checksum = v; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_verify_file_checksum( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.verify_file_checksum; +} + +unsigned char +rocksdb_ingestexternalfileoptions_get_fail_if_not_bottommost_level( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.fail_if_not_bottommost_level; +} + +void rocksdb_ingestexternalfileoptions_set_allow_db_generated_files( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.allow_db_generated_files = v; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_allow_db_generated_files( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.allow_db_generated_files; +} + +void rocksdb_ingestexternalfileoptions_set_fill_cache( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.fill_cache = v; +} + +unsigned char rocksdb_ingestexternalfileoptions_get_fill_cache( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.fill_cache; +} + +void rocksdb_ingestexternalfileoptions_set_prefetch_lmax_index_and_filter_blocks( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v) { + opt->rep.prefetch_lmax_index_and_filter_blocks = v; +} + +unsigned char +rocksdb_ingestexternalfileoptions_get_prefetch_lmax_index_and_filter_blocks( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.prefetch_lmax_index_and_filter_blocks; +} + +void rocksdb_ingestexternalfileoptions_set_file_opening_threads( + rocksdb_ingestexternalfileoptions_t* opt, int v) { + opt->rep.file_opening_threads = v; +} + +int rocksdb_ingestexternalfileoptions_get_file_opening_threads( + rocksdb_ingestexternalfileoptions_t* opt) { + return opt->rep.file_opening_threads; +} + +/* OpenAndCompactOptions */ + +unsigned char rocksdb_open_and_compact_options_get_allow_resumption( + rocksdb_open_and_compact_options_t* opt) { + return opt->rep.allow_resumption; +} + +/* ImportColumnFamilyOptions */ + +unsigned char rocksdb_import_column_family_options_get_move_files( + rocksdb_import_column_family_options_t* opt) { + return opt->rep.move_files; +} + +/* SizeApproximationOptions */ + +void rocksdb_size_approximation_options_set_include_memtables( + rocksdb_size_approximation_options_t* opt, unsigned char v) { + opt->rep.include_memtables = v; +} + +unsigned char rocksdb_size_approximation_options_get_include_memtables( + rocksdb_size_approximation_options_t* opt) { + return opt->rep.include_memtables; +} + +void rocksdb_size_approximation_options_set_include_files( + rocksdb_size_approximation_options_t* opt, unsigned char v) { + opt->rep.include_files = v; +} + +unsigned char rocksdb_size_approximation_options_get_include_files( + rocksdb_size_approximation_options_t* opt) { + return opt->rep.include_files; +} + +void rocksdb_size_approximation_options_set_include_blob_files( + rocksdb_size_approximation_options_t* opt, unsigned char v) { + opt->rep.include_blob_files = v; +} + +unsigned char rocksdb_size_approximation_options_get_include_blob_files( + rocksdb_size_approximation_options_t* opt) { + return opt->rep.include_blob_files; +} + +void rocksdb_size_approximation_options_set_files_size_error_margin( + rocksdb_size_approximation_options_t* opt, double v) { + opt->rep.files_size_error_margin = v; +} + +double rocksdb_size_approximation_options_get_files_size_error_margin( + rocksdb_size_approximation_options_t* opt) { + return opt->rep.files_size_error_margin; +} + +/* LiveFilesStorageInfoOptions */ + +void rocksdb_livefiles_storage_info_options_set_include_checksum_info( + rocksdb_livefiles_storage_info_options_t* opt, unsigned char v) { + opt->rep.include_checksum_info = v; +} + +unsigned char rocksdb_livefiles_storage_info_options_get_include_checksum_info( + rocksdb_livefiles_storage_info_options_t* opt) { + return opt->rep.include_checksum_info; +} + +void rocksdb_livefiles_storage_info_options_set_wal_size_for_flush( + rocksdb_livefiles_storage_info_options_t* opt, uint64_t v) { + opt->rep.wal_size_for_flush = v; +} + +uint64_t rocksdb_livefiles_storage_info_options_get_wal_size_for_flush( + rocksdb_livefiles_storage_info_options_t* opt) { + return opt->rep.wal_size_for_flush; +} + +void rocksdb_livefiles_storage_info_options_set_atomic_flush( + rocksdb_livefiles_storage_info_options_t* opt, unsigned char v) { + opt->rep.atomic_flush = v; +} + +unsigned char rocksdb_livefiles_storage_info_options_get_atomic_flush( + rocksdb_livefiles_storage_info_options_t* opt) { + return opt->rep.atomic_flush; +} + +/* GetColumnFamilyMetaDataOptions */ + +void rocksdb_column_family_metadata_options_set_level( + rocksdb_column_family_metadata_options_t* opt, int v) { + opt->rep.level = v; +} + +int rocksdb_column_family_metadata_options_get_level( + rocksdb_column_family_metadata_options_t* opt) { + return opt->rep.level; +} + +/* WaitForCompactOptions */ + +void rocksdb_wait_for_compact_options_set_wait_for_purge( + rocksdb_wait_for_compact_options_t* opt, unsigned char v) { + opt->rep.wait_for_purge = v; +} + +unsigned char rocksdb_wait_for_compact_options_get_wait_for_purge( + rocksdb_wait_for_compact_options_t* opt) { + return opt->rep.wait_for_purge; +} + +/* BlockBasedTableOptions */ + +void rocksdb_block_based_options_set_cache_index_and_filter_blocks( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.cache_index_and_filter_blocks = v; +} + +unsigned char rocksdb_block_based_options_get_cache_index_and_filter_blocks( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.cache_index_and_filter_blocks; +} + +void rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.cache_index_and_filter_blocks_with_high_priority = v; +} + +unsigned char +rocksdb_block_based_options_get_cache_index_and_filter_blocks_with_high_priority( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.cache_index_and_filter_blocks_with_high_priority; +} + +void rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.pin_l0_filter_and_index_blocks_in_cache = v; +} + +unsigned char +rocksdb_block_based_options_get_pin_l0_filter_and_index_blocks_in_cache( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.pin_l0_filter_and_index_blocks_in_cache; +} + +void rocksdb_block_based_options_set_pin_top_level_index_and_filter( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.pin_top_level_index_and_filter = v; +} + +unsigned char rocksdb_block_based_options_get_pin_top_level_index_and_filter( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.pin_top_level_index_and_filter; +} + +void rocksdb_block_based_options_set_index_type( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.index_type = static_castrep.index_type)>(v); +} + +int rocksdb_block_based_options_get_index_type( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.index_type); +} + +void rocksdb_block_based_options_set_index_block_search_type( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.index_block_search_type = + static_castrep.index_block_search_type)>(v); +} + +int rocksdb_block_based_options_get_index_block_search_type( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.index_block_search_type); +} + +void rocksdb_block_based_options_set_data_block_index_type( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.data_block_index_type = + static_castrep.data_block_index_type)>(v); +} + +int rocksdb_block_based_options_get_data_block_index_type( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.data_block_index_type); +} + +void rocksdb_block_based_options_set_data_block_hash_table_util_ratio( + rocksdb_block_based_table_options_t* opt, double v) { + opt->rep.data_block_hash_table_util_ratio = v; +} + +double rocksdb_block_based_options_get_data_block_hash_table_util_ratio( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.data_block_hash_table_util_ratio; +} + +void rocksdb_block_based_options_set_checksum( + rocksdb_block_based_table_options_t* opt, char v) { + opt->rep.checksum = static_castrep.checksum)>(v); +} + +int rocksdb_block_based_options_get_checksum( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.checksum); +} + +void rocksdb_block_based_options_set_no_block_cache( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.no_block_cache = v; +} + +unsigned char rocksdb_block_based_options_get_no_block_cache( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.no_block_cache; +} + +void rocksdb_block_based_options_set_block_size( + rocksdb_block_based_table_options_t* opt, size_t v) { + opt->rep.block_size = static_castrep.block_size)>(v); +} + +uint64_t rocksdb_block_based_options_get_block_size( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.block_size; +} + +void rocksdb_block_based_options_set_block_size_deviation( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.block_size_deviation = v; +} + +int rocksdb_block_based_options_get_block_size_deviation( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.block_size_deviation; +} + +void rocksdb_block_based_options_set_block_restart_interval( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.block_restart_interval = v; +} + +int rocksdb_block_based_options_get_block_restart_interval( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.block_restart_interval; +} + +void rocksdb_block_based_options_set_index_block_restart_interval( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.index_block_restart_interval = v; +} + +int rocksdb_block_based_options_get_index_block_restart_interval( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.index_block_restart_interval; +} + +void rocksdb_block_based_options_set_metadata_block_size( + rocksdb_block_based_table_options_t* opt, uint64_t v) { + opt->rep.metadata_block_size = v; +} + +uint64_t rocksdb_block_based_options_get_metadata_block_size( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.metadata_block_size; +} + +void rocksdb_block_based_options_set_partition_filters( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.partition_filters = v; +} + +unsigned char rocksdb_block_based_options_get_partition_filters( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.partition_filters; +} + +void rocksdb_block_based_options_set_decouple_partitioned_filters( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.decouple_partitioned_filters = v; +} + +unsigned char rocksdb_block_based_options_get_decouple_partitioned_filters( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.decouple_partitioned_filters; +} + +void rocksdb_block_based_options_set_optimize_filters_for_memory( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.optimize_filters_for_memory = v; +} + +unsigned char rocksdb_block_based_options_get_optimize_filters_for_memory( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.optimize_filters_for_memory; +} + +void rocksdb_block_based_options_set_use_delta_encoding( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.use_delta_encoding = v; +} + +unsigned char rocksdb_block_based_options_get_use_delta_encoding( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.use_delta_encoding; +} + +void rocksdb_block_based_options_set_use_udi_as_primary_index( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.use_udi_as_primary_index = v; +} + +unsigned char rocksdb_block_based_options_get_use_udi_as_primary_index( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.use_udi_as_primary_index; +} + +void rocksdb_block_based_options_set_fail_if_no_udi_on_open( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.fail_if_no_udi_on_open = v; +} + +unsigned char rocksdb_block_based_options_get_fail_if_no_udi_on_open( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.fail_if_no_udi_on_open; +} + +void rocksdb_block_based_options_set_whole_key_filtering( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.whole_key_filtering = v; +} + +unsigned char rocksdb_block_based_options_get_whole_key_filtering( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.whole_key_filtering; +} + +void rocksdb_block_based_options_set_detect_filter_construct_corruption( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.detect_filter_construct_corruption = v; +} + +unsigned char +rocksdb_block_based_options_get_detect_filter_construct_corruption( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.detect_filter_construct_corruption; +} + +void rocksdb_block_based_options_set_verify_compression( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.verify_compression = v; +} + +unsigned char rocksdb_block_based_options_get_verify_compression( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.verify_compression; +} + +void rocksdb_block_based_options_set_read_amp_bytes_per_bit( + rocksdb_block_based_table_options_t* opt, uint32_t v) { + opt->rep.read_amp_bytes_per_bit = v; +} + +uint32_t rocksdb_block_based_options_get_read_amp_bytes_per_bit( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.read_amp_bytes_per_bit; +} + +void rocksdb_block_based_options_set_format_version( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.format_version = static_castrep.format_version)>(v); +} + +uint32_t rocksdb_block_based_options_get_format_version( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.format_version; +} + +void rocksdb_block_based_options_set_separate_key_value_in_data_block( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.separate_key_value_in_data_block = v; +} + +unsigned char rocksdb_block_based_options_get_separate_key_value_in_data_block( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.separate_key_value_in_data_block; +} + +void rocksdb_block_based_options_set_uniform_cv_threshold( + rocksdb_block_based_table_options_t* opt, double v) { + opt->rep.uniform_cv_threshold = v; +} + +double rocksdb_block_based_options_get_uniform_cv_threshold( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.uniform_cv_threshold; +} + +void rocksdb_block_based_options_set_enable_index_compression( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.enable_index_compression = v; +} + +unsigned char rocksdb_block_based_options_get_enable_index_compression( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.enable_index_compression; +} + +void rocksdb_block_based_options_set_block_align( + rocksdb_block_based_table_options_t* opt, unsigned char v) { + opt->rep.block_align = v; +} + +unsigned char rocksdb_block_based_options_get_block_align( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.block_align; +} + +void rocksdb_block_based_options_set_super_block_alignment_size( + rocksdb_block_based_table_options_t* opt, size_t v) { + opt->rep.super_block_alignment_size = v; +} + +size_t rocksdb_block_based_options_get_super_block_alignment_size( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.super_block_alignment_size; +} + +void rocksdb_block_based_options_set_super_block_alignment_space_overhead_ratio( + rocksdb_block_based_table_options_t* opt, size_t v) { + opt->rep.super_block_alignment_space_overhead_ratio = v; +} + +size_t +rocksdb_block_based_options_get_super_block_alignment_space_overhead_ratio( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.super_block_alignment_space_overhead_ratio; +} + +void rocksdb_block_based_options_set_index_shortening( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.index_shortening = + static_castrep.index_shortening)>(v); +} + +int rocksdb_block_based_options_get_index_shortening( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.index_shortening); +} + +void rocksdb_block_based_options_set_max_auto_readahead_size( + rocksdb_block_based_table_options_t* opt, size_t v) { + opt->rep.max_auto_readahead_size = v; +} + +size_t rocksdb_block_based_options_get_max_auto_readahead_size( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.max_auto_readahead_size; +} + +void rocksdb_block_based_options_set_prepopulate_block_cache( + rocksdb_block_based_table_options_t* opt, int v) { + opt->rep.prepopulate_block_cache = + static_castrep.prepopulate_block_cache)>(v); +} + +int rocksdb_block_based_options_get_prepopulate_block_cache( + rocksdb_block_based_table_options_t* opt) { + return static_cast(opt->rep.prepopulate_block_cache); +} + +void rocksdb_block_based_options_set_initial_auto_readahead_size( + rocksdb_block_based_table_options_t* opt, size_t v) { + opt->rep.initial_auto_readahead_size = v; +} + +size_t rocksdb_block_based_options_get_initial_auto_readahead_size( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.initial_auto_readahead_size; +} + +void rocksdb_block_based_options_set_num_file_reads_for_auto_readahead( + rocksdb_block_based_table_options_t* opt, uint64_t v) { + opt->rep.num_file_reads_for_auto_readahead = v; +} + +uint64_t rocksdb_block_based_options_get_num_file_reads_for_auto_readahead( + rocksdb_block_based_table_options_t* opt) { + return opt->rep.num_file_reads_for_auto_readahead; +} + +/* CuckooTableOptions */ + +void rocksdb_cuckoo_options_set_hash_table_ratio( + rocksdb_cuckoo_table_options_t* opt, double v) { + opt->rep.hash_table_ratio = v; +} + +double rocksdb_cuckoo_options_get_hash_table_ratio( + rocksdb_cuckoo_table_options_t* opt) { + return opt->rep.hash_table_ratio; +} + +void rocksdb_cuckoo_options_set_max_search_depth( + rocksdb_cuckoo_table_options_t* opt, uint32_t v) { + opt->rep.max_search_depth = v; +} + +uint32_t rocksdb_cuckoo_options_get_max_search_depth( + rocksdb_cuckoo_table_options_t* opt) { + return opt->rep.max_search_depth; +} + +void rocksdb_cuckoo_options_set_cuckoo_block_size( + rocksdb_cuckoo_table_options_t* opt, uint32_t v) { + opt->rep.cuckoo_block_size = v; +} + +uint32_t rocksdb_cuckoo_options_get_cuckoo_block_size( + rocksdb_cuckoo_table_options_t* opt) { + return opt->rep.cuckoo_block_size; +} + +void rocksdb_cuckoo_options_set_identity_as_first_hash( + rocksdb_cuckoo_table_options_t* opt, unsigned char v) { + opt->rep.identity_as_first_hash = v; +} + +unsigned char rocksdb_cuckoo_options_get_identity_as_first_hash( + rocksdb_cuckoo_table_options_t* opt) { + return opt->rep.identity_as_first_hash; +} + +void rocksdb_cuckoo_options_set_use_module_hash( + rocksdb_cuckoo_table_options_t* opt, unsigned char v) { + opt->rep.use_module_hash = v; +} + +unsigned char rocksdb_cuckoo_options_get_use_module_hash( + rocksdb_cuckoo_table_options_t* opt) { + return opt->rep.use_module_hash; +} + +/* CompactionOptionsUniversal */ + +void rocksdb_universal_compaction_options_set_max_read_amp( + rocksdb_universal_compaction_options_t* opt, int v) { + opt->rep->max_read_amp = v; +} + +int rocksdb_universal_compaction_options_get_max_read_amp( + rocksdb_universal_compaction_options_t* opt) { + return opt->rep->max_read_amp; +} + +void rocksdb_universal_compaction_options_set_allow_trivial_move( + rocksdb_universal_compaction_options_t* opt, unsigned char v) { + opt->rep->allow_trivial_move = v; +} + +unsigned char rocksdb_universal_compaction_options_get_allow_trivial_move( + rocksdb_universal_compaction_options_t* opt) { + return opt->rep->allow_trivial_move; +} + +void rocksdb_universal_compaction_options_set_incremental( + rocksdb_universal_compaction_options_t* opt, unsigned char v) { + opt->rep->incremental = v; +} + +unsigned char rocksdb_universal_compaction_options_get_incremental( + rocksdb_universal_compaction_options_t* opt) { + return opt->rep->incremental; +} + +void rocksdb_universal_compaction_options_set_reduce_file_locking( + rocksdb_universal_compaction_options_t* opt, unsigned char v) { + opt->rep->reduce_file_locking = v; +} + +unsigned char rocksdb_universal_compaction_options_get_reduce_file_locking( + rocksdb_universal_compaction_options_t* opt) { + return opt->rep->reduce_file_locking; +} + +/* CompactionOptionsFIFO */ + +void rocksdb_fifo_compaction_options_set_age_for_warm( + rocksdb_fifo_compaction_options_t* opt, uint64_t v) { + opt->rep.age_for_warm = v; +} + +uint64_t rocksdb_fifo_compaction_options_get_age_for_warm( + rocksdb_fifo_compaction_options_t* opt) { + return opt->rep.age_for_warm; +} + +void rocksdb_fifo_compaction_options_set_allow_trivial_copy_when_change_temperature( + rocksdb_fifo_compaction_options_t* opt, unsigned char v) { + opt->rep.allow_trivial_copy_when_change_temperature = v; +} + +unsigned char +rocksdb_fifo_compaction_options_get_allow_trivial_copy_when_change_temperature( + rocksdb_fifo_compaction_options_t* opt) { + return opt->rep.allow_trivial_copy_when_change_temperature; +} + +void rocksdb_fifo_compaction_options_set_trivial_copy_buffer_size( + rocksdb_fifo_compaction_options_t* opt, uint64_t v) { + opt->rep.trivial_copy_buffer_size = v; +} + +uint64_t rocksdb_fifo_compaction_options_get_trivial_copy_buffer_size( + rocksdb_fifo_compaction_options_t* opt) { + return opt->rep.trivial_copy_buffer_size; +} + +/* BackupEngineOptions */ + +void rocksdb_backup_engine_options_set_backup_dir( + rocksdb_backup_engine_options_t* opt, const char* v) { + opt->rep.backup_dir = v; +} + +const char* rocksdb_backup_engine_options_get_backup_dir( + rocksdb_backup_engine_options_t* opt, size_t* size) { + *size = opt->rep.backup_dir.size(); + return opt->rep.backup_dir.data(); +} + +void rocksdb_backup_engine_options_set_share_table_files( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.share_table_files = v; +} + +unsigned char rocksdb_backup_engine_options_get_share_table_files( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.share_table_files; +} + +void rocksdb_backup_engine_options_set_sync( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.sync = v; +} + +unsigned char rocksdb_backup_engine_options_get_sync( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.sync; +} + +void rocksdb_backup_engine_options_set_destroy_old_data( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.destroy_old_data = v; +} + +unsigned char rocksdb_backup_engine_options_get_destroy_old_data( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.destroy_old_data; +} + +void rocksdb_backup_engine_options_set_backup_log_files( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.backup_log_files = v; +} + +unsigned char rocksdb_backup_engine_options_get_backup_log_files( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.backup_log_files; +} + +void rocksdb_backup_engine_options_set_io_buffer_size( + rocksdb_backup_engine_options_t* opt, uint64_t v) { + opt->rep.io_buffer_size = v; +} + +uint64_t rocksdb_backup_engine_options_get_io_buffer_size( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.io_buffer_size; +} + +void rocksdb_backup_engine_options_set_backup_rate_limit( + rocksdb_backup_engine_options_t* opt, uint64_t v) { + opt->rep.backup_rate_limit = v; +} + +uint64_t rocksdb_backup_engine_options_get_backup_rate_limit( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.backup_rate_limit; +} + +void rocksdb_backup_engine_options_set_restore_rate_limit( + rocksdb_backup_engine_options_t* opt, uint64_t v) { + opt->rep.restore_rate_limit = v; +} + +uint64_t rocksdb_backup_engine_options_get_restore_rate_limit( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.restore_rate_limit; +} + +void rocksdb_backup_engine_options_set_share_files_with_checksum( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.share_files_with_checksum = v; +} + +unsigned char rocksdb_backup_engine_options_get_share_files_with_checksum( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.share_files_with_checksum; +} + +void rocksdb_backup_engine_options_set_max_background_operations( + rocksdb_backup_engine_options_t* opt, int v) { + opt->rep.max_background_operations = v; +} + +int rocksdb_backup_engine_options_get_max_background_operations( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.max_background_operations; +} + +void rocksdb_backup_engine_options_set_callback_trigger_interval_size( + rocksdb_backup_engine_options_t* opt, uint64_t v) { + opt->rep.callback_trigger_interval_size = v; +} + +uint64_t rocksdb_backup_engine_options_get_callback_trigger_interval_size( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.callback_trigger_interval_size; +} + +void rocksdb_backup_engine_options_set_max_valid_backups_to_open( + rocksdb_backup_engine_options_t* opt, int v) { + opt->rep.max_valid_backups_to_open = v; +} + +int rocksdb_backup_engine_options_get_max_valid_backups_to_open( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.max_valid_backups_to_open; +} + +void rocksdb_backup_engine_options_set_share_files_with_checksum_naming( + rocksdb_backup_engine_options_t* opt, int v) { + opt->rep.share_files_with_checksum_naming = + static_castrep.share_files_with_checksum_naming)>(v); +} + +int rocksdb_backup_engine_options_get_share_files_with_checksum_naming( + rocksdb_backup_engine_options_t* opt) { + return static_cast(opt->rep.share_files_with_checksum_naming); +} + +void rocksdb_backup_engine_options_set_schema_version( + rocksdb_backup_engine_options_t* opt, int v) { + opt->rep.schema_version = v; +} + +int rocksdb_backup_engine_options_get_schema_version( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.schema_version; +} + +void rocksdb_backup_engine_options_set_current_temperatures_override_manifest( + rocksdb_backup_engine_options_t* opt, unsigned char v) { + opt->rep.current_temperatures_override_manifest = v; +} + +unsigned char +rocksdb_backup_engine_options_get_current_temperatures_override_manifest( + rocksdb_backup_engine_options_t* opt) { + return opt->rep.current_temperatures_override_manifest; +} + +/* CreateBackupOptions */ + +void rocksdb_create_backup_options_set_flush_before_backup( + rocksdb_create_backup_options_t* opt, unsigned char v) { + opt->rep.flush_before_backup = v; +} + +unsigned char rocksdb_create_backup_options_get_flush_before_backup( + rocksdb_create_backup_options_t* opt) { + return opt->rep.flush_before_backup; +} + +void rocksdb_create_backup_options_set_decrease_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt, unsigned char v) { + opt->rep.decrease_background_thread_cpu_priority = v; +} + +unsigned char +rocksdb_create_backup_options_get_decrease_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt) { + return opt->rep.decrease_background_thread_cpu_priority; +} + +void rocksdb_create_backup_options_set_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt, int v) { + opt->rep.background_thread_cpu_priority = + static_castrep.background_thread_cpu_priority)>(v); +} + +int rocksdb_create_backup_options_get_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt) { + return static_cast(opt->rep.background_thread_cpu_priority); +} + +void rocksdb_create_backup_options_set_atomic_flush( + rocksdb_create_backup_options_t* opt, unsigned char v) { + opt->rep.atomic_flush = v; +} + +unsigned char rocksdb_create_backup_options_get_atomic_flush( + rocksdb_create_backup_options_t* opt) { + return opt->rep.atomic_flush; +} + +/* RestoreOptions */ + +void rocksdb_restore_options_set_keep_log_files(rocksdb_restore_options_t* opt, + int v) { + opt->rep.keep_log_files = static_castrep.keep_log_files)>(v); +} + +unsigned char rocksdb_restore_options_get_keep_log_files( + rocksdb_restore_options_t* opt) { + return opt->rep.keep_log_files; +} + +void rocksdb_restore_options_set_mode(rocksdb_restore_options_t* opt, int v) { + opt->rep.mode = static_castrep.mode)>(v); +} + +int rocksdb_restore_options_get_mode(rocksdb_restore_options_t* opt) { + return static_cast(opt->rep.mode); +} + +/* TransactionDBOptions */ + +void rocksdb_transactiondb_options_set_max_num_locks( + rocksdb_transactiondb_options_t* opt, int64_t v) { + opt->rep.max_num_locks = v; +} + +int64_t rocksdb_transactiondb_options_get_max_num_locks( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.max_num_locks; +} + +void rocksdb_transactiondb_options_set_max_num_deadlocks( + rocksdb_transactiondb_options_t* opt, uint32_t v) { + opt->rep.max_num_deadlocks = v; +} + +uint32_t rocksdb_transactiondb_options_get_max_num_deadlocks( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.max_num_deadlocks; +} + +void rocksdb_transactiondb_options_set_num_stripes( + rocksdb_transactiondb_options_t* opt, size_t v) { + opt->rep.num_stripes = v; +} + +size_t rocksdb_transactiondb_options_get_num_stripes( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.num_stripes; +} + +void rocksdb_transactiondb_options_set_transaction_lock_timeout( + rocksdb_transactiondb_options_t* opt, int64_t v) { + opt->rep.transaction_lock_timeout = v; +} + +int64_t rocksdb_transactiondb_options_get_transaction_lock_timeout( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.transaction_lock_timeout; +} + +void rocksdb_transactiondb_options_set_default_lock_timeout( + rocksdb_transactiondb_options_t* opt, int64_t v) { + opt->rep.default_lock_timeout = v; +} + +int64_t rocksdb_transactiondb_options_get_default_lock_timeout( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.default_lock_timeout; +} + +void rocksdb_transactiondb_options_set_write_policy( + rocksdb_transactiondb_options_t* opt, int v) { + opt->rep.write_policy = static_castrep.write_policy)>(v); +} + +int rocksdb_transactiondb_options_get_write_policy( + rocksdb_transactiondb_options_t* opt) { + return static_cast(opt->rep.write_policy); +} + +void rocksdb_transactiondb_options_set_rollback_merge_operands( + rocksdb_transactiondb_options_t* opt, unsigned char v) { + opt->rep.rollback_merge_operands = v; +} + +unsigned char rocksdb_transactiondb_options_get_rollback_merge_operands( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.rollback_merge_operands; +} + +void rocksdb_transactiondb_options_set_use_per_key_point_lock_mgr( + rocksdb_transactiondb_options_t* opt, unsigned char v) { + opt->rep.use_per_key_point_lock_mgr = v; +} + +unsigned char rocksdb_transactiondb_options_get_use_per_key_point_lock_mgr( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.use_per_key_point_lock_mgr; +} + +void rocksdb_transactiondb_options_set_skip_concurrency_control( + rocksdb_transactiondb_options_t* opt, unsigned char v) { + opt->rep.skip_concurrency_control = v; +} + +unsigned char rocksdb_transactiondb_options_get_skip_concurrency_control( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.skip_concurrency_control; +} + +void rocksdb_transactiondb_options_set_default_write_batch_flush_threshold( + rocksdb_transactiondb_options_t* opt, int64_t v) { + opt->rep.default_write_batch_flush_threshold = v; +} + +int64_t rocksdb_transactiondb_options_get_default_write_batch_flush_threshold( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.default_write_batch_flush_threshold; +} + +void rocksdb_transactiondb_options_set_enable_udt_validation( + rocksdb_transactiondb_options_t* opt, unsigned char v) { + opt->rep.enable_udt_validation = v; +} + +unsigned char rocksdb_transactiondb_options_get_enable_udt_validation( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.enable_udt_validation; +} + +void rocksdb_transactiondb_options_set_txn_commit_bypass_memtable_threshold( + rocksdb_transactiondb_options_t* opt, uint32_t v) { + opt->rep.txn_commit_bypass_memtable_threshold = v; +} + +uint32_t rocksdb_transactiondb_options_get_txn_commit_bypass_memtable_threshold( + rocksdb_transactiondb_options_t* opt) { + return opt->rep.txn_commit_bypass_memtable_threshold; +} + +/* TransactionOptions */ + void rocksdb_transaction_options_set_set_snapshot( rocksdb_transaction_options_t* opt, unsigned char v) { opt->rep.set_snapshot = v; } +unsigned char rocksdb_transaction_options_get_set_snapshot( + rocksdb_transaction_options_t* opt) { + return opt->rep.set_snapshot; +} + void rocksdb_transaction_options_set_deadlock_detect( rocksdb_transaction_options_t* opt, unsigned char v) { opt->rep.deadlock_detect = v; } +unsigned char rocksdb_transaction_options_get_deadlock_detect( + rocksdb_transaction_options_t* opt) { + return opt->rep.deadlock_detect; +} + +void rocksdb_transaction_options_set_use_only_the_last_commit_time_batch_for_recovery( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.use_only_the_last_commit_time_batch_for_recovery = v; +} + +unsigned char +rocksdb_transaction_options_get_use_only_the_last_commit_time_batch_for_recovery( + rocksdb_transaction_options_t* opt) { + return opt->rep.use_only_the_last_commit_time_batch_for_recovery; +} + void rocksdb_transaction_options_set_lock_timeout( - rocksdb_transaction_options_t* opt, int64_t lock_timeout) { - opt->rep.lock_timeout = lock_timeout; + rocksdb_transaction_options_t* opt, int64_t v) { + opt->rep.lock_timeout = v; +} + +int64_t rocksdb_transaction_options_get_lock_timeout( + rocksdb_transaction_options_t* opt) { + return opt->rep.lock_timeout; +} + +void rocksdb_transaction_options_set_deadlock_timeout_us( + rocksdb_transaction_options_t* opt, int64_t v) { + opt->rep.deadlock_timeout_us = v; +} + +int64_t rocksdb_transaction_options_get_deadlock_timeout_us( + rocksdb_transaction_options_t* opt) { + return opt->rep.deadlock_timeout_us; } void rocksdb_transaction_options_set_expiration( - rocksdb_transaction_options_t* opt, int64_t expiration) { - opt->rep.expiration = expiration; + rocksdb_transaction_options_t* opt, int64_t v) { + opt->rep.expiration = v; +} + +int64_t rocksdb_transaction_options_get_expiration( + rocksdb_transaction_options_t* opt) { + return opt->rep.expiration; } void rocksdb_transaction_options_set_deadlock_detect_depth( - rocksdb_transaction_options_t* opt, int64_t depth) { - opt->rep.deadlock_detect_depth = depth; + rocksdb_transaction_options_t* opt, int64_t v) { + opt->rep.deadlock_detect_depth = v; +} + +int64_t rocksdb_transaction_options_get_deadlock_detect_depth( + rocksdb_transaction_options_t* opt) { + return opt->rep.deadlock_detect_depth; } void rocksdb_transaction_options_set_max_write_batch_size( - rocksdb_transaction_options_t* opt, size_t size) { - opt->rep.max_write_batch_size = size; + rocksdb_transaction_options_t* opt, size_t v) { + opt->rep.max_write_batch_size = v; +} + +size_t rocksdb_transaction_options_get_max_write_batch_size( + rocksdb_transaction_options_t* opt) { + return opt->rep.max_write_batch_size; +} + +void rocksdb_transaction_options_set_skip_concurrency_control( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.skip_concurrency_control = v; +} + +unsigned char rocksdb_transaction_options_get_skip_concurrency_control( + rocksdb_transaction_options_t* opt) { + return opt->rep.skip_concurrency_control; } void rocksdb_transaction_options_set_skip_prepare( @@ -7618,6 +12088,97 @@ void rocksdb_transaction_options_set_skip_prepare( opt->rep.skip_prepare = v; } +unsigned char rocksdb_transaction_options_get_skip_prepare( + rocksdb_transaction_options_t* opt) { + return opt->rep.skip_prepare; +} + +void rocksdb_transaction_options_set_write_batch_flush_threshold( + rocksdb_transaction_options_t* opt, int64_t v) { + opt->rep.write_batch_flush_threshold = v; +} + +int64_t rocksdb_transaction_options_get_write_batch_flush_threshold( + rocksdb_transaction_options_t* opt) { + return opt->rep.write_batch_flush_threshold; +} + +void rocksdb_transaction_options_set_write_batch_track_timestamp_size( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.write_batch_track_timestamp_size = v; +} + +unsigned char rocksdb_transaction_options_get_write_batch_track_timestamp_size( + rocksdb_transaction_options_t* opt) { + return opt->rep.write_batch_track_timestamp_size; +} + +void rocksdb_transaction_options_set_commit_bypass_memtable( + rocksdb_transaction_options_t* opt, unsigned char v) { + opt->rep.commit_bypass_memtable = v; +} + +unsigned char rocksdb_transaction_options_get_commit_bypass_memtable( + rocksdb_transaction_options_t* opt) { + return opt->rep.commit_bypass_memtable; +} + +void rocksdb_transaction_options_set_large_txn_commit_optimize_threshold( + rocksdb_transaction_options_t* opt, uint32_t v) { + opt->rep.large_txn_commit_optimize_threshold = v; +} + +uint32_t rocksdb_transaction_options_get_large_txn_commit_optimize_threshold( + rocksdb_transaction_options_t* opt) { + return opt->rep.large_txn_commit_optimize_threshold; +} + +void rocksdb_transaction_options_set_large_txn_commit_optimize_byte_threshold( + rocksdb_transaction_options_t* opt, uint64_t v) { + opt->rep.large_txn_commit_optimize_byte_threshold = v; +} + +uint64_t +rocksdb_transaction_options_get_large_txn_commit_optimize_byte_threshold( + rocksdb_transaction_options_t* opt) { + return opt->rep.large_txn_commit_optimize_byte_threshold; +} + +/* OptimisticTransactionOptions */ + +void rocksdb_optimistictransaction_options_set_set_snapshot( + rocksdb_optimistictransaction_options_t* opt, unsigned char v) { + opt->rep.set_snapshot = v; +} + +unsigned char rocksdb_optimistictransaction_options_get_set_snapshot( + rocksdb_optimistictransaction_options_t* opt) { + return opt->rep.set_snapshot; +} + +/* OptimisticTransactionDBOptions */ + +void rocksdb_optimistictransactiondb_options_set_validate_policy( + rocksdb_optimistictransactiondb_options_t* opt, int v) { + opt->rep.validate_policy = static_castrep.validate_policy)>(v); +} + +int rocksdb_optimistictransactiondb_options_get_validate_policy( + rocksdb_optimistictransactiondb_options_t* opt) { + return static_cast(opt->rep.validate_policy); +} + +void rocksdb_optimistictransactiondb_options_set_occ_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt, uint32_t v) { + opt->rep.occ_lock_buckets = v; +} + +uint32_t rocksdb_optimistictransactiondb_options_get_occ_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt) { + return opt->rep.occ_lock_buckets; +} +// END generated: c_generated_option_structs_auto.cc.inc + rocksdb_optimistictransaction_options_t* rocksdb_optimistictransaction_options_create() { return new rocksdb_optimistictransaction_options_t; @@ -7628,11 +12189,6 @@ void rocksdb_optimistictransaction_options_destroy( delete opt; } -void rocksdb_optimistictransaction_options_set_set_snapshot( - rocksdb_optimistictransaction_options_t* opt, unsigned char v) { - opt->rep.set_snapshot = v; -} - char* rocksdb_optimistictransactiondb_property_value( rocksdb_optimistictransactiondb_t* db, const char* propname) { std::string tmp; @@ -7837,6 +12393,63 @@ void rocksdb_transaction_rebuild_from_writebatch_wi(rocksdb_transaction_t* txn, SaveError(errptr, txn->rep->RebuildFromWriteBatch(wi->rep->GetWriteBatch())); } +// BEGIN generated: c_generated_transaction_subset.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'Transaction' +// --header-out +// c_api_gen/c_generated_transaction_subset.h.inc +// --source-out +// c_api_gen/c_generated_transaction_subset.cc.inc + +/* Transaction */ + +void rocksdb_transaction_put(rocksdb_transaction_t* txn, const char* key, + size_t klen, const char* val, size_t vlen, + char** errptr) { + SaveError(errptr, txn->rep->Put(Slice(key, klen), Slice(val, vlen))); +} + +void rocksdb_transaction_put_cf(rocksdb_transaction_t* txn, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, + size_t vlen, char** errptr) { + SaveError(errptr, txn->rep->Put(column_family->rep, Slice(key, klen), + Slice(val, vlen))); +} + +void rocksdb_transaction_merge(rocksdb_transaction_t* txn, const char* key, + size_t klen, const char* val, size_t vlen, + char** errptr) { + SaveError(errptr, txn->rep->Merge(Slice(key, klen), Slice(val, vlen))); +} + +void rocksdb_transaction_merge_cf(rocksdb_transaction_t* txn, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, + size_t vlen, char** errptr) { + SaveError(errptr, txn->rep->Merge(column_family->rep, Slice(key, klen), + Slice(val, vlen))); +} + +void rocksdb_transaction_delete(rocksdb_transaction_t* txn, const char* key, + size_t klen, char** errptr) { + SaveError(errptr, txn->rep->Delete(Slice(key, klen))); +} + +void rocksdb_transaction_delete_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, char** errptr) { + SaveError(errptr, txn->rep->Delete(column_family->rep, Slice(key, klen))); +} + void rocksdb_transaction_commit(rocksdb_transaction_t* txn, char** errptr) { SaveError(errptr, txn->rep->Commit()); } @@ -7845,6 +12458,11 @@ void rocksdb_transaction_rollback(rocksdb_transaction_t* txn, char** errptr) { SaveError(errptr, txn->rep->Rollback()); } +void rocksdb_transaction_put_log_data(rocksdb_transaction_t* txn, + const char* blob, size_t len) { + txn->rep->PutLogData(Slice(blob, len)); +} + void rocksdb_transaction_set_savepoint(rocksdb_transaction_t* txn) { txn->rep->SetSavePoint(); } @@ -7853,6 +12471,7 @@ void rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t* txn, char** errptr) { SaveError(errptr, txn->rep->RollbackToSavePoint()); } +// END generated: c_generated_transaction_subset.cc.inc void rocksdb_transaction_destroy(rocksdb_transaction_t* txn) { delete txn->rep; @@ -8300,21 +12919,6 @@ void rocksdb_transactiondb_multi_get_cf( } } -// Put a key inside a transaction -void rocksdb_transaction_put(rocksdb_transaction_t* txn, const char* key, - size_t klen, const char* val, size_t vlen, - char** errptr) { - SaveError(errptr, txn->rep->Put(Slice(key, klen), Slice(val, vlen))); -} - -void rocksdb_transaction_put_cf(rocksdb_transaction_t* txn, - rocksdb_column_family_handle_t* column_family, - const char* key, size_t klen, const char* val, - size_t vlen, char** errptr) { - SaveError(errptr, txn->rep->Put(column_family->rep, Slice(key, klen), - Slice(val, vlen))); -} - void rocksdb_transaction_set_commit_timestamp(rocksdb_transaction_t* txn, uint64_t commit_timestamp) { txn->rep->SetCommitTimestamp(commit_timestamp); @@ -8325,7 +12929,24 @@ void rocksdb_transaction_set_read_timestamp_for_validation( txn->rep->SetReadTimestampForValidation(read_timestamp); } -// Put a key outside a transaction +// BEGIN generated: c_generated_transactiondb_subset.cc.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'TransactionDB simple' +// --header-out +// c_api_gen/c_generated_transactiondb_subset.h.inc +// --source-out +// c_api_gen/c_generated_transactiondb_subset.cc.inc + +/* TransactionDB simple */ + void rocksdb_transactiondb_put(rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, const char* key, size_t klen, const char* val, @@ -8344,29 +12965,12 @@ void rocksdb_transactiondb_put_cf(rocksdb_transactiondb_t* txn_db, Slice(key, keylen), Slice(val, vallen))); } -// Write batch into transaction db void rocksdb_transactiondb_write(rocksdb_transactiondb_t* db, const rocksdb_writeoptions_t* options, rocksdb_writebatch_t* batch, char** errptr) { SaveError(errptr, db->rep->Write(options->rep, &batch->rep)); } -// Merge a key inside a transaction -void rocksdb_transaction_merge(rocksdb_transaction_t* txn, const char* key, - size_t klen, const char* val, size_t vlen, - char** errptr) { - SaveError(errptr, txn->rep->Merge(Slice(key, klen), Slice(val, vlen))); -} - -void rocksdb_transaction_merge_cf(rocksdb_transaction_t* txn, - rocksdb_column_family_handle_t* column_family, - const char* key, size_t klen, const char* val, - size_t vlen, char** errptr) { - SaveError(errptr, txn->rep->Merge(column_family->rep, Slice(key, klen), - Slice(val, vlen))); -} - -// Merge a key outside a transaction void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, const char* key, size_t klen, const char* val, @@ -8383,24 +12987,6 @@ void rocksdb_transactiondb_merge_cf( Slice(key, klen), Slice(val, vlen))); } -// Delete a key inside a transaction -void rocksdb_transaction_delete(rocksdb_transaction_t* txn, const char* key, - size_t klen, char** errptr) { - SaveError(errptr, txn->rep->Delete(Slice(key, klen))); -} - -void rocksdb_transaction_delete_cf( - rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, - const char* key, size_t klen, char** errptr) { - SaveError(errptr, txn->rep->Delete(column_family->rep, Slice(key, klen))); -} - -void rocksdb_transaction_put_log_data(rocksdb_transaction_t* txn, - const char* blob, size_t len) { - txn->rep->PutLogData(Slice(blob, len)); -} - -// Delete a key outside a transaction void rocksdb_transactiondb_delete(rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, const char* key, size_t klen, char** errptr) { @@ -8415,6 +13001,24 @@ void rocksdb_transactiondb_delete_cf( Slice(key, keylen))); } +void rocksdb_transactiondb_flush_wal(rocksdb_transactiondb_t* txn_db, + unsigned char sync, char** errptr) { + SaveError(errptr, txn_db->rep->FlushWAL(sync)); +} + +void rocksdb_transactiondb_flush(rocksdb_transactiondb_t* txn_db, + const rocksdb_flushoptions_t* options, + char** errptr) { + SaveError(errptr, txn_db->rep->Flush(options->rep)); +} + +void rocksdb_transactiondb_flush_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, char** errptr) { + SaveError(errptr, txn_db->rep->Flush(options->rep, column_family->rep)); +} +// END generated: c_generated_transactiondb_subset.cc.inc + // Create an iterator inside a transaction rocksdb_iterator_t* rocksdb_transaction_create_iterator( rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options) { @@ -8453,23 +13057,6 @@ void rocksdb_transactiondb_close(rocksdb_transactiondb_t* txn_db) { delete txn_db; } -void rocksdb_transactiondb_flush_wal(rocksdb_transactiondb_t* txn_db, - unsigned char sync, char** errptr) { - SaveError(errptr, txn_db->rep->FlushWAL(sync)); -} - -void rocksdb_transactiondb_flush(rocksdb_transactiondb_t* txn_db, - const rocksdb_flushoptions_t* options, - char** errptr) { - SaveError(errptr, txn_db->rep->Flush(options->rep)); -} - -void rocksdb_transactiondb_flush_cf( - rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, - rocksdb_column_family_handle_t* column_family, char** errptr) { - SaveError(errptr, txn_db->rep->Flush(options->rep, column_family->rep)); -} - void rocksdb_transactiondb_flush_cfs( rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, rocksdb_column_family_handle_t** column_families, int num_column_families, @@ -8482,6 +13069,14 @@ void rocksdb_transactiondb_flush_cfs( SaveError(errptr, txn_db->rep->Flush(options->rep, column_family_handles)); } +void rocksdb_transactiondb_flush_wal_with_options( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushwaloptions_t* options, + char** errptr) { + FlushWALOptions default_options; + SaveError(errptr, txn_db->rep->FlushWAL( + GetFlushWALOptions(options, &default_options))); +} + rocksdb_checkpoint_t* rocksdb_transactiondb_checkpoint_object_create( rocksdb_transactiondb_t* txn_db, char** errptr) { Checkpoint* checkpoint; @@ -8500,10 +13095,33 @@ rocksdb_optimistictransactiondb_t* rocksdb_optimistictransactiondb_open( options->rep, std::string(name), &otxn_db))) { return nullptr; } - rocksdb_optimistictransactiondb_t* result = - new rocksdb_optimistictransactiondb_t; - result->rep = otxn_db; - return result; + return WrapOptimisticTransactionDB(otxn_db); +} + +rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open_with_otxn_db_options( + const rocksdb_options_t* options, + const rocksdb_optimistictransactiondb_options_t* otxn_db_options, + const char* name, char** errptr) { + std::vector column_families; + column_families.emplace_back(ROCKSDB_NAMESPACE::kDefaultColumnFamilyName, + ColumnFamilyOptions(options->rep)); + + std::vector handles; + OptimisticTransactionDBOptions default_options; + const OptimisticTransactionDBOptions& effective_options = + GetOptimisticTransactionDBOptions(otxn_db_options, &default_options); + OptimisticTransactionDB* otxn_db; + if (SaveError(errptr, + OptimisticTransactionDB::Open( + DBOptions(options->rep), effective_options, + std::string(name), column_families, &handles, &otxn_db))) { + return nullptr; + } + for (auto* handle : handles) { + delete handle; + } + return WrapOptimisticTransactionDB(otxn_db); } rocksdb_optimistictransactiondb_t* @@ -8534,10 +13152,45 @@ rocksdb_optimistictransactiondb_open_column_families( c_handle->immortal = false; column_family_handles[i] = c_handle; } - rocksdb_optimistictransactiondb_t* result = - new rocksdb_optimistictransactiondb_t; - result->rep = otxn_db; - return result; + return WrapOptimisticTransactionDB(otxn_db); +} + +rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open_column_families_with_otxn_db_options( + const rocksdb_options_t* db_options, + const rocksdb_optimistictransactiondb_options_t* otxn_db_options, + const char* name, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr) { + std::vector column_families; + column_families.reserve(num_column_families); + for (int i = 0; i < num_column_families; i++) { + column_families.emplace_back( + std::string(column_family_names[i]), + ColumnFamilyOptions(column_family_options[i]->rep)); + } + + OptimisticTransactionDBOptions default_options; + const OptimisticTransactionDBOptions& effective_options = + GetOptimisticTransactionDBOptions(otxn_db_options, &default_options); + + OptimisticTransactionDB* otxn_db; + std::vector handles; + if (SaveError(errptr, + OptimisticTransactionDB::Open( + DBOptions(db_options->rep), effective_options, + std::string(name), column_families, &handles, &otxn_db))) { + return nullptr; + } + + for (size_t i = 0; i < handles.size(); i++) { + auto* c_handle = new rocksdb_column_family_handle_t; + c_handle->rep = handles[i]; + c_handle->immortal = false; + column_family_handles[i] = c_handle; + } + return WrapOptimisticTransactionDB(otxn_db); } rocksdb_t* rocksdb_optimistictransactiondb_get_base_db( @@ -8733,26 +13386,6 @@ uint64_t rocksdb_approximate_memory_usage_get_cache_total( return memory_usage->cache_total; } -void rocksdb_options_set_dump_malloc_stats(rocksdb_options_t* opt, - unsigned char val) { - opt->rep.dump_malloc_stats = val; -} - -void rocksdb_options_set_memtable_whole_key_filtering(rocksdb_options_t* opt, - unsigned char val) { - opt->rep.memtable_whole_key_filtering = val; -} - -void rocksdb_options_set_avoid_unnecessary_blocking_io(rocksdb_options_t* opt, - unsigned char val) { - opt->rep.avoid_unnecessary_blocking_io = val; -} - -unsigned char rocksdb_options_get_avoid_unnecessary_blocking_io( - rocksdb_options_t* opt) { - return opt->rep.avoid_unnecessary_blocking_io; -} - // deletes container with memory usage estimates void rocksdb_approximate_memory_usage_destroy(rocksdb_memory_usage_t* usage) { delete usage; diff --git a/db/c_test.c b/db/c_test.c index cfb4f22845..8bb38e9d3a 100644 --- a/db/c_test.c +++ b/db/c_test.c @@ -104,6 +104,18 @@ static void Free(char** ptr) { } } +static long GetLocalFileSize(const char* path) { + FILE* file = fopen(path, "rb"); + long size; + if (file == NULL) { + return -1; + } + CheckCondition(fseek(file, 0, SEEK_END) == 0); + size = ftell(file); + fclose(file); + return size; +} + static void CheckValue(char* err, const char* expected, char** actual, size_t actual_length) { CheckNoError(err); @@ -371,6 +383,282 @@ static rocksdb_compactionfilter_t* CFilterCreate( CFilterName); } +typedef struct TableFilterState { + int calls; + int saw_entries_1; + int saw_entries_2; + int saw_entries_3; + uint64_t hidden_num_entries; + int destructor_calls; +} TableFilterState; + +static void TableFilterStateDestroy(void* arg) { + TableFilterState* state = (TableFilterState*)arg; + state->destructor_calls++; +} + +static unsigned char TableFilterCallback( + void* arg, const rocksdb_table_properties_t* props) { + TableFilterState* state = (TableFilterState*)arg; + uint64_t num_entries = rocksdb_table_properties_num_entries(props); + size_t cf_name_len = 0; + const char* cf_name = + rocksdb_table_properties_column_family_name(props, &cf_name_len); + size_t readable_count = + rocksdb_table_properties_readable_properties_count(props); + + state->calls++; + CheckEqual("default", cf_name, cf_name_len); + CheckCondition(1 == rocksdb_table_properties_has_key_largest_seqno(props)); + CheckCondition(1 == rocksdb_table_properties_has_key_smallest_seqno(props)); + if (readable_count > 0) { + size_t key_len = 0; + size_t value_len = 0; + CheckCondition(rocksdb_table_properties_readable_properties_key_at( + props, 0, &key_len) != NULL); + CheckCondition(key_len > 0); + CheckCondition(rocksdb_table_properties_readable_properties_value_at( + props, 0, &value_len) != NULL); + CheckCondition(value_len > 0); + } + + switch (num_entries) { + case 1: + state->saw_entries_1 = 1; + break; + case 2: + state->saw_entries_2 = 1; + break; + case 3: + state->saw_entries_3 = 1; + break; + default: + CheckCondition(0); + } + + return num_entries != state->hidden_num_entries; +} + +typedef struct ListenerState { + int flush_count; + int saw_flush_entries_1; + int saw_flush_entries_2; + int saw_flush_entries_3; + int compaction_count; + int external_ingest_count; + const char* expected_external_file_path; +} ListenerState; + +static void ListenerNoopDestructor(void* arg) { (void)arg; } + +static void ListenerOnFlushBegin(void* state, rocksdb_t* db, + const rocksdb_flushjobinfo_t* info) { + (void)state; + (void)db; + (void)info; +} + +static void ListenerOnFlushCompleted(void* arg, rocksdb_t* db, + const rocksdb_flushjobinfo_t* info) { + ListenerState* state = (ListenerState*)arg; + const rocksdb_table_properties_t* props; + size_t cf_name_len = 0; + const char* cf_name = rocksdb_flushjobinfo_cf_name(info, &cf_name_len); + uint64_t num_entries; + + (void)db; + CheckEqual("default", cf_name, cf_name_len); + props = rocksdb_flushjobinfo_table_properties(info); + num_entries = rocksdb_table_properties_num_entries(props); + CheckCondition(1 == rocksdb_table_properties_has_key_largest_seqno(props)); + CheckCondition(1 == rocksdb_table_properties_has_key_smallest_seqno(props)); + CheckCondition(0 == + rocksdb_flushjobinfo_blob_file_addition_infos_count(info)); + + switch (num_entries) { + case 1: + state->saw_flush_entries_1 = 1; + break; + case 2: + state->saw_flush_entries_2 = 1; + break; + case 3: + state->saw_flush_entries_3 = 1; + break; + default: + CheckCondition(0); + } + state->flush_count++; +} + +static void ListenerOnCompactionBegin(void* state, rocksdb_t* db, + const rocksdb_compactionjobinfo_t* info) { + (void)state; + (void)db; + (void)info; +} + +static void ListenerOnCompactionCompleted( + void* arg, rocksdb_t* db, const rocksdb_compactionjobinfo_t* info) { + ListenerState* state = (ListenerState*)arg; + size_t input_count = rocksdb_compactionjobinfo_input_files_count(info); + size_t output_count = rocksdb_compactionjobinfo_output_files_count(info); + size_t file_name_len = 0; + const char* file_name; + const rocksdb_compaction_file_info_t* input_file_info; + const rocksdb_compaction_file_info_t* output_file_info; + const rocksdb_compaction_job_stats_t* stats; + const rocksdb_table_properties_t* props; + + (void)db; + CheckCondition(input_count > 0); + CheckCondition(output_count > 0); + + file_name = rocksdb_compactionjobinfo_input_file_at(info, 0, &file_name_len); + CheckCondition(file_name != NULL); + CheckCondition(file_name_len > 0); + + input_file_info = rocksdb_compactionjobinfo_input_file_info_at(info, 0); + CheckCondition(input_file_info != NULL); + CheckCondition(rocksdb_compaction_file_info_file_number(input_file_info) > 0); + + output_file_info = rocksdb_compactionjobinfo_output_file_info_at(info, 0); + CheckCondition(output_file_info != NULL); + CheckCondition(rocksdb_compaction_file_info_file_number(output_file_info) > + 0); + + stats = rocksdb_compactionjobinfo_stats(info); + CheckCondition(stats != NULL); + CheckCondition(rocksdb_compactionjobinfo_input_file_infos_count(info) == + input_count); + CheckCondition(rocksdb_compactionjobinfo_output_file_infos_count(info) == + output_count); + CheckCondition(rocksdb_compaction_job_stats_num_input_files(stats) >= + input_count); + CheckCondition(rocksdb_compaction_job_stats_num_output_files(stats) <= + output_count); + + CheckCondition(rocksdb_compactionjobinfo_table_properties_count(info) > 0); + props = rocksdb_compactionjobinfo_table_properties_for_file(info, file_name, + file_name_len); + CheckCondition(props != NULL); + CheckCondition(rocksdb_table_properties_num_entries(props) > 0); + + CheckCondition( + 0 == rocksdb_compactionjobinfo_blob_file_addition_infos_count(info)); + CheckCondition(0 == + rocksdb_compactionjobinfo_blob_file_garbage_infos_count(info)); + state->compaction_count++; +} + +static void ListenerOnSubcompactionBegin( + void* state, const rocksdb_subcompactionjobinfo_t* info) { + (void)state; + (void)info; +} + +static void ListenerOnSubcompactionCompleted( + void* state, const rocksdb_subcompactionjobinfo_t* info) { + (void)state; + (void)info; +} + +static void ListenerOnExternalFileIngested( + void* arg, rocksdb_t* db, const rocksdb_externalfileingestioninfo_t* info) { + ListenerState* state = (ListenerState*)arg; + size_t path_len = 0; + const char* external_path = + rocksdb_externalfileingestioninfo_external_file_path(info, &path_len); + const rocksdb_table_properties_t* props = + rocksdb_externalfileingestioninfo_table_properties(info); + + (void)db; + CheckEqual(state->expected_external_file_path, external_path, path_len); + CheckCondition(rocksdb_table_properties_num_entries(props) == 2); + state->external_ingest_count++; +} + +static void ListenerOnBackgroundError(void* state, uint32_t reason, + rocksdb_status_ptr_t* status) { + (void)state; + (void)reason; + (void)status; +} + +static void ListenerOnStallConditionsChanged( + void* state, const rocksdb_writestallinfo_t* info) { + (void)state; + (void)info; +} + +static void ListenerOnMemtableSealed(void* state, + const rocksdb_memtableinfo_t* info) { + (void)state; + (void)info; +} + +typedef struct WalFilterState { + int column_family_map_calls; + int log_record_calls; + int destructor_calls; +} WalFilterState; + +static void WalFilterDestroy(void* arg) { + WalFilterState* state = (WalFilterState*)arg; + state->destructor_calls++; +} + +static void WalFilterColumnFamilyLogNumberMap( + void* arg, const uint32_t* column_family_ids, const uint64_t* log_numbers, + size_t column_family_log_number_count, + const char* const* column_family_names, + const size_t* column_family_name_lengths, + const uint32_t* column_family_name_ids, size_t column_family_name_count) { + WalFilterState* state = (WalFilterState*)arg; + size_t i; + + if (column_family_log_number_count > 0) { + CheckCondition(column_family_ids != NULL); + CheckCondition(log_numbers != NULL); + } + if (column_family_name_count > 0) { + CheckCondition(column_family_names != NULL); + CheckCondition(column_family_name_lengths != NULL); + CheckCondition(column_family_name_ids != NULL); + } + for (i = 0; i < column_family_name_count; ++i) { + CheckCondition(column_family_names[i] != NULL); + CheckCondition(column_family_name_lengths[i] > 0); + } + state->column_family_map_calls++; +} + +static int WalFilterLogRecordFound(void* arg, unsigned long long log_number, + const char* log_file_name, + size_t log_file_name_len, + const rocksdb_writebatch_t* batch, + rocksdb_writebatch_t* new_batch, + unsigned char* batch_changed) { + WalFilterState* state = (WalFilterState*)arg; + (void)log_number; + (void)log_file_name; + (void)log_file_name_len; + (void)new_batch; + + CheckCondition(rocksdb_writebatch_count((rocksdb_writebatch_t*)batch) == 1); + *batch_changed = 0; + state->log_record_calls++; + if (state->log_record_calls == 1) { + return rocksdb_wal_filter_ignore_current_record; + } + return rocksdb_wal_filter_continue_processing; +} + +static const char* WalFilterName(void* arg) { + (void)arg; + return "CTestWalFilter"; +} + void CheckMetaData(rocksdb_column_family_metadata_t* cf_meta, const char* expected_cf_name) { char* cf_name = rocksdb_column_family_metadata_get_name(cf_meta); @@ -760,6 +1048,12 @@ typedef struct { char last_db_name[256]; } RemoteCompactionState; +typedef struct { + int progress_calls; + int exclude_calls; + char last_relative_file[256]; +} CreateBackupOptionsState; + // Schedule callback - gets called when compaction is scheduled static rocksdb_compactionservice_scheduleresponse_t* RemoteCompactionSchedule( void* state, const rocksdb_compactionservice_jobinfo_t* info, @@ -822,6 +1116,24 @@ static void RemoteCompactionCancel(void* state) { // Destructor callback static void RemoteCompactionDestroy(void* state) { (void)state; } +static void CreateBackupProgress(void* state) { + CreateBackupOptionsState* backup_state = (CreateBackupOptionsState*)state; + backup_state->progress_calls++; +} + +static unsigned char CreateBackupExcludeFile(void* state, + const char* relative_file, + size_t relative_file_len) { + CreateBackupOptionsState* backup_state = (CreateBackupOptionsState*)state; + backup_state->exclude_calls++; + if (relative_file_len >= sizeof(backup_state->last_relative_file)) { + relative_file_len = sizeof(backup_state->last_relative_file) - 1; + } + memcpy(backup_state->last_relative_file, relative_file, relative_file_len); + backup_state->last_relative_file[relative_file_len] = '\0'; + return 0; +} + // NULL schedule callback for testing failure handling static rocksdb_compactionservice_scheduleresponse_t* NullSchedule( void* state, const rocksdb_compactionservice_jobinfo_t* info, @@ -833,6 +1145,13 @@ static rocksdb_compactionservice_scheduleresponse_t* NullSchedule( return NULL; // Return NULL to simulate failure } +// Auto-generated set->get->assert round-trip coverage for the generated option +// wrappers. Defines static rocksdb_roundtrip_test_* helpers and +// rocksdb_run_generated_roundtrip_tests(); regenerated by +// tools/c_api_gen/regen_all.py. Included here (after the CheckCondition macro) +// so it can use the test harness. +#include "c_api_gen/c_generated_roundtrip_tests.c.inc" + int main(int argc, char** argv) { (void)argc; (void)argv; @@ -1049,6 +1368,107 @@ int main(int argc, char** argv) { rocksdb_backup_engine_close(be); } + StartPhase("backup_create_options"); + { + char backup_options_dbname[300]; + char backup_options_backup_dir[300]; + snprintf(backup_options_dbname, sizeof(backup_options_dbname), + "%s/rocksdb_c_test-%d-backup-options-db", GetTempDir(), + ((int)geteuid())); + snprintf(backup_options_backup_dir, sizeof(backup_options_backup_dir), + "%s/rocksdb_c_test-%d-backup-options-backup", GetTempDir(), + ((int)geteuid())); + + rocksdb_options_t* backup_db_options = rocksdb_options_create(); + rocksdb_options_set_create_if_missing(backup_db_options, 1); + rocksdb_destroy_db(backup_db_options, backup_options_dbname, &err); + CheckNoError(err); + + rocksdb_t* backup_db = + rocksdb_open(backup_db_options, backup_options_dbname, &err); + CheckNoError(err); + rocksdb_put(backup_db, woptions, "backup-key", 10, "backup-value", 12, + &err); + CheckNoError(err); + + rocksdb_backup_engine_options_t* backup_engine_options = + rocksdb_backup_engine_options_create(backup_options_backup_dir); + rocksdb_backup_engine_options_set_destroy_old_data(backup_engine_options, + 1); + rocksdb_backup_engine_options_set_callback_trigger_interval_size( + backup_engine_options, 1); + rocksdb_backup_engine_t* be = + rocksdb_backup_engine_open_opts(backup_engine_options, env, &err); + CheckNoError(err); + rocksdb_backup_engine_options_destroy(backup_engine_options); + + rocksdb_create_backup_options_t* create_backup_options = + rocksdb_create_backup_options_create(); + CreateBackupOptionsState backup_state = {0}; + uint32_t backup_id = 0; + rocksdb_create_backup_options_set_flush_before_backup(create_backup_options, + 1); + CheckCondition(1 == rocksdb_create_backup_options_get_flush_before_backup( + create_backup_options)); + rocksdb_create_backup_options_set_decrease_background_thread_cpu_priority( + create_backup_options, 1); + CheckCondition( + 1 == + rocksdb_create_backup_options_get_decrease_background_thread_cpu_priority( + create_backup_options)); + rocksdb_create_backup_options_set_background_thread_cpu_priority( + create_backup_options, 1); + CheckCondition( + 1 == rocksdb_create_backup_options_get_background_thread_cpu_priority( + create_backup_options)); + rocksdb_create_backup_options_set_atomic_flush(create_backup_options, 1); + CheckCondition(1 == rocksdb_create_backup_options_get_atomic_flush( + create_backup_options)); + rocksdb_create_backup_options_set_atomic_flush(create_backup_options, 0); + rocksdb_create_backup_options_set_progress_callback( + create_backup_options, &backup_state, CreateBackupProgress); + rocksdb_create_backup_options_set_exclude_files_callback( + create_backup_options, &backup_state, CreateBackupExcludeFile); + rocksdb_create_backup_options_set_exclude_files_callback( + create_backup_options, NULL, NULL); + + rocksdb_backup_engine_create_new_backup_with_options( + be, backup_db, create_backup_options, &backup_id, &err); + CheckNoError(err); + CheckCondition(backup_id > 0); + CheckCondition(backup_state.progress_calls > 0); + + rocksdb_put(backup_db, woptions, "backup-key-2", 12, "backup-value-2", 14, + &err); + CheckNoError(err); + + rocksdb_backup_engine_create_new_backup_with_metadata( + be, backup_db, create_backup_options, "meta-1", 6, &backup_id, &err); + CheckNoError(err); + CheckCondition(backup_id > 0); + + { + const rocksdb_backup_engine_info_t* bei = + rocksdb_backup_engine_get_backup_info(be); + CheckCondition(rocksdb_backup_engine_info_count(bei) > 1); + { + int latest_backup = rocksdb_backup_engine_info_count(bei) - 1; + size_t app_metadata_len = 0; + const char* app_metadata = rocksdb_backup_engine_info_app_metadata( + bei, latest_backup, &app_metadata_len); + CheckEqual("meta-1", app_metadata, app_metadata_len); + } + rocksdb_backup_engine_info_destroy(bei); + } + + rocksdb_create_backup_options_destroy(create_backup_options); + rocksdb_backup_engine_close(be); + rocksdb_close(backup_db); + rocksdb_destroy_db(backup_db_options, backup_options_dbname, &err); + CheckNoError(err); + rocksdb_options_destroy(backup_db_options); + } + StartPhase("checkpoint"); { rocksdb_destroy_db(options, dbcheckpointname, &err); @@ -1281,6 +1701,35 @@ int main(int argc, char** argv) { StartPhase("addfile"); { rocksdb_envoptions_t* env_opt = rocksdb_envoptions_create(); + rocksdb_ratelimiter_t* env_rate_limiter = + rocksdb_ratelimiter_create(32 * 1024 * 1024, 100 * 1000, 10); + rocksdb_envoptions_set_use_mmap_reads(env_opt, 1); + CheckCondition(1 == rocksdb_envoptions_get_use_mmap_reads(env_opt)); + rocksdb_envoptions_set_use_mmap_writes(env_opt, 0); + CheckCondition(0 == rocksdb_envoptions_get_use_mmap_writes(env_opt)); + rocksdb_envoptions_set_use_direct_reads(env_opt, 1); + CheckCondition(1 == rocksdb_envoptions_get_use_direct_reads(env_opt)); + rocksdb_envoptions_set_use_direct_writes(env_opt, 1); + CheckCondition(1 == rocksdb_envoptions_get_use_direct_writes(env_opt)); + rocksdb_envoptions_set_allow_fallocate(env_opt, 0); + CheckCondition(0 == rocksdb_envoptions_get_allow_fallocate(env_opt)); + rocksdb_envoptions_set_fd_cloexec(env_opt, 0); + CheckCondition(0 == rocksdb_envoptions_get_fd_cloexec(env_opt)); + rocksdb_envoptions_set_bytes_per_sync(env_opt, 4096); + CheckCondition(4096 == rocksdb_envoptions_get_bytes_per_sync(env_opt)); + rocksdb_envoptions_set_strict_bytes_per_sync(env_opt, 1); + CheckCondition(1 == rocksdb_envoptions_get_strict_bytes_per_sync(env_opt)); + rocksdb_envoptions_set_fallocate_with_keep_size(env_opt, 0); + CheckCondition(0 == + rocksdb_envoptions_get_fallocate_with_keep_size(env_opt)); + rocksdb_envoptions_set_compaction_readahead_size(env_opt, 8192); + CheckCondition(8192 == + rocksdb_envoptions_get_compaction_readahead_size(env_opt)); + rocksdb_envoptions_set_writable_file_max_buffer_size(env_opt, 16384); + CheckCondition( + 16384 == rocksdb_envoptions_get_writable_file_max_buffer_size(env_opt)); + rocksdb_envoptions_set_rate_limiter(env_opt, env_rate_limiter); + rocksdb_ratelimiter_destroy(env_rate_limiter); rocksdb_sstfilewriter_t* writer = rocksdb_sstfilewriter_create(env_opt, options); @@ -1357,11 +1806,16 @@ int main(int argc, char** argv) { StartPhase("writebatch"); { rocksdb_writebatch_t* wb = rocksdb_writebatch_create(); + rocksdb_writebatch_t* protected_wb = + rocksdb_writebatch_create_with_params(0, 0, 8, 0); rocksdb_writebatch_put(wb, "foo", 3, "a", 1); rocksdb_writebatch_clear(wb); rocksdb_writebatch_put(wb, "bar", 3, "b", 1); rocksdb_writebatch_put(wb, "box", 3, "c", 1); rocksdb_writebatch_delete(wb, "bar", 3); + rocksdb_writebatch_put(protected_wb, "sum", 3, "value", 5); + rocksdb_writebatch_verify_checksum(protected_wb, &err); + CheckNoError(err); rocksdb_write(db, woptions, wb, &err); CheckNoError(err); CheckGet(db, roptions, "foo", "hello"); @@ -1388,6 +1842,7 @@ int main(int argc, char** argv) { rocksdb_write(db, woptions, wb, &err); CheckNoError(err); CheckGet(db, roptions, "bay", NULL); + rocksdb_writebatch_destroy(protected_wb); rocksdb_writebatch_destroy(wb); } @@ -1822,6 +2277,102 @@ int main(int argc, char** argv) { CheckCondition(sizes[1] > 0); } + StartPhase("size_approximation_options"); + { + uint64_t sizes[2]; + const char* start[2] = {"a", "k00000000000000010000"}; + size_t start_len[2] = {1, 21}; + const char* limit[2] = {"k00000000000000010000", "z"}; + size_t limit_len[2] = {21, 1}; + rocksdb_size_approximation_options_t* size_options = + rocksdb_size_approximation_options_create(); + rocksdb_size_approximation_options_set_include_memtables(size_options, 1); + CheckCondition( + 1 == + rocksdb_size_approximation_options_get_include_memtables(size_options)); + rocksdb_size_approximation_options_set_include_files(size_options, 1); + CheckCondition(1 == rocksdb_size_approximation_options_get_include_files( + size_options)); + rocksdb_size_approximation_options_set_include_blob_files(size_options, 1); + CheckCondition(1 == + rocksdb_size_approximation_options_get_include_blob_files( + size_options)); + rocksdb_size_approximation_options_set_files_size_error_margin(size_options, + 0.25); + CheckCondition( + 0.25 == rocksdb_size_approximation_options_get_files_size_error_margin( + size_options)); + rocksdb_approximate_sizes_with_options( + db, size_options, 2, start, start_len, limit, limit_len, sizes, &err); + CheckNoError(err); + CheckCondition(sizes[0] > 0); + CheckCondition(sizes[1] > 0); + rocksdb_size_approximation_options_destroy(size_options); + } + + StartPhase("column_family_metadata_options"); + { + size_t key_len = 0; + rocksdb_column_family_metadata_options_t* metadata_options = + rocksdb_column_family_metadata_options_create(); + CheckCondition(-1 == rocksdb_column_family_metadata_options_get_level( + metadata_options)); + rocksdb_column_family_metadata_options_set_level(metadata_options, 0); + CheckCondition(0 == rocksdb_column_family_metadata_options_get_level( + metadata_options)); + rocksdb_column_family_metadata_options_set_level(metadata_options, -1); + CheckCondition(-1 == rocksdb_column_family_metadata_options_get_level( + metadata_options)); + rocksdb_column_family_metadata_options_set_start_key(metadata_options, "zz", + 2); + rocksdb_column_family_metadata_options_set_end_key(metadata_options, "zzz", + 3); + CheckCondition(0 == + memcmp(rocksdb_column_family_metadata_options_get_start_key( + metadata_options, &key_len), + "zz", key_len)); + CheckCondition(key_len == 2); + CheckCondition(0 == + memcmp(rocksdb_column_family_metadata_options_get_end_key( + metadata_options, &key_len), + "zzz", key_len)); + CheckCondition(key_len == 3); + + rocksdb_column_family_metadata_t* filtered_meta = + rocksdb_get_column_family_metadata_with_options(db, metadata_options); + CheckCondition( + 0 == rocksdb_column_family_metadata_get_file_count(filtered_meta)); + rocksdb_column_family_metadata_destroy(filtered_meta); + + rocksdb_column_family_metadata_options_set_start_key(metadata_options, NULL, + 0); + rocksdb_column_family_metadata_options_set_end_key(metadata_options, NULL, + 0); + CheckCondition(NULL == rocksdb_column_family_metadata_options_get_start_key( + metadata_options, &key_len)); + CheckCondition(key_len == 0); + CheckCondition(NULL == rocksdb_column_family_metadata_options_get_end_key( + metadata_options, &key_len)); + CheckCondition(key_len == 0); + + filtered_meta = + rocksdb_get_column_family_metadata_with_options(db, metadata_options); + CheckCondition( + rocksdb_column_family_metadata_get_file_count(filtered_meta) > 0); + rocksdb_column_family_metadata_destroy(filtered_meta); + rocksdb_column_family_metadata_options_destroy(metadata_options); + } + + StartPhase("import_column_family_options"); + { + rocksdb_import_column_family_options_t* import_options = + rocksdb_import_column_family_options_create(); + rocksdb_import_column_family_options_set_move_files(import_options, 1); + CheckCondition(1 == rocksdb_import_column_family_options_get_move_files( + import_options)); + rocksdb_import_column_family_options_destroy(import_options); + } + StartPhase("property"); { char* prop = rocksdb_property_value(db, "nosuchprop"); @@ -2206,6 +2757,222 @@ int main(int argc, char** argv) { rocksdb_flush_wal(db, 1, &err); CheckNoError(err); + { + rocksdb_flushwaloptions_t* flush_wal_options = + rocksdb_flushwaloptions_create(); + rocksdb_flushwaloptions_set_sync(flush_wal_options, 1); + CheckCondition(1 == rocksdb_flushwaloptions_get_sync(flush_wal_options)); + rocksdb_flushwaloptions_set_rate_limiter_priority(flush_wal_options, 2); + CheckCondition(2 == rocksdb_flushwaloptions_get_rate_limiter_priority( + flush_wal_options)); + rocksdb_flush_wal_with_options(db, flush_wal_options, &err); + CheckNoError(err); + rocksdb_flushwaloptions_destroy(flush_wal_options); + } + + { + rocksdb_wal_readoptions_t* wal_read_options = + rocksdb_wal_readoptions_create(); + rocksdb_wal_iterator_t* wal_iterator; + rocksdb_writebatch_t* wal_batch; + uint64_t wal_seq = 0; + + CheckCondition( + 1 == rocksdb_wal_readoptions_get_verify_checksums(wal_read_options)); + rocksdb_wal_readoptions_set_verify_checksums(wal_read_options, 0); + CheckCondition( + 0 == rocksdb_wal_readoptions_get_verify_checksums(wal_read_options)); + + wal_iterator = rocksdb_get_updates_since(db, 0, wal_read_options, &err); + CheckNoError(err); + CheckCondition(wal_iterator != NULL); + CheckCondition(1 == rocksdb_wal_iter_valid(wal_iterator)); + wal_batch = rocksdb_wal_iter_get_batch(wal_iterator, &wal_seq); + CheckCondition(wal_seq > 0); + CheckCondition(rocksdb_writebatch_count(wal_batch) > 0); + + rocksdb_writebatch_destroy(wal_batch); + rocksdb_wal_iter_destroy(wal_iterator); + rocksdb_wal_readoptions_destroy(wal_read_options); + } + + { + const char* start[1] = {"a"}; + size_t start_len[1] = {1}; + const char* limit[1] = {"z"}; + size_t limit_len[1] = {1}; + uint64_t sizes[1]; + rocksdb_size_approximation_options_t* size_options = + rocksdb_size_approximation_options_create(); + rocksdb_size_approximation_options_set_include_files(size_options, 1); + rocksdb_approximate_sizes_cf_with_options(db, handles[1], size_options, 1, + start, start_len, limit, + limit_len, sizes, &err); + CheckNoError(err); + CheckCondition(sizes[0] > 0); + rocksdb_size_approximation_options_destroy(size_options); + } + + { + size_t key_len = 0; + rocksdb_column_family_metadata_options_t* metadata_options = + rocksdb_column_family_metadata_options_create(); + rocksdb_column_family_metadata_options_set_start_key(metadata_options, + "zzz", 3); + rocksdb_column_family_metadata_options_set_end_key(metadata_options, + "zzzz", 4); + CheckCondition( + 0 == memcmp(rocksdb_column_family_metadata_options_get_start_key( + metadata_options, &key_len), + "zzz", key_len)); + CheckCondition(key_len == 3); + + rocksdb_column_family_metadata_t* filtered_meta = + rocksdb_get_column_family_metadata_cf_with_options(db, handles[1], + metadata_options); + CheckCondition( + 0 == rocksdb_column_family_metadata_get_file_count(filtered_meta)); + rocksdb_column_family_metadata_destroy(filtered_meta); + rocksdb_column_family_metadata_options_destroy(metadata_options); + } + + { + char* input_file_name = NULL; + rocksdb_compaction_options_t* compaction_options = + rocksdb_compaction_options_create(); + rocksdb_compactionjobinfo_t* compaction_info = + rocksdb_compactionjobinfo_create(); + unsigned char* canceled = rocksdb_compaction_options_canceled_create(); + char** output_files = NULL; + size_t num_output_files = 0; + rocksdb_column_family_metadata_t* cf_meta = + rocksdb_get_column_family_metadata_cf(db, handles[1]); + size_t level_count = + rocksdb_column_family_metadata_get_level_count(cf_meta); + + rocksdb_compaction_options_set_compression(compaction_options, 0); + CheckCondition( + 0 == rocksdb_compaction_options_get_compression(compaction_options)); + rocksdb_compaction_options_set_output_file_size_limit(compaction_options, + 1024 * 1024); + CheckCondition(1024 * 1024 == + rocksdb_compaction_options_get_output_file_size_limit( + compaction_options)); + rocksdb_compaction_options_set_max_subcompactions(compaction_options, 1); + CheckCondition(1 == rocksdb_compaction_options_get_max_subcompactions( + compaction_options)); + rocksdb_compaction_options_set_output_temperature_override( + compaction_options, 4); + CheckCondition(4 == + rocksdb_compaction_options_get_output_temperature_override( + compaction_options)); + rocksdb_compaction_options_set_allow_trivial_move(compaction_options, 1); + CheckCondition(1 == rocksdb_compaction_options_get_allow_trivial_move( + compaction_options)); + rocksdb_compaction_options_set_allow_trivial_move(compaction_options, 0); + CheckCondition(0 == rocksdb_compaction_options_get_allow_trivial_move( + compaction_options)); + rocksdb_compaction_options_canceled_set(canceled, 0); + rocksdb_compaction_options_set_canceled(compaction_options, canceled); + + for (size_t l = 0; l < level_count && input_file_name == NULL; ++l) { + rocksdb_level_metadata_t* level_meta = + rocksdb_column_family_metadata_get_level_metadata(cf_meta, l); + size_t file_count = rocksdb_level_metadata_get_file_count(level_meta); + if (file_count > 0) { + rocksdb_sst_file_metadata_t* file_meta = + rocksdb_level_metadata_get_sst_file_metadata(level_meta, 0); + input_file_name = + rocksdb_sst_file_metadata_get_relative_filename(file_meta); + rocksdb_sst_file_metadata_destroy(file_meta); + } + rocksdb_level_metadata_destroy(level_meta); + } + CheckCondition(input_file_name != NULL); + + { + const char* input_files[1] = {input_file_name}; + rocksdb_compact_files_cf(db, handles[1], compaction_options, + input_files, 1, 1, -1, &output_files, + &num_output_files, compaction_info, &err); + } + CheckNoError(err); + CheckCondition(output_files != NULL); + CheckCondition(num_output_files > 0); + CheckCondition(rocksdb_compactionjobinfo_job_id(compaction_info) > 0); + + rocksdb_compact_files_output_file_names_destroy(output_files, + num_output_files); + rocksdb_compaction_options_canceled_destroy(canceled); + rocksdb_compactionjobinfo_destroy(compaction_info); + rocksdb_compaction_options_destroy(compaction_options); + rocksdb_column_family_metadata_destroy(cf_meta); + Free(&input_file_name); + } + + { + rocksdb_readoptions_t* verify_options = rocksdb_readoptions_create(); + rocksdb_wal_files_t* wal_files; + rocksdb_wal_file_t* current_wal_file; + const rocksdb_wal_file_t* last_wal_file; + size_t wal_count; + + rocksdb_pause_background_work(db, &err); + CheckNoError(err); + rocksdb_continue_background_work(db, &err); + CheckNoError(err); + + // Rewrite an existing key to guarantee WAL activity without changing + // the number of visible keys in cf1. + rocksdb_put_cf(db, woptions, handles[1], "buff", 4, "rocksdb", 7, &err); + CheckNoError(err); + + rocksdb_disable_file_deletions(db, &err); + CheckNoError(err); + wal_files = rocksdb_get_sorted_wal_files(db, &err); + CheckNoError(err); + CheckCondition(wal_files != NULL); + wal_count = rocksdb_wal_files_count(wal_files); + CheckCondition(wal_count > 0); + last_wal_file = rocksdb_wal_files_get_wal_file(wal_files, wal_count - 1); + CheckCondition(last_wal_file != NULL); + CheckCondition( + strstr(rocksdb_wal_file_path_name(last_wal_file), ".log") != NULL); + CheckCondition(rocksdb_wal_file_log_number(last_wal_file) > 0); + CheckCondition(rocksdb_wal_file_size_file_bytes(last_wal_file) > 0); + CheckCondition(rocksdb_wal_file_type(last_wal_file) == + rocksdb_wal_file_type_alive_log || + rocksdb_wal_file_type(last_wal_file) == + rocksdb_wal_file_type_archived_log); + rocksdb_wal_files_destroy(wal_files); + rocksdb_enable_file_deletions(db, &err); + CheckNoError(err); + + current_wal_file = rocksdb_get_current_wal_file(db, &err); + CheckNoError(err); + CheckCondition(current_wal_file != NULL); + CheckCondition( + strstr(rocksdb_wal_file_path_name(current_wal_file), ".log") != NULL); + CheckCondition(rocksdb_wal_file_log_number(current_wal_file) > 0); + CheckCondition(rocksdb_wal_file_type(current_wal_file) == + rocksdb_wal_file_type_alive_log); + rocksdb_wal_file_destroy(current_wal_file); + + rocksdb_verify_checksum(db, &err); + CheckNoError(err); + rocksdb_verify_checksum_with_options(db, verify_options, &err); + CheckNoError(err); + rocksdb_verify_file_checksums(db, &err); + CheckCondition(err != NULL); + CheckCondition(strstr(err, "file_checksum_gen_factory is null") != NULL); + Free(&err); + rocksdb_verify_file_checksums_with_options(db, verify_options, &err); + CheckCondition(err != NULL); + CheckCondition(strstr(err, "file_checksum_gen_factory is null") != NULL); + Free(&err); + + rocksdb_readoptions_destroy(verify_options); + } // Test column family handle get name { @@ -2614,6 +3381,52 @@ int main(int argc, char** argv) { rocksdb_cuckoo_options_destroy(cuckoo_options); } + StartPhase("block_based_options_auto"); + { + rocksdb_block_based_table_options_t* bbo; + const char* factory_name; + size_t factory_name_len; + bbo = rocksdb_block_based_options_create(); + + rocksdb_block_based_options_set_enable_index_compression(bbo, 1); + CheckCondition( + 1 == rocksdb_block_based_options_get_enable_index_compression(bbo)); + + rocksdb_block_based_options_set_max_auto_readahead_size(bbo, 4096); + CheckCondition( + 4096 == rocksdb_block_based_options_get_max_auto_readahead_size(bbo)); + + rocksdb_block_based_options_set_prepopulate_block_cache(bbo, 2); + CheckCondition( + 2 == rocksdb_block_based_options_get_prepopulate_block_cache(bbo)); + + rocksdb_block_based_options_set_initial_auto_readahead_size(bbo, 2048); + CheckCondition( + 2048 == + rocksdb_block_based_options_get_initial_auto_readahead_size(bbo)); + + rocksdb_block_based_options_set_num_file_reads_for_auto_readahead(bbo, 7); + CheckCondition( + 7 == + rocksdb_block_based_options_get_num_file_reads_for_auto_readahead(bbo)); + + rocksdb_block_based_options_set_user_defined_index_factory_from_string( + bbo, "trie_index", 10, &err); + CheckNoError(err); + factory_name = + rocksdb_block_based_options_get_user_defined_index_factory_name( + bbo, &factory_name_len); + CheckEqual("trie_index", factory_name, factory_name_len); + rocksdb_block_based_options_clear_user_defined_index_factory(bbo); + factory_name = + rocksdb_block_based_options_get_user_defined_index_factory_name( + bbo, &factory_name_len); + CheckCondition(factory_name == NULL); + CheckCondition(factory_name_len == 0); + + rocksdb_block_based_options_destroy(bbo); + } + StartPhase("options"); { rocksdb_options_t* o; @@ -2920,6 +3733,38 @@ int main(int argc, char** argv) { rocksdb_options_set_async_wal_precreate(o, 1); CheckCondition(1 == rocksdb_options_get_async_wal_precreate(o)); + CheckCondition(0 == rocksdb_options_checksum_handoff_file_types_count(o)); + rocksdb_options_checksum_handoff_file_types_add(o, 0); + rocksdb_options_checksum_handoff_file_types_add(o, 2); + CheckCondition(2 == rocksdb_options_checksum_handoff_file_types_count(o)); + CheckCondition(1 == + rocksdb_options_checksum_handoff_file_types_contains(o, 0)); + CheckCondition(1 == + rocksdb_options_checksum_handoff_file_types_contains(o, 2)); + rocksdb_options_checksum_handoff_file_types_remove(o, 0); + CheckCondition(0 == + rocksdb_options_checksum_handoff_file_types_contains(o, 0)); + CheckCondition(1 == rocksdb_options_checksum_handoff_file_types_count(o)); + + CheckCondition( + 1 == rocksdb_options_calculate_sst_write_lifetime_hint_set_count(o)); + CheckCondition( + 1 == + rocksdb_options_calculate_sst_write_lifetime_hint_set_contains(o, 0)); + rocksdb_options_calculate_sst_write_lifetime_hint_set_clear(o); + CheckCondition( + 0 == rocksdb_options_calculate_sst_write_lifetime_hint_set_count(o)); + rocksdb_options_calculate_sst_write_lifetime_hint_set_add(o, 1); + rocksdb_options_calculate_sst_write_lifetime_hint_set_add(o, 2); + CheckCondition( + 2 == rocksdb_options_calculate_sst_write_lifetime_hint_set_count(o)); + CheckCondition( + 1 == + rocksdb_options_calculate_sst_write_lifetime_hint_set_contains(o, 1)); + CheckCondition( + 1 == + rocksdb_options_calculate_sst_write_lifetime_hint_set_contains(o, 2)); + /* Blob Options */ rocksdb_options_set_enable_blob_files(o, 1); CheckCondition(1 == rocksdb_options_get_enable_blob_files(o)); @@ -3061,6 +3906,18 @@ int main(int argc, char** argv) { CheckCondition(1 == rocksdb_options_get_atomic_flush(copy)); CheckCondition(29.0 == rocksdb_options_get_experimental_mempurge_threshold(copy)); + CheckCondition(1 == + rocksdb_options_checksum_handoff_file_types_count(copy)); + CheckCondition( + 1 == rocksdb_options_checksum_handoff_file_types_contains(copy, 2)); + CheckCondition( + 2 == rocksdb_options_calculate_sst_write_lifetime_hint_set_count(copy)); + CheckCondition( + 1 == rocksdb_options_calculate_sst_write_lifetime_hint_set_contains( + copy, 1)); + CheckCondition( + 1 == rocksdb_options_calculate_sst_write_lifetime_hint_set_contains( + copy, 2)); // Copies should be independent. rocksdb_options_set_allow_ingest_behind(copy, 0); @@ -3436,13 +4293,73 @@ int main(int argc, char** argv) { CheckCondition(29.0 == rocksdb_options_get_experimental_mempurge_threshold(o)); + rocksdb_options_checksum_handoff_file_types_add(copy, 3); + CheckCondition(2 == + rocksdb_options_checksum_handoff_file_types_count(copy)); + CheckCondition(1 == rocksdb_options_checksum_handoff_file_types_count(o)); + CheckCondition( + 1 == rocksdb_options_checksum_handoff_file_types_contains(copy, 3)); + CheckCondition(0 == + rocksdb_options_checksum_handoff_file_types_contains(o, 3)); + + rocksdb_options_calculate_sst_write_lifetime_hint_set_remove(copy, 2); + CheckCondition( + 1 == rocksdb_options_calculate_sst_write_lifetime_hint_set_count(copy)); + CheckCondition( + 2 == rocksdb_options_calculate_sst_write_lifetime_hint_set_count(o)); + CheckCondition( + 0 == rocksdb_options_calculate_sst_write_lifetime_hint_set_contains( + copy, 2)); + CheckCondition( + 1 == + rocksdb_options_calculate_sst_write_lifetime_hint_set_contains(o, 2)); + rocksdb_options_destroy(copy); rocksdb_options_destroy(o); } + StartPhase("options_auto"); + { + rocksdb_options_t* o; + const char* str; + size_t len; + o = rocksdb_options_create(); + + rocksdb_options_set_db_log_dir(o, "db-log-dir"); + str = rocksdb_options_get_db_log_dir(o, &len); + CheckEqual("db-log-dir", str, len); + + rocksdb_options_set_wal_dir(o, "wal-dir"); + str = rocksdb_options_get_wal_dir(o, &len); + CheckEqual("wal-dir", str, len); + + rocksdb_options_set_allow_fallocate(o, 1); + CheckCondition(1 == rocksdb_options_get_allow_fallocate(o)); + + rocksdb_options_set_db_host_id(o, "db-host"); + str = rocksdb_options_get_db_host_id(o, &len); + CheckEqual("db-host", str, len); + + rocksdb_options_set_metadata_write_temperature(o, 2); + CheckCondition(2 == rocksdb_options_get_metadata_write_temperature(o)); + + rocksdb_options_set_cf_allow_ingest_behind(o, 1); + CheckCondition(1 == rocksdb_options_get_cf_allow_ingest_behind(o)); + + rocksdb_options_set_block_protection_bytes_per_key(o, 8); + CheckCondition(8 == rocksdb_options_get_block_protection_bytes_per_key(o)); + + rocksdb_options_destroy(o); + } + StartPhase("read_options"); { rocksdb_readoptions_t* ro; + const char* request_id; + size_t request_id_len; + const char* table_index_factory_name; + size_t table_index_factory_name_len; + ro = rocksdb_readoptions_create(); rocksdb_readoptions_set_verify_checksums(ro, 1); @@ -3454,18 +4371,44 @@ int main(int argc, char** argv) { rocksdb_readoptions_set_read_tier(ro, 2); CheckCondition(2 == rocksdb_readoptions_get_read_tier(ro)); + rocksdb_readoptions_set_rate_limiter_priority(ro, 1); + CheckCondition(1 == rocksdb_readoptions_get_rate_limiter_priority(ro)); + + rocksdb_readoptions_set_value_size_soft_limit(ro, 123); + CheckCondition(123 == rocksdb_readoptions_get_value_size_soft_limit(ro)); + + CheckCondition(0 == + rocksdb_readoptions_has_merge_operand_count_threshold(ro)); + rocksdb_readoptions_set_merge_operand_count_threshold(ro, 456); + CheckCondition(1 == + rocksdb_readoptions_has_merge_operand_count_threshold(ro)); + CheckCondition(456 == + rocksdb_readoptions_get_merge_operand_count_threshold(ro)); + rocksdb_readoptions_clear_merge_operand_count_threshold(ro); + CheckCondition(0 == + rocksdb_readoptions_has_merge_operand_count_threshold(ro)); + rocksdb_readoptions_set_tailing(ro, 1); CheckCondition(1 == rocksdb_readoptions_get_tailing(ro)); + rocksdb_readoptions_set_optimize_multiget_for_io(ro, 1); + CheckCondition(1 == rocksdb_readoptions_get_optimize_multiget_for_io(ro)); + rocksdb_readoptions_set_readahead_size(ro, 100); CheckCondition(100 == rocksdb_readoptions_get_readahead_size(ro)); + rocksdb_readoptions_set_auto_prefix_mode(ro, 1); + CheckCondition(1 == rocksdb_readoptions_get_auto_prefix_mode(ro)); + rocksdb_readoptions_set_prefix_same_as_start(ro, 1); CheckCondition(1 == rocksdb_readoptions_get_prefix_same_as_start(ro)); rocksdb_readoptions_set_pin_data(ro, 1); CheckCondition(1 == rocksdb_readoptions_get_pin_data(ro)); + rocksdb_readoptions_set_adaptive_readahead(ro, 1); + CheckCondition(1 == rocksdb_readoptions_get_adaptive_readahead(ro)); + rocksdb_readoptions_set_total_order_seek(ro, 1); CheckCondition(1 == rocksdb_readoptions_get_total_order_seek(ro)); @@ -3489,6 +4432,44 @@ int main(int argc, char** argv) { rocksdb_readoptions_set_async_io(ro, 1); CheckCondition(1 == rocksdb_readoptions_get_async_io(ro)); + rocksdb_readoptions_set_auto_readahead_size(ro, 1); + CheckCondition(1 == rocksdb_readoptions_get_auto_readahead_size(ro)); + + rocksdb_readoptions_set_allow_unprepared_value(ro, 1); + CheckCondition(1 == rocksdb_readoptions_get_allow_unprepared_value(ro)); + + rocksdb_readoptions_set_auto_refresh_iterator_with_snapshot(ro, 1); + CheckCondition( + 1 == rocksdb_readoptions_get_auto_refresh_iterator_with_snapshot(ro)); + + rocksdb_readoptions_set_io_activity(ro, 3); + CheckCondition(3 == rocksdb_readoptions_get_io_activity(ro)); + + request_id = rocksdb_readoptions_get_request_id(ro, &request_id_len); + CheckCondition(request_id == NULL); + CheckCondition(request_id_len == 0); + rocksdb_readoptions_set_request_id(ro, "request-123", 11); + request_id = rocksdb_readoptions_get_request_id(ro, &request_id_len); + CheckEqual("request-123", request_id, request_id_len); + rocksdb_readoptions_clear_request_id(ro); + request_id = rocksdb_readoptions_get_request_id(ro, &request_id_len); + CheckCondition(request_id == NULL); + CheckCondition(request_id_len == 0); + + CheckCondition(0 == rocksdb_readoptions_has_table_filter(ro)); + rocksdb_readoptions_set_table_index_factory_from_string(ro, "trie_index", + 10, &err); + CheckNoError(err); + table_index_factory_name = rocksdb_readoptions_get_table_index_factory_name( + ro, &table_index_factory_name_len); + CheckEqual("trie_index", table_index_factory_name, + table_index_factory_name_len); + rocksdb_readoptions_clear_table_index_factory(ro); + table_index_factory_name = rocksdb_readoptions_get_table_index_factory_name( + ro, &table_index_factory_name_len); + CheckCondition(table_index_factory_name == NULL); + CheckCondition(table_index_factory_name_len == 0); + // optimize_multiget_for_io defaults to true (1); flip to 0 to verify the // setter is wired through to the underlying C++ ReadOptions field. CheckCondition(1 == rocksdb_readoptions_get_optimize_multiget_for_io(ro)); @@ -3498,6 +4479,223 @@ int main(int argc, char** argv) { rocksdb_readoptions_destroy(ro); } + StartPhase("table_filter_listener_metadata"); + { + char local_dbname[400]; + char local_sstfilename[400]; + const char* file_list[1]; + rocksdb_options_t* local_options = rocksdb_options_create(); + rocksdb_t* local_db; + rocksdb_writeoptions_t* local_woptions = rocksdb_writeoptions_create(); + rocksdb_readoptions_t* local_roptions = rocksdb_readoptions_create(); + rocksdb_flushoptions_t* flush_options = rocksdb_flushoptions_create(); + rocksdb_wait_for_compact_options_t* wait_options = + rocksdb_wait_for_compact_options_create(); + rocksdb_envoptions_t* env_options = rocksdb_envoptions_create(); + rocksdb_ingestexternalfileoptions_t* ingest_options = + rocksdb_ingestexternalfileoptions_create(); + rocksdb_sstfilewriter_t* writer; + rocksdb_iterator_t* iter; + char* val; + size_t val_len; + char* iter_err = NULL; + ListenerState listener_state = {0}; + TableFilterState filter_state = {0}; + + snprintf(local_dbname, sizeof(local_dbname), + "%s/rocksdb_c_test-%d-table-filter-listener", GetTempDir(), + ((int)geteuid())); + snprintf(local_sstfilename, sizeof(local_sstfilename), + "%s/rocksdb_c_test-%d-table-filter-listener.sst", GetTempDir(), + ((int)geteuid())); + listener_state.expected_external_file_path = local_sstfilename; + + rocksdb_destroy_db(local_options, local_dbname, &err); + Free(&err); + remove(local_sstfilename); + + rocksdb_options_set_create_if_missing(local_options, 1); + rocksdb_options_set_disable_auto_compactions(local_options, 1); + rocksdb_options_set_compression(local_options, rocksdb_no_compression); + rocksdb_options_add_eventlistener( + local_options, + rocksdb_eventlistener_create( + &listener_state, ListenerNoopDestructor, ListenerOnFlushBegin, + ListenerOnFlushCompleted, ListenerOnCompactionBegin, + ListenerOnCompactionCompleted, ListenerOnSubcompactionBegin, + ListenerOnSubcompactionCompleted, ListenerOnExternalFileIngested, + ListenerOnBackgroundError, ListenerOnStallConditionsChanged, + ListenerOnMemtableSealed)); + + local_db = rocksdb_open(local_options, local_dbname, &err); + CheckNoError(err); + + rocksdb_flushoptions_set_wait(flush_options, 1); + + rocksdb_put(local_db, local_woptions, "a", 1, "1", 1, &err); + CheckNoError(err); + rocksdb_flush(local_db, flush_options, &err); + CheckNoError(err); + + rocksdb_put(local_db, local_woptions, "b", 1, "2", 1, &err); + CheckNoError(err); + rocksdb_put(local_db, local_woptions, "c", 1, "3", 1, &err); + CheckNoError(err); + rocksdb_flush(local_db, flush_options, &err); + CheckNoError(err); + + rocksdb_put(local_db, local_woptions, "d", 1, "4", 1, &err); + CheckNoError(err); + rocksdb_put(local_db, local_woptions, "e", 1, "5", 1, &err); + CheckNoError(err); + rocksdb_put(local_db, local_woptions, "f", 1, "6", 1, &err); + CheckNoError(err); + rocksdb_flush(local_db, flush_options, &err); + CheckNoError(err); + + CheckCondition(listener_state.flush_count == 3); + CheckCondition(listener_state.saw_flush_entries_1); + CheckCondition(listener_state.saw_flush_entries_2); + CheckCondition(listener_state.saw_flush_entries_3); + + filter_state.hidden_num_entries = 2; + CheckCondition(0 == rocksdb_readoptions_has_table_filter(local_roptions)); + rocksdb_readoptions_set_table_filter(local_roptions, &filter_state, + TableFilterStateDestroy, + TableFilterCallback); + CheckCondition(1 == rocksdb_readoptions_has_table_filter(local_roptions)); + + iter = rocksdb_create_iterator(local_db, local_roptions); + rocksdb_iter_seek_to_first(iter); + CheckCondition(rocksdb_iter_valid(iter)); + CheckIter(iter, "a", "1"); + rocksdb_iter_next(iter); + CheckCondition(rocksdb_iter_valid(iter)); + CheckIter(iter, "d", "4"); + rocksdb_iter_next(iter); + CheckCondition(rocksdb_iter_valid(iter)); + CheckIter(iter, "e", "5"); + rocksdb_iter_next(iter); + CheckCondition(rocksdb_iter_valid(iter)); + CheckIter(iter, "f", "6"); + rocksdb_iter_next(iter); + CheckCondition(!rocksdb_iter_valid(iter)); + rocksdb_iter_get_error(iter, &iter_err); + CheckNoError(iter_err); + rocksdb_iter_destroy(iter); + + CheckCondition(filter_state.calls == 3); + CheckCondition(filter_state.saw_entries_1); + CheckCondition(filter_state.saw_entries_2); + CheckCondition(filter_state.saw_entries_3); + + rocksdb_readoptions_clear_table_filter(local_roptions); + CheckCondition(0 == rocksdb_readoptions_has_table_filter(local_roptions)); + CheckCondition(filter_state.destructor_calls == 1); + rocksdb_readoptions_set_table_filter(local_roptions, &filter_state, + TableFilterStateDestroy, + TableFilterCallback); + + rocksdb_compact_range(local_db, NULL, 0, NULL, 0); + rocksdb_wait_for_compact(local_db, wait_options, &err); + CheckNoError(err); + CheckCondition(listener_state.compaction_count >= 1); + + writer = rocksdb_sstfilewriter_create(env_options, local_options); + rocksdb_sstfilewriter_open(writer, local_sstfilename, &err); + CheckNoError(err); + rocksdb_sstfilewriter_put(writer, "g", 1, "7", 1, &err); + CheckNoError(err); + rocksdb_sstfilewriter_put(writer, "h", 1, "8", 1, &err); + CheckNoError(err); + rocksdb_sstfilewriter_finish(writer, &err); + CheckNoError(err); + + file_list[0] = local_sstfilename; + rocksdb_ingest_external_file(local_db, file_list, 1, ingest_options, &err); + CheckNoError(err); + CheckCondition(listener_state.external_ingest_count == 1); + + val = rocksdb_get(local_db, local_roptions, "g", 1, &val_len, &err); + CheckNoError(err); + CheckEqual("7", val, val_len); + Free(&val); + + rocksdb_sstfilewriter_destroy(writer); + rocksdb_ingestexternalfileoptions_destroy(ingest_options); + rocksdb_envoptions_destroy(env_options); + rocksdb_wait_for_compact_options_destroy(wait_options); + rocksdb_flushoptions_destroy(flush_options); + rocksdb_writeoptions_destroy(local_woptions); + rocksdb_readoptions_destroy(local_roptions); + CheckCondition(filter_state.destructor_calls == 2); + rocksdb_close(local_db); + rocksdb_destroy_db(local_options, local_dbname, &err); + CheckNoError(err); + rocksdb_options_destroy(local_options); + remove(local_sstfilename); + } + + StartPhase("wal_filter"); + { + char wal_dbname[400]; + rocksdb_options_t* wal_options = rocksdb_options_create(); + rocksdb_writeoptions_t* wal_woptions = rocksdb_writeoptions_create(); + rocksdb_readoptions_t* wal_roptions = rocksdb_readoptions_create(); + rocksdb_t* wal_db; + rocksdb_walfilter_t* wal_filter; + WalFilterState wal_filter_state = {0}; + char* val; + size_t val_len; + + snprintf(wal_dbname, sizeof(wal_dbname), "%s/rocksdb_c_test-%d-wal-filter", + GetTempDir(), ((int)geteuid())); + rocksdb_destroy_db(wal_options, wal_dbname, &err); + Free(&err); + + rocksdb_options_set_create_if_missing(wal_options, 1); + rocksdb_options_set_compression(wal_options, rocksdb_no_compression); + rocksdb_writeoptions_set_sync(wal_woptions, 0); + + wal_db = rocksdb_open(wal_options, wal_dbname, &err); + CheckNoError(err); + rocksdb_put(wal_db, wal_woptions, "k1", 2, "v1", 2, &err); + CheckNoError(err); + rocksdb_put(wal_db, wal_woptions, "k2", 2, "v2", 2, &err); + CheckNoError(err); + rocksdb_close(wal_db); + + wal_filter = rocksdb_walfilter_create( + &wal_filter_state, WalFilterDestroy, WalFilterColumnFamilyLogNumberMap, + WalFilterLogRecordFound, WalFilterName); + rocksdb_options_set_wal_filter(wal_options, wal_filter); + + wal_db = rocksdb_open(wal_options, wal_dbname, &err); + CheckNoError(err); + CheckCondition(wal_filter_state.column_family_map_calls > 0); + CheckCondition(wal_filter_state.log_record_calls == 2); + + val = rocksdb_get(wal_db, wal_roptions, "k1", 2, &val_len, &err); + CheckNoError(err); + CheckEqual(NULL, val, val_len); + Free(&val); + + val = rocksdb_get(wal_db, wal_roptions, "k2", 2, &val_len, &err); + CheckNoError(err); + CheckEqual("v2", val, val_len); + Free(&val); + + rocksdb_close(wal_db); + rocksdb_options_clear_wal_filter(wal_options); + rocksdb_walfilter_destroy(wal_filter); + CheckCondition(wal_filter_state.destructor_calls == 1); + rocksdb_readoptions_destroy(wal_roptions); + rocksdb_writeoptions_destroy(wal_woptions); + rocksdb_destroy_db(wal_options, wal_dbname, &err); + CheckNoError(err); + rocksdb_options_destroy(wal_options); + } + StartPhase("write_options"); { rocksdb_writeoptions_t* wo; @@ -3523,6 +4721,15 @@ int main(int argc, char** argv) { CheckCondition(1 == rocksdb_writeoptions_get_memtable_insert_hint_per_batch(wo)); + rocksdb_writeoptions_set_rate_limiter_priority(wo, 1); + CheckCondition(1 == rocksdb_writeoptions_get_rate_limiter_priority(wo)); + + rocksdb_writeoptions_set_protection_bytes_per_key(wo, 8); + CheckCondition(8 == rocksdb_writeoptions_get_protection_bytes_per_key(wo)); + + rocksdb_writeoptions_set_io_activity(wo, 2); + CheckCondition(2 == rocksdb_writeoptions_get_io_activity(wo)); + rocksdb_writeoptions_destroy(wo); } @@ -3554,6 +4761,15 @@ int main(int argc, char** argv) { rocksdb_compactoptions_set_max_subcompactions(co, 1); CheckCondition(1 == rocksdb_compactoptions_get_max_subcompactions(co)); + rocksdb_compactoptions_set_blob_garbage_collection_policy(co, 1); + CheckCondition( + 1 == rocksdb_compactoptions_get_blob_garbage_collection_policy(co)); + + rocksdb_compactoptions_set_blob_garbage_collection_age_cutoff(co, 0.75); + CheckCondition( + 0.75 == + rocksdb_compactoptions_get_blob_garbage_collection_age_cutoff(co)); + rocksdb_compactoptions_destroy(co); } @@ -3565,9 +4781,64 @@ int main(int argc, char** argv) { rocksdb_flushoptions_set_wait(fo, 1); CheckCondition(1 == rocksdb_flushoptions_get_wait(fo)); + rocksdb_flushoptions_set_allow_write_stall(fo, 1); + CheckCondition(1 == rocksdb_flushoptions_get_allow_write_stall(fo)); + + rocksdb_flushoptions_set_force_atomic_flush(fo, 1); + CheckCondition(1 == rocksdb_flushoptions_get_force_atomic_flush(fo)); + rocksdb_flushoptions_destroy(fo); } + StartPhase("ingest_external_file_options"); + { + rocksdb_ingestexternalfileoptions_t* io; + io = rocksdb_ingestexternalfileoptions_create(); + + rocksdb_ingestexternalfileoptions_set_move_files(io, 1); + CheckCondition(1 == rocksdb_ingestexternalfileoptions_get_move_files(io)); + + rocksdb_ingestexternalfileoptions_set_link_files(io, 1); + CheckCondition(1 == rocksdb_ingestexternalfileoptions_get_link_files(io)); + + rocksdb_ingestexternalfileoptions_set_failed_move_fall_back_to_copy(io, 0); + CheckCondition( + 0 == + rocksdb_ingestexternalfileoptions_get_failed_move_fall_back_to_copy( + io)); + + rocksdb_ingestexternalfileoptions_set_snapshot_consistency(io, 0); + CheckCondition( + 0 == rocksdb_ingestexternalfileoptions_get_snapshot_consistency(io)); + + rocksdb_ingestexternalfileoptions_set_verify_checksums_before_ingest(io, 1); + CheckCondition( + 1 == + rocksdb_ingestexternalfileoptions_get_verify_checksums_before_ingest( + io)); + + rocksdb_ingestexternalfileoptions_set_verify_checksums_readahead_size(io, + 1024); + CheckCondition( + 1024 == + rocksdb_ingestexternalfileoptions_get_verify_checksums_readahead_size( + io)); + + rocksdb_ingestexternalfileoptions_set_verify_file_checksum(io, 0); + CheckCondition( + 0 == rocksdb_ingestexternalfileoptions_get_verify_file_checksum(io)); + + rocksdb_ingestexternalfileoptions_set_allow_db_generated_files(io, 1); + CheckCondition( + 1 == + rocksdb_ingestexternalfileoptions_get_allow_db_generated_files(io)); + + rocksdb_ingestexternalfileoptions_set_fill_cache(io, 0); + CheckCondition(0 == rocksdb_ingestexternalfileoptions_get_fill_cache(io)); + + rocksdb_ingestexternalfileoptions_destroy(io); + } + StartPhase("cache_options"); { rocksdb_cache_t* co; @@ -3688,6 +4959,22 @@ int main(int argc, char** argv) { CheckCondition(1 == rocksdb_universal_compaction_options_get_stop_style(uco)); + rocksdb_universal_compaction_options_set_max_read_amp(uco, 2); + CheckCondition(2 == + rocksdb_universal_compaction_options_get_max_read_amp(uco)); + + rocksdb_universal_compaction_options_set_allow_trivial_move(uco, 1); + CheckCondition( + 1 == rocksdb_universal_compaction_options_get_allow_trivial_move(uco)); + + rocksdb_universal_compaction_options_set_incremental(uco, 1); + CheckCondition(1 == + rocksdb_universal_compaction_options_get_incremental(uco)); + + rocksdb_universal_compaction_options_set_reduce_file_locking(uco, 1); + CheckCondition( + 1 == rocksdb_universal_compaction_options_get_reduce_file_locking(uco)); + rocksdb_universal_compaction_options_destroy(uco); } @@ -3709,14 +4996,35 @@ int main(int argc, char** argv) { CheckCondition( 1 == rocksdb_fifo_compaction_options_get_use_kv_ratio_compaction(fco)); + rocksdb_fifo_compaction_options_set_age_for_warm(fco, 300); + CheckCondition(300 == + rocksdb_fifo_compaction_options_get_age_for_warm(fco)); + + rocksdb_fifo_compaction_options_set_allow_trivial_copy_when_change_temperature( + fco, 1); + CheckCondition( + 1 == + rocksdb_fifo_compaction_options_get_allow_trivial_copy_when_change_temperature( + fco)); + + rocksdb_fifo_compaction_options_set_trivial_copy_buffer_size(fco, 8192); + CheckCondition( + 8192 == + rocksdb_fifo_compaction_options_get_trivial_copy_buffer_size(fco)); + rocksdb_fifo_compaction_options_destroy(fco); } StartPhase("backup_engine_option"); { rocksdb_backup_engine_options_t* bdo; + const char* str; + size_t len; bdo = rocksdb_backup_engine_options_create("path"); + str = rocksdb_backup_engine_options_get_backup_dir(bdo, &len); + CheckEqual("path", str, len); + rocksdb_backup_engine_options_set_share_table_files(bdo, 1); CheckCondition(1 == rocksdb_backup_engine_options_get_share_table_files(bdo)); @@ -3804,9 +5112,142 @@ int main(int argc, char** argv) { 2 == rocksdb_backup_engine_options_get_share_files_with_checksum_naming( bdo)); + rocksdb_backup_engine_options_set_io_buffer_size(bdo, 8192); + CheckCondition(8192 == + rocksdb_backup_engine_options_get_io_buffer_size(bdo)); + + rocksdb_backup_engine_options_set_share_files_with_checksum(bdo, 1); + CheckCondition( + 1 == rocksdb_backup_engine_options_get_share_files_with_checksum(bdo)); + + rocksdb_backup_engine_options_set_schema_version(bdo, 2); + CheckCondition(2 == rocksdb_backup_engine_options_get_schema_version(bdo)); + + rocksdb_backup_engine_options_set_current_temperatures_override_manifest( + bdo, 1); + CheckCondition( + 1 == + rocksdb_backup_engine_options_get_current_temperatures_override_manifest( + bdo)); + rocksdb_backup_engine_options_destroy(bdo); } + StartPhase("restore_options"); + { + rocksdb_restore_options_t* ro; + ro = rocksdb_restore_options_create(); + + rocksdb_restore_options_set_keep_log_files(ro, 1); + CheckCondition(1 == rocksdb_restore_options_get_keep_log_files(ro)); + + rocksdb_restore_options_set_mode(ro, 2); + CheckCondition(2 == rocksdb_restore_options_get_mode(ro)); + + rocksdb_restore_options_destroy(ro); + } + + StartPhase("transaction_options_roundtrip"); + { + rocksdb_transactiondb_options_t* tdb; + rocksdb_transaction_options_t* to; + rocksdb_optimistictransaction_options_t* oto; + + tdb = rocksdb_transactiondb_options_create(); + rocksdb_transactiondb_options_set_max_num_locks(tdb, 99); + CheckCondition(99 == rocksdb_transactiondb_options_get_max_num_locks(tdb)); + rocksdb_transactiondb_options_set_num_stripes(tdb, 10); + CheckCondition(10 == rocksdb_transactiondb_options_get_num_stripes(tdb)); + rocksdb_transactiondb_options_set_transaction_lock_timeout(tdb, 11); + CheckCondition( + 11 == rocksdb_transactiondb_options_get_transaction_lock_timeout(tdb)); + rocksdb_transactiondb_options_set_default_lock_timeout(tdb, 12); + CheckCondition(12 == + rocksdb_transactiondb_options_get_default_lock_timeout(tdb)); + rocksdb_transactiondb_options_set_max_num_deadlocks(tdb, 13); + CheckCondition(13 == + rocksdb_transactiondb_options_get_max_num_deadlocks(tdb)); + rocksdb_transactiondb_options_set_write_policy(tdb, 2); + CheckCondition(2 == rocksdb_transactiondb_options_get_write_policy(tdb)); + rocksdb_transactiondb_options_set_skip_concurrency_control(tdb, 1); + CheckCondition( + 1 == rocksdb_transactiondb_options_get_skip_concurrency_control(tdb)); + rocksdb_transactiondb_options_set_default_write_batch_flush_threshold(tdb, + 14); + CheckCondition( + 14 == + rocksdb_transactiondb_options_get_default_write_batch_flush_threshold( + tdb)); + rocksdb_transactiondb_options_set_enable_udt_validation(tdb, 0); + CheckCondition( + 0 == rocksdb_transactiondb_options_get_enable_udt_validation(tdb)); + rocksdb_transactiondb_options_set_txn_commit_bypass_memtable_threshold(tdb, + 15); + CheckCondition( + 15 == + rocksdb_transactiondb_options_get_txn_commit_bypass_memtable_threshold( + tdb)); + rocksdb_transactiondb_options_destroy(tdb); + + to = rocksdb_transaction_options_create(); + rocksdb_transaction_options_set_set_snapshot(to, 1); + CheckCondition(1 == rocksdb_transaction_options_get_set_snapshot(to)); + rocksdb_transaction_options_set_deadlock_detect(to, 1); + CheckCondition(1 == rocksdb_transaction_options_get_deadlock_detect(to)); + rocksdb_transaction_options_set_use_only_the_last_commit_time_batch_for_recovery( + to, 1); + CheckCondition( + 1 == + rocksdb_transaction_options_get_use_only_the_last_commit_time_batch_for_recovery( + to)); + rocksdb_transaction_options_set_lock_timeout(to, 16); + CheckCondition(16 == rocksdb_transaction_options_get_lock_timeout(to)); + rocksdb_transaction_options_set_deadlock_timeout_us(to, 17); + CheckCondition(17 == + rocksdb_transaction_options_get_deadlock_timeout_us(to)); + rocksdb_transaction_options_set_expiration(to, 18); + CheckCondition(18 == rocksdb_transaction_options_get_expiration(to)); + rocksdb_transaction_options_set_deadlock_detect_depth(to, 19); + CheckCondition(19 == + rocksdb_transaction_options_get_deadlock_detect_depth(to)); + rocksdb_transaction_options_set_max_write_batch_size(to, 20); + CheckCondition(20 == + rocksdb_transaction_options_get_max_write_batch_size(to)); + rocksdb_transaction_options_set_skip_concurrency_control(to, 1); + CheckCondition( + 1 == rocksdb_transaction_options_get_skip_concurrency_control(to)); + rocksdb_transaction_options_set_skip_prepare(to, 0); + CheckCondition(0 == rocksdb_transaction_options_get_skip_prepare(to)); + rocksdb_transaction_options_set_write_batch_flush_threshold(to, 21); + CheckCondition( + 21 == rocksdb_transaction_options_get_write_batch_flush_threshold(to)); + rocksdb_transaction_options_set_write_batch_track_timestamp_size(to, 1); + CheckCondition( + 1 == + rocksdb_transaction_options_get_write_batch_track_timestamp_size(to)); + rocksdb_transaction_options_set_commit_bypass_memtable(to, 1); + CheckCondition(1 == + rocksdb_transaction_options_get_commit_bypass_memtable(to)); + rocksdb_transaction_options_set_large_txn_commit_optimize_threshold(to, 22); + CheckCondition( + 22 == + rocksdb_transaction_options_get_large_txn_commit_optimize_threshold( + to)); + rocksdb_transaction_options_set_large_txn_commit_optimize_byte_threshold( + to, 23); + CheckCondition( + 23 == + rocksdb_transaction_options_get_large_txn_commit_optimize_byte_threshold( + to)); + rocksdb_transaction_options_destroy(to); + + oto = rocksdb_optimistictransaction_options_create(); + rocksdb_optimistictransaction_options_set_set_snapshot(oto, 1); + CheckCondition(1 == + rocksdb_optimistictransaction_options_get_set_snapshot(oto)); + rocksdb_optimistictransaction_options_destroy(oto); + } + StartPhase("compression_options"); { rocksdb_options_t* co; @@ -4187,13 +5628,23 @@ int main(int argc, char** argv) { // flush rocksdb_flushoptions_t* flush_options = rocksdb_flushoptions_create(); + rocksdb_flushwaloptions_t* txn_flush_wal_options = + rocksdb_flushwaloptions_create(); rocksdb_flushoptions_set_wait(flush_options, 1); - rocksdb_transactiondb_flush_wal(txn_db, 1, &err); + rocksdb_flushwaloptions_set_sync(txn_flush_wal_options, 1); + CheckCondition(1 == + rocksdb_flushwaloptions_get_sync(txn_flush_wal_options)); + rocksdb_flushwaloptions_set_rate_limiter_priority(txn_flush_wal_options, 1); + CheckCondition(1 == rocksdb_flushwaloptions_get_rate_limiter_priority( + txn_flush_wal_options)); + rocksdb_transactiondb_flush_wal_with_options(txn_db, txn_flush_wal_options, + &err); CheckNoError(err); rocksdb_transactiondb_flush_cf(txn_db, flush_options, cfh, &err); CheckNoError(err); rocksdb_transactiondb_flush(txn_db, flush_options, &err); CheckNoError(err); + rocksdb_flushwaloptions_destroy(txn_flush_wal_options); rocksdb_flushoptions_destroy(flush_options); // close and destroy @@ -4414,9 +5865,29 @@ int main(int argc, char** argv) { StartPhase("optimistic_transactions"); { rocksdb_options_t* db_options = rocksdb_options_create(); + rocksdb_optimistictransactiondb_options_t* otxn_db_open_options = + rocksdb_optimistictransactiondb_options_create(); + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets = + rocksdb_optimistictransactiondb_lock_buckets_create(128, 1); rocksdb_options_set_create_if_missing(db_options, 1); rocksdb_options_set_allow_concurrent_memtable_write(db_options, 1); - otxn_db = rocksdb_optimistictransactiondb_open(db_options, dbname, &err); + rocksdb_optimistictransactiondb_options_set_validate_policy( + otxn_db_open_options, 0); + CheckCondition(0 == + rocksdb_optimistictransactiondb_options_get_validate_policy( + otxn_db_open_options)); + rocksdb_optimistictransactiondb_options_set_occ_lock_buckets( + otxn_db_open_options, 1024); + CheckCondition(1024 == + rocksdb_optimistictransactiondb_options_get_occ_lock_buckets( + otxn_db_open_options)); + CheckCondition( + rocksdb_optimistictransactiondb_lock_buckets_approximate_memory_usage( + lock_buckets) > 0); + rocksdb_optimistictransactiondb_options_set_shared_lock_buckets( + otxn_db_open_options, lock_buckets); + otxn_db = rocksdb_optimistictransactiondb_open_with_otxn_db_options( + db_options, otxn_db_open_options, dbname, &err); otxn_options = rocksdb_optimistictransaction_options_create(); rocksdb_transaction_t* txn1 = rocksdb_optimistictransaction_begin( otxn_db, woptions, otxn_options, NULL); @@ -4515,8 +5986,10 @@ int main(int argc, char** argv) { rocksdb_options_set_error_if_exists(cf_options, 0); rocksdb_column_family_handle_t* cf_handles[3]; - otxn_db = rocksdb_optimistictransactiondb_open_column_families( - db_options, dbname, 3, cf_names, cf_opts, cf_handles, &err); + otxn_db = + rocksdb_optimistictransactiondb_open_column_families_with_otxn_db_options( + db_options, otxn_db_open_options, dbname, 3, cf_names, cf_opts, + cf_handles, &err); CheckNoError(err); rocksdb_transaction_t* txn_cf = rocksdb_optimistictransaction_begin( otxn_db, woptions, otxn_options, NULL); @@ -4534,6 +6007,8 @@ int main(int argc, char** argv) { rocksdb_optimistictransactiondb_close(otxn_db); rocksdb_destroy_db(db_options, dbname, &err); rocksdb_options_destroy(db_options); + rocksdb_optimistictransactiondb_lock_buckets_destroy(lock_buckets); + rocksdb_optimistictransactiondb_options_destroy(otxn_db_open_options); rocksdb_optimistictransaction_options_destroy(otxn_options); CheckNoError(err); } @@ -4746,6 +6221,10 @@ int main(int argc, char** argv) { rocksdb_wait_for_compact_options_set_close_db(wco, 1); CheckCondition(1 == rocksdb_wait_for_compact_options_get_close_db(wco)); + rocksdb_wait_for_compact_options_set_wait_for_purge(wco, 1); + CheckCondition(1 == + rocksdb_wait_for_compact_options_get_wait_for_purge(wco)); + rocksdb_wait_for_compact_options_set_timeout(wco, 342); CheckCondition(342 == rocksdb_wait_for_compact_options_get_timeout(wco)); @@ -4762,6 +6241,248 @@ int main(int argc, char** argv) { rocksdb_wait_for_compact_options_destroy(wco); } + StartPhase("livefiles_storage_info"); + { + int found_named_entry = 0; + rocksdb_livefiles_storage_info_options_t* storage_options = + rocksdb_livefiles_storage_info_options_create(); + rocksdb_livefiles_storage_info_t* storage_info; + rocksdb_livefiles_storage_info_options_set_include_checksum_info( + storage_options, 1); + CheckCondition( + 1 == rocksdb_livefiles_storage_info_options_get_include_checksum_info( + storage_options)); + rocksdb_livefiles_storage_info_options_set_wal_size_for_flush( + storage_options, UINT64_MAX); + CheckCondition( + UINT64_MAX == + rocksdb_livefiles_storage_info_options_get_wal_size_for_flush( + storage_options)); + rocksdb_livefiles_storage_info_options_set_atomic_flush(storage_options, 1); + CheckCondition(1 == rocksdb_livefiles_storage_info_options_get_atomic_flush( + storage_options)); + + storage_info = + rocksdb_get_livefiles_storage_info(db, storage_options, &err); + CheckNoError(err); + CheckCondition(storage_info != NULL); + CheckCondition(rocksdb_livefiles_storage_info_count(storage_info) > 0); + for (size_t i = 0; i < rocksdb_livefiles_storage_info_count(storage_info); + ++i) { + size_t replacement_contents_len = 0; + const char* relative_filename = + rocksdb_livefiles_storage_info_relative_filename(storage_info, i); + const char* directory = + rocksdb_livefiles_storage_info_directory(storage_info, i); + CheckCondition(relative_filename != NULL); + CheckCondition(directory != NULL); + if (strlen(relative_filename) > 0) { + found_named_entry = 1; + } + (void)rocksdb_livefiles_storage_info_file_number(storage_info, i); + (void)rocksdb_livefiles_storage_info_file_type(storage_info, i); + (void)rocksdb_livefiles_storage_info_size(storage_info, i); + (void)rocksdb_livefiles_storage_info_temperature(storage_info, i); + (void)rocksdb_livefiles_storage_info_file_checksum(storage_info, i); + (void)rocksdb_livefiles_storage_info_file_checksum_func_name(storage_info, + i); + (void)rocksdb_livefiles_storage_info_replacement_contents( + storage_info, i, &replacement_contents_len); + (void)rocksdb_livefiles_storage_info_trim_to_size(storage_info, i); + } + CheckCondition(found_named_entry); + rocksdb_livefiles_storage_info_destroy(storage_info); + rocksdb_livefiles_storage_info_options_destroy(storage_options); + } + + StartPhase("trace_options"); + { + rocksdb_trace_options_t* trace_options = rocksdb_trace_options_create(); + rocksdb_block_cache_trace_options_t* block_trace_options = + rocksdb_block_cache_trace_options_create(); + rocksdb_block_cache_trace_writer_options_t* writer_options = + rocksdb_block_cache_trace_writer_options_create(); + rocksdb_trace_options_set_max_trace_file_size(trace_options, 1024 * 1024); + CheckCondition(1024 * 1024 == rocksdb_trace_options_get_max_trace_file_size( + trace_options)); + rocksdb_trace_options_set_sampling_frequency(trace_options, 3); + CheckCondition(3 == + rocksdb_trace_options_get_sampling_frequency(trace_options)); + rocksdb_trace_options_set_filter(trace_options, + rocksdb_trace_filter_multi_get); + CheckCondition(rocksdb_trace_filter_multi_get == + rocksdb_trace_options_get_filter(trace_options)); + rocksdb_trace_options_set_preserve_write_order(trace_options, 1); + CheckCondition( + 1 == rocksdb_trace_options_get_preserve_write_order(trace_options)); + rocksdb_block_cache_trace_options_set_sampling_frequency( + block_trace_options, 7); + CheckCondition(7 == + rocksdb_block_cache_trace_options_get_sampling_frequency( + block_trace_options)); + rocksdb_block_cache_trace_writer_options_set_max_trace_file_size( + writer_options, 2048); + CheckCondition( + 2048 == + rocksdb_block_cache_trace_writer_options_get_max_trace_file_size( + writer_options)); + rocksdb_block_cache_trace_writer_options_destroy(writer_options); + rocksdb_block_cache_trace_options_destroy(block_trace_options); + rocksdb_trace_options_destroy(trace_options); + } + + StartPhase("trace"); + { + char trace_filename[400]; + char io_trace_filename[400]; + char block_trace_filename[400]; + char block_trace_filename_2[400]; + char replay_dbname[400]; + size_t val_len; + char* val; + rocksdb_trace_options_t* trace_options = rocksdb_trace_options_create(); + rocksdb_envoptions_t* trace_env_options = rocksdb_envoptions_create(); + rocksdb_block_cache_trace_options_t* block_trace_options = + rocksdb_block_cache_trace_options_create(); + rocksdb_block_cache_trace_writer_options_t* writer_options = + rocksdb_block_cache_trace_writer_options_create(); + rocksdb_flushoptions_t* flush_options = rocksdb_flushoptions_create(); + + snprintf(trace_filename, sizeof(trace_filename), "%s/rocksdb.trace", + dbname); + snprintf(io_trace_filename, sizeof(io_trace_filename), + "%s/rocksdb_io.trace", dbname); + snprintf(block_trace_filename, sizeof(block_trace_filename), + "%s/rocksdb_block.trace", dbname); + snprintf(block_trace_filename_2, sizeof(block_trace_filename_2), + "%s/rocksdb_block2.trace", dbname); + remove(trace_filename); + remove(io_trace_filename); + remove(block_trace_filename); + remove(block_trace_filename_2); + + rocksdb_trace_options_set_max_trace_file_size(trace_options, 1024 * 1024); + rocksdb_trace_options_set_sampling_frequency(trace_options, 1); + rocksdb_trace_options_set_filter(trace_options, rocksdb_trace_filter_none); + rocksdb_block_cache_trace_options_set_sampling_frequency( + block_trace_options, 1); + rocksdb_block_cache_trace_writer_options_set_max_trace_file_size( + writer_options, 1024 * 1024); + rocksdb_flushoptions_set_wait(flush_options, 1); + + rocksdb_start_trace(db, NULL, trace_env_options, trace_options, + trace_filename, &err); + CheckNoError(err); + rocksdb_put(db, woptions, "tracek", 6, "tracev", 6, &err); + CheckNoError(err); + rocksdb_end_trace(db, &err); + CheckNoError(err); + CheckCondition(GetLocalFileSize(trace_filename) > 0); + + rocksdb_start_io_trace(db, NULL, trace_env_options, trace_options, + io_trace_filename, &err); + CheckNoError(err); + val = rocksdb_get(db, roptions, "tracek", 6, &val_len, &err); + CheckValue(err, "tracev", &val, val_len); + rocksdb_end_io_trace(db, &err); + CheckNoError(err); + CheckCondition(GetLocalFileSize(io_trace_filename) > 0); + + rocksdb_flush(db, flush_options, &err); + CheckNoError(err); + + rocksdb_start_block_cache_trace(db, NULL, trace_env_options, trace_options, + block_trace_filename, &err); + CheckNoError(err); + val = rocksdb_get(db, roptions, "tracek", 6, &val_len, &err); + CheckValue(err, "tracev", &val, val_len); + rocksdb_end_block_cache_trace(db, &err); + CheckNoError(err); + CheckCondition(GetLocalFileSize(block_trace_filename) > 0); + + rocksdb_start_block_cache_trace_with_options( + db, NULL, trace_env_options, block_trace_options, writer_options, + block_trace_filename_2, &err); + CheckNoError(err); + val = rocksdb_get(db, roptions, "tracek", 6, &val_len, &err); + CheckValue(err, "tracev", &val, val_len); + rocksdb_end_block_cache_trace(db, &err); + CheckNoError(err); + CheckCondition(GetLocalFileSize(block_trace_filename_2) > 0); + + { + rocksdb_trace_reader_t* trace_reader; + rocksdb_replay_options_t* replay_options = + rocksdb_replay_options_create(); + rocksdb_options_t* replay_db_options = rocksdb_options_create(); + rocksdb_t* replay_db; + rocksdb_replayer_t* replayer; + char* encoded_trace = NULL; + size_t encoded_trace_size = 0; + + trace_reader = rocksdb_trace_reader_create(env, trace_env_options, + trace_filename, &err); + CheckNoError(err); + CheckCondition(trace_reader != NULL); + + encoded_trace = + rocksdb_trace_reader_read(trace_reader, &encoded_trace_size, &err); + CheckNoError(err); + CheckCondition(encoded_trace != NULL); + CheckCondition(encoded_trace_size > 0); + free(encoded_trace); + + rocksdb_trace_reader_reset(trace_reader, &err); + CheckNoError(err); + encoded_trace = + rocksdb_trace_reader_read(trace_reader, &encoded_trace_size, &err); + CheckNoError(err); + CheckCondition(encoded_trace != NULL); + free(encoded_trace); + + rocksdb_trace_reader_close(trace_reader, &err); + CheckNoError(err); + rocksdb_trace_reader_destroy(trace_reader); + + snprintf(replay_dbname, sizeof(replay_dbname), + "%s/rocksdb_c_test-%d-replay", GetTempDir(), ((int)geteuid())); + rocksdb_options_set_create_if_missing(replay_db_options, 1); + rocksdb_options_set_env(replay_db_options, env); + rocksdb_options_set_comparator(replay_db_options, cmp); + replay_db = rocksdb_open(replay_db_options, replay_dbname, &err); + CheckNoError(err); + + rocksdb_replay_options_set_num_threads(replay_options, 1); + rocksdb_replay_options_set_fast_forward(replay_options, 1000000.0); + CheckCondition(1 == + rocksdb_replay_options_get_num_threads(replay_options)); + CheckCondition(1000000.0 == + rocksdb_replay_options_get_fast_forward(replay_options)); + + replayer = rocksdb_new_default_replayer( + replay_db, NULL, 0, env, trace_env_options, trace_filename, &err); + CheckNoError(err); + CheckCondition(replayer != NULL); + rocksdb_replayer_prepare(replayer, &err); + CheckNoError(err); + CheckCondition(rocksdb_replayer_get_header_timestamp(replayer) > 0); + rocksdb_replayer_replay(replayer, replay_options, &err); + CheckNoError(err); + CheckGet(replay_db, roptions, "tracek", "tracev"); + + rocksdb_replayer_destroy(replayer); + rocksdb_close(replay_db); + rocksdb_options_destroy(replay_db_options); + rocksdb_replay_options_destroy(replay_options); + } + + rocksdb_flushoptions_destroy(flush_options); + rocksdb_block_cache_trace_writer_options_destroy(writer_options); + rocksdb_block_cache_trace_options_destroy(block_trace_options); + rocksdb_envoptions_destroy(trace_env_options); + rocksdb_trace_options_destroy(trace_options); + } + StartPhase("write_buffer_manager"); { rocksdb_cache_t* lru; @@ -4999,12 +6720,20 @@ int main(int argc, char** argv) { { // Test that the new factory types work with regular rocksdb_options_t rocksdb_options_t* test_opts = rocksdb_options_create(); + rocksdb_t* checksum_db; + rocksdb_writeoptions_t* checksum_woptions = rocksdb_writeoptions_create(); + rocksdb_flushoptions_t* checksum_flushoptions = + rocksdb_flushoptions_create(); + rocksdb_readoptions_t* checksum_roptions = rocksdb_readoptions_create(); + char checksum_dbname[400]; // Test file checksum gen factory on regular options rocksdb_file_checksum_gen_factory_t* checksum_factory = rocksdb_file_checksum_gen_crc32c_factory_create(); CheckCondition(checksum_factory != NULL); rocksdb_options_set_file_checksum_gen_factory(test_opts, checksum_factory); + rocksdb_options_set_create_if_missing(test_opts, 1); + rocksdb_options_set_env(test_opts, env); // Test SST partitioner factory on regular options rocksdb_sst_partitioner_factory_t* partitioner_factory = @@ -5012,6 +6741,25 @@ int main(int argc, char** argv) { CheckCondition(partitioner_factory != NULL); rocksdb_options_set_sst_partitioner_factory(test_opts, partitioner_factory); + snprintf(checksum_dbname, sizeof(checksum_dbname), + "%s/rocksdb_c_test-%d-checksum", GetTempDir(), ((int)geteuid())); + checksum_db = rocksdb_open(test_opts, checksum_dbname, &err); + CheckNoError(err); + rocksdb_put(checksum_db, checksum_woptions, "checksum-key", 12, + "checksum-value", 14, &err); + CheckNoError(err); + rocksdb_flush(checksum_db, checksum_flushoptions, &err); + CheckNoError(err); + rocksdb_verify_file_checksums(checksum_db, &err); + CheckNoError(err); + rocksdb_verify_file_checksums_with_options(checksum_db, checksum_roptions, + &err); + CheckNoError(err); + rocksdb_close(checksum_db); + rocksdb_readoptions_destroy(checksum_roptions); + rocksdb_flushoptions_destroy(checksum_flushoptions); + rocksdb_writeoptions_destroy(checksum_woptions); + // Cleanup rocksdb_file_checksum_gen_factory_destroy(checksum_factory); rocksdb_sst_partitioner_factory_destroy(partitioner_factory); @@ -5076,6 +6824,8 @@ int main(int argc, char** argv) { rocksdb_open_and_compact_options_create(); rocksdb_open_and_compact_options_set_canceled(oac_opts, canceled); rocksdb_open_and_compact_options_set_allow_resumption(oac_opts, 1); + CheckCondition( + 1 == rocksdb_open_and_compact_options_get_allow_resumption(oac_opts)); // Cleanup rocksdb_open_and_compact_options_destroy(oac_opts); @@ -5117,6 +6867,9 @@ int main(int argc, char** argv) { StartPhase("cancel_all_background_work"); rocksdb_cancel_all_background_work(db, 1); + StartPhase("generated_option_roundtrips"); + rocksdb_run_generated_roundtrip_tests(); + StartPhase("cleanup"); rocksdb_close(db); rocksdb_options_destroy(options); diff --git a/include/rocksdb/c.h b/include/rocksdb/c.h index 66ef64d515..6e998fa8e0 100644 --- a/include/rocksdb/c.h +++ b/include/rocksdb/c.h @@ -1,16 +1,16 @@ -// Copyright (c) 2011-present, Facebook, Inc. All rights reserved. +// 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). +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/regen_all.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Edit tools/c_api_gen/c_base.h or the inputs under tools/c_api_gen/, +// then rerun: python3 tools/c_api_gen/regen_all.py +// ----------------------------------------------------------------------------- -/* 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. - - C bindings for rocksdb. May be useful as a stable ABI that can be - used by programs that keep rocksdb in a shared library, or for - a JNI api. - +/* Does not support: . getters for the option types . custom comparators that implement key shortening @@ -73,6 +73,7 @@ typedef struct rocksdb_status_ptr_t rocksdb_status_ptr_t; typedef struct rocksdb_backup_engine_t rocksdb_backup_engine_t; typedef struct rocksdb_backup_engine_info_t rocksdb_backup_engine_info_t; typedef struct rocksdb_backup_engine_options_t rocksdb_backup_engine_options_t; +typedef struct rocksdb_create_backup_options_t rocksdb_create_backup_options_t; typedef struct rocksdb_restore_options_t rocksdb_restore_options_t; typedef struct rocksdb_memory_allocator_t rocksdb_memory_allocator_t; typedef struct rocksdb_lru_cache_options_t rocksdb_lru_cache_options_t; @@ -86,6 +87,7 @@ typedef struct rocksdb_compactionfiltercontext_t rocksdb_compactionfiltercontext_t; typedef struct rocksdb_compactionfilterfactory_t rocksdb_compactionfilterfactory_t; +typedef struct rocksdb_walfilter_t rocksdb_walfilter_t; typedef struct rocksdb_file_checksum_gen_factory_t rocksdb_file_checksum_gen_factory_t; typedef struct rocksdb_sst_partitioner_factory_t @@ -100,13 +102,19 @@ typedef struct rocksdb_fifo_compaction_options_t typedef struct rocksdb_filelock_t rocksdb_filelock_t; typedef struct rocksdb_filterpolicy_t rocksdb_filterpolicy_t; typedef struct rocksdb_flushoptions_t rocksdb_flushoptions_t; +typedef struct rocksdb_flushwaloptions_t rocksdb_flushwaloptions_t; typedef struct rocksdb_iterator_t rocksdb_iterator_t; typedef struct rocksdb_logger_t rocksdb_logger_t; typedef struct rocksdb_mergeoperator_t rocksdb_mergeoperator_t; typedef struct rocksdb_options_t rocksdb_options_t; +typedef struct rocksdb_compaction_options_t rocksdb_compaction_options_t; typedef struct rocksdb_compactoptions_t rocksdb_compactoptions_t; typedef struct rocksdb_block_based_table_options_t rocksdb_block_based_table_options_t; +typedef struct rocksdb_block_cache_trace_options_t + rocksdb_block_cache_trace_options_t; +typedef struct rocksdb_block_cache_trace_writer_options_t + rocksdb_block_cache_trace_writer_options_t; typedef struct rocksdb_cuckoo_table_options_t rocksdb_cuckoo_table_options_t; typedef struct rocksdb_randomfile_t rocksdb_randomfile_t; typedef struct rocksdb_readoptions_t rocksdb_readoptions_t; @@ -130,9 +138,21 @@ typedef struct rocksdb_export_import_files_metadata_t rocksdb_export_import_files_metadata_t; typedef struct rocksdb_level_metadata_t rocksdb_level_metadata_t; typedef struct rocksdb_sst_file_metadata_t rocksdb_sst_file_metadata_t; +typedef struct rocksdb_column_family_metadata_options_t + rocksdb_column_family_metadata_options_t; typedef struct rocksdb_envoptions_t rocksdb_envoptions_t; typedef struct rocksdb_ingestexternalfileoptions_t rocksdb_ingestexternalfileoptions_t; +typedef struct rocksdb_trace_options_t rocksdb_trace_options_t; +typedef struct rocksdb_trace_reader_t rocksdb_trace_reader_t; +typedef struct rocksdb_replay_options_t rocksdb_replay_options_t; +typedef struct rocksdb_replayer_t rocksdb_replayer_t; +typedef struct rocksdb_size_approximation_options_t + rocksdb_size_approximation_options_t; +typedef struct rocksdb_livefiles_storage_info_options_t + rocksdb_livefiles_storage_info_options_t; +typedef struct rocksdb_livefiles_storage_info_t + rocksdb_livefiles_storage_info_t; typedef struct rocksdb_sstfilewriter_t rocksdb_sstfilewriter_t; typedef struct rocksdb_ratelimiter_t rocksdb_ratelimiter_t; typedef struct rocksdb_perfcontext_t rocksdb_perfcontext_t; @@ -142,12 +162,18 @@ typedef struct rocksdb_transactiondb_t rocksdb_transactiondb_t; typedef struct rocksdb_transaction_options_t rocksdb_transaction_options_t; typedef struct rocksdb_optimistictransactiondb_t rocksdb_optimistictransactiondb_t; +typedef struct rocksdb_optimistictransactiondb_options_t + rocksdb_optimistictransactiondb_options_t; +typedef struct rocksdb_optimistictransactiondb_lock_buckets_t + rocksdb_optimistictransactiondb_lock_buckets_t; typedef struct rocksdb_optimistictransaction_options_t rocksdb_optimistictransaction_options_t; typedef struct rocksdb_transaction_t rocksdb_transaction_t; typedef struct rocksdb_checkpoint_t rocksdb_checkpoint_t; typedef struct rocksdb_wal_iterator_t rocksdb_wal_iterator_t; typedef struct rocksdb_wal_readoptions_t rocksdb_wal_readoptions_t; +typedef struct rocksdb_wal_file_t rocksdb_wal_file_t; +typedef struct rocksdb_wal_files_t rocksdb_wal_files_t; typedef struct rocksdb_memory_consumers_t rocksdb_memory_consumers_t; typedef struct rocksdb_memory_usage_t rocksdb_memory_usage_t; typedef struct rocksdb_statistics_histogram_data_t @@ -167,6 +193,13 @@ typedef struct rocksdb_compactionjobinfo_t rocksdb_compactionjobinfo_t; typedef struct rocksdb_subcompactionjobinfo_t rocksdb_subcompactionjobinfo_t; typedef struct rocksdb_externalfileingestioninfo_t rocksdb_externalfileingestioninfo_t; +typedef struct rocksdb_table_properties_t rocksdb_table_properties_t; +typedef struct rocksdb_compaction_job_stats_t rocksdb_compaction_job_stats_t; +typedef struct rocksdb_compaction_file_info_t rocksdb_compaction_file_info_t; +typedef struct rocksdb_blob_file_addition_info_t + rocksdb_blob_file_addition_info_t; +typedef struct rocksdb_blob_file_garbage_info_t + rocksdb_blob_file_garbage_info_t; typedef struct rocksdb_eventlistener_t rocksdb_eventlistener_t; typedef struct rocksdb_writestallinfo_t rocksdb_writestallinfo_t; typedef struct rocksdb_writestallcondition_t rocksdb_writestallcondition_t; @@ -197,6 +230,22 @@ typedef void (*rocksdb_compaction_service_cancel_awaiting_jobs_cb)(void* state); typedef void (*rocksdb_compaction_service_on_installation_cb)( void* state, const char* scheduled_job_id, int status); +typedef void (*rocksdb_create_backup_options_progress_cb)(void* state); +typedef unsigned char (*rocksdb_create_backup_options_exclude_files_cb)( + void* state, const char* relative_file, size_t relative_file_len); +typedef unsigned char (*rocksdb_readoptions_table_filter_cb)( + void* state, const rocksdb_table_properties_t* table_properties); +typedef void (*rocksdb_walfilter_column_family_log_number_map_cb)( + void* state, const uint32_t* column_family_ids, const uint64_t* log_numbers, + size_t column_family_log_number_count, + const char* const* column_family_names, + const size_t* column_family_name_lengths, + const uint32_t* column_family_name_ids, size_t column_family_name_count); +typedef int (*rocksdb_walfilter_log_record_found_cb)( + void* state, unsigned long long log_number, const char* log_file_name, + size_t log_file_name_len, const rocksdb_writebatch_t* batch, + rocksdb_writebatch_t* new_batch, unsigned char* batch_changed); + /* DB operations */ extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open( @@ -205,8 +254,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open( extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_with_ttl( const rocksdb_options_t* options, const char* name, int ttl, char** errptr); -/* If error_if_wal_file_exists is non-zero, returns an error when a non-empty - * WAL file exists. Empty WAL files are tolerated. */ extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_for_read_only( const rocksdb_options_t* options, const char* name, unsigned char error_if_wal_file_exists, char** errptr); @@ -222,6 +269,22 @@ extern ROCKSDB_LIBRARY_API rocksdb_backup_engine_t* rocksdb_backup_engine_open_opts(const rocksdb_backup_engine_options_t* options, rocksdb_env_t* env, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_create_backup_options_t* +rocksdb_create_backup_options_create(void); + +extern ROCKSDB_LIBRARY_API void rocksdb_create_backup_options_destroy( + rocksdb_create_backup_options_t* options); + +extern ROCKSDB_LIBRARY_API void +rocksdb_create_backup_options_set_progress_callback( + rocksdb_create_backup_options_t* options, void* state, + rocksdb_create_backup_options_progress_cb callback); + +extern ROCKSDB_LIBRARY_API void +rocksdb_create_backup_options_set_exclude_files_callback( + rocksdb_create_backup_options_t* options, void* state, + rocksdb_create_backup_options_exclude_files_cb callback); + extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_create_new_backup( rocksdb_backup_engine_t* be, rocksdb_t* db, char** errptr); @@ -229,6 +292,18 @@ extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_create_new_backup_flush( rocksdb_backup_engine_t* be, rocksdb_t* db, unsigned char flush_before_backup, char** errptr); +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_create_new_backup_with_options( + rocksdb_backup_engine_t* be, rocksdb_t* db, + const rocksdb_create_backup_options_t* options, uint32_t* backup_id, + char** errptr); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_create_new_backup_with_metadata( + rocksdb_backup_engine_t* be, rocksdb_t* db, + const rocksdb_create_backup_options_t* options, const char* app_metadata, + size_t app_metadata_len, uint32_t* backup_id, char** errptr); + extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_purge_old_backups( rocksdb_backup_engine_t* be, uint32_t num_backups_to_keep, char** errptr); @@ -236,8 +311,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_restore_options_t* rocksdb_restore_options_create(void); extern ROCKSDB_LIBRARY_API void rocksdb_restore_options_destroy( rocksdb_restore_options_t* opt); -extern ROCKSDB_LIBRARY_API void rocksdb_restore_options_set_keep_log_files( - rocksdb_restore_options_t* opt, int v); extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_verify_backup( rocksdb_backup_engine_t* be, uint32_t backup_id, char** errptr); @@ -270,18 +343,67 @@ extern ROCKSDB_LIBRARY_API uint64_t rocksdb_backup_engine_info_size( extern ROCKSDB_LIBRARY_API uint32_t rocksdb_backup_engine_info_number_files( const rocksdb_backup_engine_info_t* info, int index); +extern ROCKSDB_LIBRARY_API const char* rocksdb_backup_engine_info_app_metadata( + const rocksdb_backup_engine_info_t* info, int index, size_t* len); + extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_info_destroy( const rocksdb_backup_engine_info_t* info); -/* Cancels any in-progress backup. This is a one-way operation: once called, - all future CreateNewBackup requests on this engine will fail with - Status::Incomplete. Open a new BackupEngine instance to resume backups. */ extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_stop_backup( rocksdb_backup_engine_t* be); extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_close( rocksdb_backup_engine_t* be); +// BEGIN generated: c_generated_db_simple_subset.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'DB data operations' +// --header-out +// c_api_gen/c_generated_db_simple_subset.h.inc +// --source-out +// c_api_gen/c_generated_db_simple_subset.cc.inc + +/* DB data operations */ + +extern ROCKSDB_LIBRARY_API void rocksdb_put( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_put_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_merge( + rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_merge_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, const char* val, size_t vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_write( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_writebatch_t* batch, char** errptr); + extern ROCKSDB_LIBRARY_API void rocksdb_put_with_ts( rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, size_t keylen, const char* ts, size_t tslen, const char* val, size_t vallen, @@ -320,6 +442,52 @@ extern ROCKSDB_LIBRARY_API void rocksdb_singledelete_cf_with_ts( rocksdb_column_family_handle_t* column_family, const char* key, size_t keylen, const char* ts, size_t tslen, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_delete_range_cf( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* start_key, + size_t start_key_len, const char* end_key, size_t end_key_len, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_flush( + rocksdb_t* db, const rocksdb_flushoptions_t* options, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_flush_cf( + rocksdb_t* db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_flush_wal(rocksdb_t* db, + unsigned char sync, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_pause_background_work(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_continue_background_work(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_disable_file_deletions(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_enable_file_deletions(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_verify_checksum(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_verify_file_checksums(rocksdb_t* db, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_destroy_db( + const rocksdb_options_t* options, const char* name, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_repair_db( + const rocksdb_options_t* options, const char* name, char** errptr); +// END generated: c_generated_db_simple_subset.h.inc +extern ROCKSDB_LIBRARY_API void rocksdb_verify_checksum_with_options( + rocksdb_t* db, const rocksdb_readoptions_t* options, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_verify_file_checksums_with_options( + rocksdb_t* db, const rocksdb_readoptions_t* options, char** errptr); + extern ROCKSDB_LIBRARY_API void rocksdb_increase_full_history_ts_low( rocksdb_t* db, rocksdb_column_family_handle_t* column_family, const char* ts_low, size_t ts_lowlen, char** errptr); @@ -333,102 +501,17 @@ extern ROCKSDB_LIBRARY_API char* rocksdb_get_full_history_ts_low( extern ROCKSDB_LIBRARY_API rocksdb_backup_engine_options_t* rocksdb_backup_engine_options_create(const char* backup_dir); -extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_set_backup_dir( - rocksdb_backup_engine_options_t* options, const char* backup_dir); - extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_set_env( rocksdb_backup_engine_options_t* options, rocksdb_env_t* env); extern ROCKSDB_LIBRARY_API void -rocksdb_backup_engine_options_set_share_table_files( - rocksdb_backup_engine_options_t* options, unsigned char val); - -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_backup_engine_options_get_share_table_files( - rocksdb_backup_engine_options_t* options); - -extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_set_sync( - rocksdb_backup_engine_options_t* options, unsigned char val); - -extern ROCKSDB_LIBRARY_API unsigned char rocksdb_backup_engine_options_get_sync( - rocksdb_backup_engine_options_t* options); - -extern ROCKSDB_LIBRARY_API void -rocksdb_backup_engine_options_set_destroy_old_data( - rocksdb_backup_engine_options_t* options, unsigned char val); - -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_backup_engine_options_get_destroy_old_data( - rocksdb_backup_engine_options_t* options); - -extern ROCKSDB_LIBRARY_API void -rocksdb_backup_engine_options_set_backup_log_files( - rocksdb_backup_engine_options_t* options, unsigned char val); - -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_backup_engine_options_get_backup_log_files( - rocksdb_backup_engine_options_t* options); - -extern ROCKSDB_LIBRARY_API void -rocksdb_backup_engine_options_set_backup_rate_limit( - rocksdb_backup_engine_options_t* options, uint64_t limit); - -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_backup_engine_options_get_backup_rate_limit( - rocksdb_backup_engine_options_t* options); - -extern ROCKSDB_LIBRARY_API void -rocksdb_backup_engine_options_set_restore_rate_limit( - rocksdb_backup_engine_options_t* options, uint64_t limit); - -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_backup_engine_options_get_restore_rate_limit( - rocksdb_backup_engine_options_t* options); - -/* Sets a RateLimiter for backup transfers. When non-null, overrides the - uint64_t backup_rate_limit value. */ -extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_set_backup_rate_limiter( rocksdb_backup_engine_options_t* options, rocksdb_ratelimiter_t* limiter); -/* Sets a RateLimiter for restore transfers. When non-null, overrides the - uint64_t restore_rate_limit value. */ extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_set_restore_rate_limiter( rocksdb_backup_engine_options_t* options, rocksdb_ratelimiter_t* limiter); -extern ROCKSDB_LIBRARY_API void -rocksdb_backup_engine_options_set_max_background_operations( - rocksdb_backup_engine_options_t* options, int val); - -extern ROCKSDB_LIBRARY_API int -rocksdb_backup_engine_options_get_max_background_operations( - rocksdb_backup_engine_options_t* options); - -extern ROCKSDB_LIBRARY_API void -rocksdb_backup_engine_options_set_callback_trigger_interval_size( - rocksdb_backup_engine_options_t* options, uint64_t size); - -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_backup_engine_options_get_callback_trigger_interval_size( - rocksdb_backup_engine_options_t* options); - -extern ROCKSDB_LIBRARY_API void -rocksdb_backup_engine_options_set_max_valid_backups_to_open( - rocksdb_backup_engine_options_t* options, int val); - -extern ROCKSDB_LIBRARY_API int -rocksdb_backup_engine_options_get_max_valid_backups_to_open( - rocksdb_backup_engine_options_t* options); - -extern ROCKSDB_LIBRARY_API void -rocksdb_backup_engine_options_set_share_files_with_checksum_naming( - rocksdb_backup_engine_options_t* options, int val); - -extern ROCKSDB_LIBRARY_API int -rocksdb_backup_engine_options_get_share_files_with_checksum_naming( - rocksdb_backup_engine_options_t* options); - extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_destroy( rocksdb_backup_engine_options_t*); @@ -470,8 +553,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_column_families_with_ttl( rocksdb_column_family_handle_t** column_family_handles, const int* ttls, char** errptr); -/* If error_if_wal_file_exists is non-zero, returns an error when a non-empty - * WAL file exists. Empty WAL files are tolerated. */ extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_for_read_only_column_families( const rocksdb_options_t* options, const char* name, int num_column_families, @@ -538,43 +619,6 @@ extern ROCKSDB_LIBRARY_API char* rocksdb_column_family_handle_get_name( extern ROCKSDB_LIBRARY_API void rocksdb_close(rocksdb_t* db); -extern ROCKSDB_LIBRARY_API void rocksdb_put( - rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, - size_t keylen, const char* val, size_t vallen, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_put_cf( - rocksdb_t* db, const rocksdb_writeoptions_t* options, - rocksdb_column_family_handle_t* column_family, const char* key, - size_t keylen, const char* val, size_t vallen, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_delete( - rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, - size_t keylen, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_delete_cf( - rocksdb_t* db, const rocksdb_writeoptions_t* options, - rocksdb_column_family_handle_t* column_family, const char* key, - size_t keylen, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_delete_range_cf( - rocksdb_t* db, const rocksdb_writeoptions_t* options, - rocksdb_column_family_handle_t* column_family, const char* start_key, - size_t start_key_len, const char* end_key, size_t end_key_len, - char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_merge( - rocksdb_t* db, const rocksdb_writeoptions_t* options, const char* key, - size_t keylen, const char* val, size_t vallen, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_merge_cf( - rocksdb_t* db, const rocksdb_writeoptions_t* options, - rocksdb_column_family_handle_t* column_family, const char* key, - size_t keylen, const char* val, size_t vallen, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_write( - rocksdb_t* db, const rocksdb_writeoptions_t* options, - rocksdb_writebatch_t* batch, char** errptr); - /* Returns NULL if not found. A malloc()ed array otherwise. Stores the length of the array in *vallen. */ extern ROCKSDB_LIBRARY_API char* rocksdb_get( @@ -702,6 +746,10 @@ extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* rocksdb_create_iterator( extern ROCKSDB_LIBRARY_API rocksdb_wal_iterator_t* rocksdb_get_updates_since( rocksdb_t* db, uint64_t seq_number, const rocksdb_wal_readoptions_t* options, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_wal_files_t* rocksdb_get_sorted_wal_files( + rocksdb_t* db, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_wal_file_t* rocksdb_get_current_wal_file( + rocksdb_t* db, char** errptr); extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* rocksdb_create_iterator_cf( rocksdb_t* db, const rocksdb_readoptions_t* options, @@ -764,6 +812,23 @@ extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_cf_with_flags( const size_t* range_limit_key_len, uint8_t include_flags, uint64_t* sizes, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_with_options( + rocksdb_t* db, const rocksdb_size_approximation_options_t* options, + int num_ranges, const char* const* range_start_key, + const size_t* range_start_key_len, const char* const* range_limit_key, + const size_t* range_limit_key_len, uint64_t* sizes, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_cf_with_options( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const rocksdb_size_approximation_options_t* options, int num_ranges, + const char* const* range_start_key, const size_t* range_start_key_len, + const char* const* range_limit_key, const size_t* range_limit_key_len, + uint64_t* sizes, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_size_approximation_options_t* +rocksdb_size_approximation_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_size_approximation_options_destroy( + rocksdb_size_approximation_options_t* options); + extern ROCKSDB_LIBRARY_API void rocksdb_compact_range(rocksdb_t* db, const char* start_key, size_t start_key_len, @@ -793,39 +858,34 @@ extern ROCKSDB_LIBRARY_API void rocksdb_compact_range_cf_opt( rocksdb_compactoptions_t* opt, const char* start_key, size_t start_key_len, const char* limit_key, size_t limit_key_len); +extern ROCKSDB_LIBRARY_API void rocksdb_compact_files( + rocksdb_t* db, const rocksdb_compaction_options_t* options, + const char* const* input_file_names, size_t num_input_file_names, + int output_level, int output_path_id, char*** output_file_names, + size_t* num_output_file_names, + rocksdb_compactionjobinfo_t* compaction_job_info, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_compact_files_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const rocksdb_compaction_options_t* options, + const char* const* input_file_names, size_t num_input_file_names, + int output_level, int output_path_id, char*** output_file_names, + size_t* num_output_file_names, + rocksdb_compactionjobinfo_t* compaction_job_info, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_compact_files_output_file_names_destroy( + char** output_file_names, size_t num_output_file_names); + extern ROCKSDB_LIBRARY_API const rocksdb_livefiles_t* rocksdb_livefiles( rocksdb_t* db); -extern ROCKSDB_LIBRARY_API void rocksdb_flush( - rocksdb_t* db, const rocksdb_flushoptions_t* options, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_flush_cf( - rocksdb_t* db, const rocksdb_flushoptions_t* options, - rocksdb_column_family_handle_t* column_family, char** errptr); - extern ROCKSDB_LIBRARY_API void rocksdb_flush_cfs( rocksdb_t* db, const rocksdb_flushoptions_t* options, rocksdb_column_family_handle_t** column_family, int num_column_families, char** errptr); -extern ROCKSDB_LIBRARY_API void rocksdb_flush_wal(rocksdb_t* db, - unsigned char sync, - char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_disable_file_deletions(rocksdb_t* db, - char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_enable_file_deletions(rocksdb_t* db, - char** errptr); - /* Management operations */ -extern ROCKSDB_LIBRARY_API void rocksdb_destroy_db( - const rocksdb_options_t* options, const char* name, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_repair_db( - const rocksdb_options_t* options, const char* name, char** errptr); - /* Iterator */ extern ROCKSDB_LIBRARY_API void rocksdb_iter_destroy(rocksdb_iterator_t*); @@ -871,10 +931,41 @@ extern ROCKSDB_LIBRARY_API void rocksdb_wal_iter_status( const rocksdb_wal_iterator_t* iter, char** errptr); extern ROCKSDB_LIBRARY_API rocksdb_writebatch_t* rocksdb_wal_iter_get_batch( const rocksdb_wal_iterator_t* iter, uint64_t* seq); +enum { + rocksdb_wal_file_type_archived_log = 0, + rocksdb_wal_file_type_alive_log = 1, +}; extern ROCKSDB_LIBRARY_API uint64_t rocksdb_get_latest_sequence_number(rocksdb_t* db); extern ROCKSDB_LIBRARY_API void rocksdb_wal_iter_destroy( const rocksdb_wal_iterator_t* iter); +extern ROCKSDB_LIBRARY_API rocksdb_wal_readoptions_t* +rocksdb_wal_readoptions_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_wal_readoptions_destroy( + rocksdb_wal_readoptions_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_wal_readoptions_set_verify_checksums( + rocksdb_wal_readoptions_t* options, unsigned char verify_checksums); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_wal_readoptions_get_verify_checksums( + rocksdb_wal_readoptions_t* options); +extern ROCKSDB_LIBRARY_API const char* rocksdb_wal_file_path_name( + const rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_wal_file_log_number(const rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API int rocksdb_wal_file_type( + const rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_wal_file_start_sequence(const rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_wal_file_size_file_bytes(const rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API void rocksdb_wal_file_destroy( + rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_wal_files_count(const rocksdb_wal_files_t* files); +extern ROCKSDB_LIBRARY_API const rocksdb_wal_file_t* +rocksdb_wal_files_get_wal_file(const rocksdb_wal_files_t* files, size_t index); +extern ROCKSDB_LIBRARY_API void rocksdb_wal_files_destroy( + rocksdb_wal_files_t* files); /* Write batch */ @@ -888,16 +979,56 @@ rocksdb_writebatch_create_with_params(size_t reserved_bytes, size_t max_bytes, size_t default_cf_ts_sz); extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_destroy( rocksdb_writebatch_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_clear(rocksdb_writebatch_t*); -extern ROCKSDB_LIBRARY_API int rocksdb_writebatch_count(rocksdb_writebatch_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put(rocksdb_writebatch_t*, +// BEGIN generated: c_generated_writebatch_subset.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'WriteBatch' +// --header-out +// c_api_gen/c_generated_writebatch_subset.h.inc +// --source-out +// c_api_gen/c_generated_writebatch_subset.cc.inc + +/* WriteBatch */ + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_clear( + rocksdb_writebatch_t* b); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put(rocksdb_writebatch_t* b, const char* key, size_t klen, const char* val, size_t vlen); + extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_cf( - rocksdb_writebatch_t*, rocksdb_column_family_handle_t* column_family, + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, const char* val, size_t vlen); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete( + rocksdb_writebatch_t* b, const char* key, size_t klen); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_log_data( + rocksdb_writebatch_t* b, const char* blob, size_t len); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_set_save_point( + rocksdb_writebatch_t* b); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_rollback_to_save_point( + rocksdb_writebatch_t* b, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_pop_save_point( + rocksdb_writebatch_t* b, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_verify_checksum( + rocksdb_writebatch_t* b, char** errptr); +// END generated: c_generated_writebatch_subset.h.inc +extern ROCKSDB_LIBRARY_API int rocksdb_writebatch_count(rocksdb_writebatch_t*); extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_cf_with_ts( rocksdb_writebatch_t*, rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, const char* ts, size_t tslen, const char* val, @@ -928,9 +1059,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_mergev_cf( int num_keys, const char* const* keys_list, const size_t* keys_list_sizes, int num_values, const char* const* values_list, const size_t* values_list_sizes); -extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete(rocksdb_writebatch_t*, - const char* key, - size_t klen); extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_singledelete( rocksdb_writebatch_t* b, const char* key, size_t klen); extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_cf( @@ -967,8 +1095,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_rangev_cf( int num_keys, const char* const* start_keys_list, const size_t* start_keys_list_sizes, const char* const* end_keys_list, const size_t* end_keys_list_sizes); -extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_log_data( - rocksdb_writebatch_t*, const char* blob, size_t len); extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_iterate( rocksdb_writebatch_t*, void* state, void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen), @@ -995,12 +1121,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_iterate_cf_ld( void (*log_data)(void*, const char* blob, size_t blob_len)); extern ROCKSDB_LIBRARY_API const char* rocksdb_writebatch_data( rocksdb_writebatch_t*, size_t* size); -extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_set_save_point( - rocksdb_writebatch_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_rollback_to_save_point( - rocksdb_writebatch_t*, char** errptr); -extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_pop_save_point( - rocksdb_writebatch_t*, char** errptr); extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_update_timestamps( rocksdb_writebatch_t* wb, const char* ts, size_t tslen, void* state, size_t (*get_ts_size)(void*, uint32_t), char** errptr); @@ -1011,8 +1131,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create(size_t reserved_bytes, unsigned char overwrite_keys); extern ROCKSDB_LIBRARY_API rocksdb_writebatch_wi_t* -rocksdb_writebatch_wi_create_from(const char* rep, size_t size); -extern ROCKSDB_LIBRARY_API rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create_with_params( rocksdb_comparator_t* backup_index_comparator, size_t reserved_bytes, unsigned char overwrite_key, size_t max_bytes, @@ -1177,93 +1295,72 @@ extern ROCKSDB_LIBRARY_API rocksdb_block_based_table_options_t* rocksdb_block_based_options_create(void); extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_destroy( rocksdb_block_based_table_options_t* options); -extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_checksum( - rocksdb_block_based_table_options_t*, char); -extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_block_size( - rocksdb_block_based_table_options_t* options, size_t block_size); +// BEGIN generated: c_generated_block_based_options_subset.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'BlockBasedOptions simple' +// --header-out +// c_api_gen/c_generated_block_based_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_block_based_options_subset.cc.inc + +/* BlockBasedOptions simple */ + extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_block_size_deviation( - rocksdb_block_based_table_options_t* options, int block_size_deviation); +rocksdb_block_based_options_set_data_block_hash_ratio( + rocksdb_block_based_table_options_t* options, double v); + extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_block_restart_interval( - rocksdb_block_based_table_options_t* options, int block_restart_interval); +rocksdb_block_based_options_set_top_level_index_pinning_tier( + rocksdb_block_based_table_options_t* options, int v); + extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_index_block_restart_interval( - rocksdb_block_based_table_options_t* options, - int index_block_restart_interval); +rocksdb_block_based_options_set_partition_pinning_tier( + rocksdb_block_based_table_options_t* options, int v); + extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_metadata_block_size( - rocksdb_block_based_table_options_t* options, uint64_t metadata_block_size); -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_partition_filters( - rocksdb_block_based_table_options_t* options, - unsigned char partition_filters); -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_optimize_filters_for_memory( - rocksdb_block_based_table_options_t* options, - unsigned char optimize_filters_for_memory); -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_use_delta_encoding( - rocksdb_block_based_table_options_t* options, - unsigned char use_delta_encoding); +rocksdb_block_based_options_set_unpartitioned_pinning_tier( + rocksdb_block_based_table_options_t* options, int v); +// END generated: c_generated_block_based_options_subset.h.inc extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_filter_policy( rocksdb_block_based_table_options_t* options, rocksdb_filterpolicy_t* filter_policy); -extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_no_block_cache( - rocksdb_block_based_table_options_t* options, unsigned char no_block_cache); extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_block_cache( rocksdb_block_based_table_options_t* options, rocksdb_cache_t* block_cache); extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_whole_key_filtering( - rocksdb_block_based_table_options_t*, unsigned char); -extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_format_version( - rocksdb_block_based_table_options_t*, int); +rocksdb_block_based_options_set_user_defined_index_factory_from_string( + rocksdb_block_based_table_options_t* options, const char* value, + size_t value_len, char** errptr); extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_separate_key_value_in_data_block( - rocksdb_block_based_table_options_t*, unsigned char); +rocksdb_block_based_options_clear_user_defined_index_factory( + rocksdb_block_based_table_options_t* options); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_block_based_options_get_user_defined_index_factory_name( + const rocksdb_block_based_table_options_t* options, size_t* name_len); enum { rocksdb_block_based_table_index_type_binary_search = 0, rocksdb_block_based_table_index_type_hash_search = 1, rocksdb_block_based_table_index_type_two_level_index_search = 2, }; -extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_index_type( - rocksdb_block_based_table_options_t*, int); // uses one of the above enums enum { rocksdb_block_based_table_data_block_index_type_binary_search = 0, rocksdb_block_based_table_data_block_index_type_binary_search_and_hash = 1, }; -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_data_block_index_type( - rocksdb_block_based_table_options_t*, int); // uses one of the above enums enum { rocksdb_block_based_table_index_block_search_type_binary = 0, rocksdb_block_based_table_index_block_search_type_interpolation = 1, rocksdb_block_based_table_index_block_search_type_auto = 2, }; -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_index_block_search_type( - rocksdb_block_based_table_options_t*, int); // uses one of the above enums -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_uniform_cv_threshold( - rocksdb_block_based_table_options_t*, double); -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_data_block_hash_ratio( - rocksdb_block_based_table_options_t* options, double v); // rocksdb_block_based_options_set_hash_index_allow_collision() // is removed since BlockBasedTableOptions.hash_index_allow_collision() // is removed -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_cache_index_and_filter_blocks( - rocksdb_block_based_table_options_t*, unsigned char); -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority( - rocksdb_block_based_table_options_t*, unsigned char); -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache( - rocksdb_block_based_table_options_t*, unsigned char); -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_pin_top_level_index_and_filter( - rocksdb_block_based_table_options_t*, unsigned char); extern ROCKSDB_LIBRARY_API void rocksdb_options_set_block_based_table_factory( rocksdb_options_t* opt, rocksdb_block_based_table_options_t* table_options); enum { @@ -1272,121 +1369,697 @@ enum { rocksdb_block_based_k_flush_and_similar_pinning_tier = 2, rocksdb_block_based_k_all_pinning_tier = 3, }; -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_top_level_index_pinning_tier( - rocksdb_block_based_table_options_t*, int); -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_partition_pinning_tier( - rocksdb_block_based_table_options_t*, int); -extern ROCKSDB_LIBRARY_API void -rocksdb_block_based_options_set_unpartitioned_pinning_tier( - rocksdb_block_based_table_options_t*, int); -extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_block_align( - rocksdb_block_based_table_options_t*, unsigned char); extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_buffer_manager( rocksdb_options_t* opt, rocksdb_write_buffer_manager_t* wbm); extern ROCKSDB_LIBRARY_API void rocksdb_options_set_sst_file_manager( rocksdb_options_t* opt, rocksdb_sst_file_manager_t* sfm); /* Flush job info */ +// BEGIN generated: c_generated_jobinfo_auto.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/listener.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered JobInfo metadata simple + +/* FlushJobInfo */ + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_flushjobinfo_cf_id(const rocksdb_flushjobinfo_t* info); extern ROCKSDB_LIBRARY_API const char* rocksdb_flushjobinfo_cf_name( - const rocksdb_flushjobinfo_t*, size_t*); + const rocksdb_flushjobinfo_t* info, size_t* size); + extern ROCKSDB_LIBRARY_API const char* rocksdb_flushjobinfo_file_path( - const rocksdb_flushjobinfo_t*, size_t*); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_flushjobinfo_triggered_writes_slowdown(const rocksdb_flushjobinfo_t*); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_flushjobinfo_triggered_writes_stop(const rocksdb_flushjobinfo_t*); + const rocksdb_flushjobinfo_t* info, size_t* size); + extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_flushjobinfo_largest_seqno(const rocksdb_flushjobinfo_t*); +rocksdb_flushjobinfo_file_number(const rocksdb_flushjobinfo_t* info); + extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_flushjobinfo_smallest_seqno(const rocksdb_flushjobinfo_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_reset_status( - rocksdb_status_ptr_t* status_ptr); +rocksdb_flushjobinfo_oldest_blob_file_number( + const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_flushjobinfo_thread_id(const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_flushjobinfo_job_id( + const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_flushjobinfo_triggered_writes_slowdown( + const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_flushjobinfo_triggered_writes_stop(const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_flushjobinfo_smallest_seqno(const rocksdb_flushjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_flushjobinfo_largest_seqno(const rocksdb_flushjobinfo_t* info); + extern ROCKSDB_LIBRARY_API uint32_t rocksdb_flushjobinfo_flush_reason(const rocksdb_flushjobinfo_t* info); -extern ROCKSDB_LIBRARY_API void rocksdb_status_ptr_get_error( - rocksdb_status_ptr_t* status, char** errptr); -/* Compaction job info */ +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_flushjobinfo_blob_compression_type(const rocksdb_flushjobinfo_t* info); + +/* CompactionJobInfo */ + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_compactionjobinfo_cf_id(const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_compactionjobinfo_cf_name( + const rocksdb_compactionjobinfo_t* info, size_t* size); + extern ROCKSDB_LIBRARY_API void rocksdb_compactionjobinfo_status( const rocksdb_compactionjobinfo_t* info, char** errptr); -extern ROCKSDB_LIBRARY_API const char* rocksdb_compactionjobinfo_cf_name( - const rocksdb_compactionjobinfo_t*, size_t*); -extern ROCKSDB_LIBRARY_API size_t -rocksdb_compactionjobinfo_input_files_count(const rocksdb_compactionjobinfo_t*); -extern ROCKSDB_LIBRARY_API const char* rocksdb_compactionjobinfo_input_file_at( - const rocksdb_compactionjobinfo_t*, size_t pos, size_t*); -extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_output_files_count( - const rocksdb_compactionjobinfo_t*); -extern ROCKSDB_LIBRARY_API const char* rocksdb_compactionjobinfo_output_file_at( - const rocksdb_compactionjobinfo_t*, size_t pos, size_t*); + extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_compactionjobinfo_elapsed_micros(const rocksdb_compactionjobinfo_t*); -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_compactionjobinfo_num_corrupt_keys(const rocksdb_compactionjobinfo_t*); -extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_base_input_level( - const rocksdb_compactionjobinfo_t*); -extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_output_level( - const rocksdb_compactionjobinfo_t*); -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_compactionjobinfo_input_records(const rocksdb_compactionjobinfo_t*); -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_compactionjobinfo_output_records(const rocksdb_compactionjobinfo_t*); -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_compactionjobinfo_total_input_bytes(const rocksdb_compactionjobinfo_t*); -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_compactionjobinfo_total_output_bytes( - const rocksdb_compactionjobinfo_t*); -extern ROCKSDB_LIBRARY_API uint32_t rocksdb_compactionjobinfo_compaction_reason( - const rocksdb_compactionjobinfo_t* info); -extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_num_input_files( - const rocksdb_compactionjobinfo_t* info); -extern ROCKSDB_LIBRARY_API size_t -rocksdb_compactionjobinfo_num_input_files_at_output_level( +rocksdb_compactionjobinfo_thread_id(const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_job_id( const rocksdb_compactionjobinfo_t* info); -/* Subcompaction job info */ -extern ROCKSDB_LIBRARY_API void rocksdb_subcompactionjobinfo_status( - const rocksdb_subcompactionjobinfo_t*, char**); +extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_num_l0_files( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_base_input_level( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_compactionjobinfo_output_level( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t rocksdb_compactionjobinfo_compaction_reason( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_compactionjobinfo_compression(const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_compactionjobinfo_blob_compression_type( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_compactionjobinfo_aborted( + const rocksdb_compactionjobinfo_t* info); + +/* SubcompactionJobInfo */ + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_subcompactionjobinfo_cf_id(const rocksdb_subcompactionjobinfo_t* info); + extern ROCKSDB_LIBRARY_API const char* rocksdb_subcompactionjobinfo_cf_name( - const rocksdb_subcompactionjobinfo_t*, size_t*); -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_subcompactionjobinfo_thread_id(const rocksdb_subcompactionjobinfo_t*); + const rocksdb_subcompactionjobinfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API void rocksdb_subcompactionjobinfo_status( + const rocksdb_subcompactionjobinfo_t* info, char** errptr); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_subcompactionjobinfo_thread_id( + const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_subcompactionjobinfo_job_id( + const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int +rocksdb_subcompactionjobinfo_subcompaction_job_id( + const rocksdb_subcompactionjobinfo_t* info); + extern ROCKSDB_LIBRARY_API int rocksdb_subcompactionjobinfo_base_input_level( - const rocksdb_subcompactionjobinfo_t*); + const rocksdb_subcompactionjobinfo_t* info); + extern ROCKSDB_LIBRARY_API int rocksdb_subcompactionjobinfo_output_level( - const rocksdb_subcompactionjobinfo_t*); + const rocksdb_subcompactionjobinfo_t* info); + extern ROCKSDB_LIBRARY_API uint32_t rocksdb_subcompactionjobinfo_compaction_reason( const rocksdb_subcompactionjobinfo_t* info); -/* External file ingestion info */ +extern ROCKSDB_LIBRARY_API uint32_t rocksdb_subcompactionjobinfo_compression( + const rocksdb_subcompactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_subcompactionjobinfo_blob_compression_type( + const rocksdb_subcompactionjobinfo_t* info); + +/* ExternalFileIngestionInfo */ + extern ROCKSDB_LIBRARY_API const char* rocksdb_externalfileingestioninfo_cf_name( - const rocksdb_externalfileingestioninfo_t*, size_t*); + const rocksdb_externalfileingestioninfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_externalfileingestioninfo_external_file_path( + const rocksdb_externalfileingestioninfo_t* info, size_t* size); + extern ROCKSDB_LIBRARY_API const char* rocksdb_externalfileingestioninfo_internal_file_path( - const rocksdb_externalfileingestioninfo_t*, size_t*); + const rocksdb_externalfileingestioninfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_externalfileingestioninfo_global_seqno( + const rocksdb_externalfileingestioninfo_t* info); + +/* MemTableInfo */ -/* External write stall info */ -extern ROCKSDB_LIBRARY_API const char* rocksdb_writestallinfo_cf_name( - const rocksdb_writestallinfo_t*, size_t*); -extern ROCKSDB_LIBRARY_API const rocksdb_writestallcondition_t* -rocksdb_writestallinfo_cur(const rocksdb_writestallinfo_t*); -extern ROCKSDB_LIBRARY_API const rocksdb_writestallcondition_t* -rocksdb_writestallinfo_prev(const rocksdb_writestallinfo_t*); extern ROCKSDB_LIBRARY_API const char* rocksdb_memtableinfo_cf_name( - const rocksdb_memtableinfo_t*, size_t*); + const rocksdb_memtableinfo_t* info, size_t* size); + extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_memtableinfo_first_seqno(const rocksdb_memtableinfo_t*); +rocksdb_memtableinfo_first_seqno(const rocksdb_memtableinfo_t* info); + extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_memtableinfo_earliest_seqno(const rocksdb_memtableinfo_t*); +rocksdb_memtableinfo_earliest_seqno(const rocksdb_memtableinfo_t* info); + extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_memtableinfo_num_entries(const rocksdb_memtableinfo_t*); +rocksdb_memtableinfo_num_entries(const rocksdb_memtableinfo_t* info); + extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_memtableinfo_num_deletes(const rocksdb_memtableinfo_t*); +rocksdb_memtableinfo_num_deletes(const rocksdb_memtableinfo_t* info); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_memtableinfo_newest_udt( + const rocksdb_memtableinfo_t* info, size_t* size); +// END generated: c_generated_jobinfo_auto.h.inc +// BEGIN generated: c_generated_jobinfo_metadata_subset.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'JobInfo metadata simple' +// --header-out +// c_api_gen/c_generated_jobinfo_metadata_subset.h.inc +// --source-out +// c_api_gen/c_generated_jobinfo_metadata_subset.cc.inc + +/* JobInfo metadata simple */ + +extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_input_files_count( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_output_files_count( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_elapsed_micros( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_num_corrupt_keys( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_input_records( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_output_records( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compactionjobinfo_total_input_bytes( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compactionjobinfo_total_output_bytes( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_compactionjobinfo_num_input_files( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_num_input_files_at_output_level( + const rocksdb_compactionjobinfo_t* info); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_writestallinfo_cf_name( + const rocksdb_writestallinfo_t* info, size_t* size); + +extern ROCKSDB_LIBRARY_API const rocksdb_writestallcondition_t* +rocksdb_writestallinfo_cur(const rocksdb_writestallinfo_t* info); + +extern ROCKSDB_LIBRARY_API const rocksdb_writestallcondition_t* +rocksdb_writestallinfo_prev(const rocksdb_writestallinfo_t* info); +// END generated: c_generated_jobinfo_metadata_subset.h.inc +// BEGIN generated: c_generated_metadata_structs_auto.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/compaction_job_stats.h +// - include/rocksdb/listener.h +// - include/rocksdb/table_properties.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered metadata view structs simple + +/* TableProperties */ + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_orig_file_number( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_data_size(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_uncompressed_data_size( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_index_size(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_index_partitions( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_top_level_index_size( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_index_key_is_user_key( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_index_value_is_delta_encoded( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_udi_is_primary_index( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_filter_size(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_raw_key_size(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_raw_value_size( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_data_blocks( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_num_data_blocks_compression_rejected( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_num_data_blocks_compression_bypassed( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_uniform_blocks( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_num_entries(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_filter_entries( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_num_deletions(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_num_merge_operands( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_num_range_deletions( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_format_version( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_fixed_key_len(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_column_family_id( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_creation_time(const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_oldest_key_time( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_newest_key_time( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_file_creation_time( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_slow_compression_estimated_data_size( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_fast_compression_estimated_data_size( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_external_sst_file_global_seqno_offset( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_tail_start_offset( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_user_defined_timestamps_persisted( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_key_largest_seqno( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_table_properties_key_smallest_seqno( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_data_block_restart_interval( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_index_block_restart_interval( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_table_properties_separate_key_value_in_data_block( + const rocksdb_table_properties_t* props); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_db_id( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_db_session_id( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_db_host_id( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_column_family_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_filter_policy_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_table_properties_comparator_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_merge_operator_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_prefix_extractor_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_property_collectors_names( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_compression_name( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_compression_options( + const rocksdb_table_properties_t* props, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_seqno_to_time_mapping( + const rocksdb_table_properties_t* props, size_t* size); + +/* CompactionJobStats */ + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_job_stats_elapsed_micros( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_job_stats_cpu_micros( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compaction_job_stats_has_accurate_num_input_records( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_input_records( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_job_stats_num_blobs_read( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_compaction_job_stats_num_input_files( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compaction_job_stats_num_input_files_trivially_moved( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compaction_job_stats_num_input_files_at_output_level( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compaction_job_stats_num_filtered_input_files( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compaction_job_stats_num_filtered_input_files_at_output_level( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_output_records( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_compaction_job_stats_num_output_files( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compaction_job_stats_num_output_files_blob( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compaction_job_stats_is_full_compaction( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compaction_job_stats_is_manual_compaction( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compaction_job_stats_is_remote_compaction( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_input_bytes( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_blob_bytes_read( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_output_bytes( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_output_bytes_blob( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_skipped_input_bytes( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_records_replaced( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_input_raw_key_bytes( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_total_input_raw_value_bytes( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_input_deletion_records( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_expired_deletion_records( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_corrupt_keys( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_file_write_nanos( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_file_range_sync_nanos( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_file_fsync_nanos( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_file_prepare_write_nanos( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compaction_job_stats_smallest_output_key_prefix( + const rocksdb_compaction_job_stats_t* stats, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compaction_job_stats_largest_output_key_prefix( + const rocksdb_compaction_job_stats_t* stats, size_t* size); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_single_del_fallthru( + const rocksdb_compaction_job_stats_t* stats); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_job_stats_num_single_del_mismatch( + const rocksdb_compaction_job_stats_t* stats); + +/* CompactionFileInfo */ + +extern ROCKSDB_LIBRARY_API int rocksdb_compaction_file_info_level( + const rocksdb_compaction_file_info_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_compaction_file_info_file_number( + const rocksdb_compaction_file_info_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_file_info_oldest_blob_file_number( + const rocksdb_compaction_file_info_t* info); + +/* BlobFileAdditionInfo */ + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_blob_file_addition_info_total_blob_count( + const rocksdb_blob_file_addition_info_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_blob_file_addition_info_total_blob_bytes( + const rocksdb_blob_file_addition_info_t* info); + +/* BlobFileGarbageInfo */ + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_blob_file_garbage_info_garbage_blob_count( + const rocksdb_blob_file_garbage_info_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_blob_file_garbage_info_garbage_blob_bytes( + const rocksdb_blob_file_garbage_info_t* info); +// END generated: c_generated_metadata_structs_auto.h.inc +extern ROCKSDB_LIBRARY_API rocksdb_compactionjobinfo_t* +rocksdb_compactionjobinfo_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_compactionjobinfo_destroy( + rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API void rocksdb_reset_status( + rocksdb_status_ptr_t* status_ptr); +extern ROCKSDB_LIBRARY_API void rocksdb_status_ptr_get_error( + rocksdb_status_ptr_t* status, char** errptr); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_table_properties_has_key_largest_seqno( + const rocksdb_table_properties_t* props); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_table_properties_has_key_smallest_seqno( + const rocksdb_table_properties_t* props); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_table_properties_user_collected_properties_count( + const rocksdb_table_properties_t* props); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_user_collected_properties_key_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* key_len); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_user_collected_properties_value_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* value_len); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_table_properties_readable_properties_count( + const rocksdb_table_properties_t* props); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_readable_properties_key_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* key_len); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_readable_properties_value_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* value_len); +extern ROCKSDB_LIBRARY_API const rocksdb_table_properties_t* +rocksdb_flushjobinfo_table_properties(const rocksdb_flushjobinfo_t* info); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_flushjobinfo_blob_file_addition_infos_count( + const rocksdb_flushjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_blob_file_addition_info_t* +rocksdb_flushjobinfo_blob_file_addition_info_at( + const rocksdb_flushjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API const char* rocksdb_compactionjobinfo_input_file_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size); +extern ROCKSDB_LIBRARY_API const char* rocksdb_compactionjobinfo_output_file_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size); +extern ROCKSDB_LIBRARY_API const rocksdb_compaction_job_stats_t* +rocksdb_compactionjobinfo_stats(const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_input_file_infos_count( + const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_compaction_file_info_t* +rocksdb_compactionjobinfo_input_file_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_output_file_infos_count( + const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_compaction_file_info_t* +rocksdb_compactionjobinfo_output_file_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_table_properties_count( + const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compactionjobinfo_table_properties_key_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* key_len); +extern ROCKSDB_LIBRARY_API const rocksdb_table_properties_t* +rocksdb_compactionjobinfo_table_properties_value_at( + const rocksdb_compactionjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API const rocksdb_table_properties_t* +rocksdb_compactionjobinfo_table_properties_for_file( + const rocksdb_compactionjobinfo_t* info, const char* file_name, + size_t file_name_len); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_blob_file_addition_infos_count( + const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_blob_file_addition_info_t* +rocksdb_compactionjobinfo_blob_file_addition_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_blob_file_garbage_infos_count( + const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_blob_file_garbage_info_t* +rocksdb_compactionjobinfo_blob_file_garbage_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API const rocksdb_compaction_job_stats_t* +rocksdb_subcompactionjobinfo_stats(const rocksdb_subcompactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_table_properties_t* +rocksdb_externalfileingestioninfo_table_properties( + const rocksdb_externalfileingestioninfo_t* info); /* Event listener */ @@ -1432,17 +2105,27 @@ extern ROCKSDB_LIBRARY_API rocksdb_cuckoo_table_options_t* rocksdb_cuckoo_options_create(void); extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_destroy( rocksdb_cuckoo_table_options_t* options); +// BEGIN generated: c_generated_cuckoo_options_subset.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'CuckooOptions simple' +// --header-out +// c_api_gen/c_generated_cuckoo_options_subset.h.inc +// --source-out +// c_api_gen/c_generated_cuckoo_options_subset.cc.inc + +/* CuckooOptions simple */ + extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_hash_ratio( rocksdb_cuckoo_table_options_t* options, double v); -extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_max_search_depth( - rocksdb_cuckoo_table_options_t* options, uint32_t v); -extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_cuckoo_block_size( - rocksdb_cuckoo_table_options_t* options, uint32_t v); -extern ROCKSDB_LIBRARY_API void -rocksdb_cuckoo_options_set_identity_as_first_hash( - rocksdb_cuckoo_table_options_t* options, unsigned char v); -extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_use_module_hash( - rocksdb_cuckoo_table_options_t* options, unsigned char v); +// END generated: c_generated_cuckoo_options_subset.h.inc extern ROCKSDB_LIBRARY_API void rocksdb_options_set_cuckoo_table_factory( rocksdb_options_t* opt, rocksdb_cuckoo_table_options_t* table_options); @@ -1489,6 +2172,10 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_comparator( rocksdb_options_t*, rocksdb_comparator_t*); extern ROCKSDB_LIBRARY_API void rocksdb_options_set_merge_operator( rocksdb_options_t*, rocksdb_mergeoperator_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_wal_filter( + rocksdb_options_t*, rocksdb_walfilter_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_clear_wal_filter( + rocksdb_options_t*); extern ROCKSDB_LIBRARY_API void rocksdb_options_set_uint64add_merge_operator( rocksdb_options_t*); extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compression_per_level( @@ -1545,6 +2232,33 @@ extern ROCKSDB_LIBRARY_API void rocksdb_file_checksum_gen_factory_destroy( rocksdb_file_checksum_gen_factory_t* factory); extern ROCKSDB_LIBRARY_API void rocksdb_options_set_file_checksum_gen_factory( rocksdb_options_t*, rocksdb_file_checksum_gen_factory_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_checksum_handoff_file_types_clear(rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void rocksdb_options_checksum_handoff_file_types_add( + rocksdb_options_t* opt, int file_type); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_checksum_handoff_file_types_remove(rocksdb_options_t* opt, + int file_type); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_checksum_handoff_file_types_contains(rocksdb_options_t* opt, + int file_type); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_checksum_handoff_file_types_count(rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_calculate_sst_write_lifetime_hint_set_clear( + rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_calculate_sst_write_lifetime_hint_set_add( + rocksdb_options_t* opt, int compaction_style); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_calculate_sst_write_lifetime_hint_set_remove( + rocksdb_options_t* opt, int compaction_style); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_calculate_sst_write_lifetime_hint_set_contains( + rocksdb_options_t* opt, int compaction_style); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_calculate_sst_write_lifetime_hint_set_count( + rocksdb_options_t* opt); /* SST Partitioner Factory */ extern ROCKSDB_LIBRARY_API rocksdb_sst_partitioner_factory_t* @@ -1848,11 +2562,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_recycle_log_file_num( rocksdb_options_t*, size_t); extern ROCKSDB_LIBRARY_API size_t rocksdb_options_get_recycle_log_file_num(rocksdb_options_t*); -// Set/get DBOptions::async_wal_precreate. -extern ROCKSDB_LIBRARY_API void rocksdb_options_set_async_wal_precreate( - rocksdb_options_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_options_get_async_wal_precreate(rocksdb_options_t*); extern ROCKSDB_LIBRARY_API void rocksdb_options_set_soft_pending_compaction_bytes_limit(rocksdb_options_t* opt, size_t v); @@ -1912,11 +2621,6 @@ rocksdb_options_set_use_direct_io_for_flush_and_compaction(rocksdb_options_t*, unsigned char); extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_use_direct_io_for_flush_and_compaction(rocksdb_options_t*); -extern ROCKSDB_LIBRARY_API void -rocksdb_options_set_use_direct_io_for_compaction_reads(rocksdb_options_t*, - unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_options_get_use_direct_io_for_compaction_reads(rocksdb_options_t*); extern ROCKSDB_LIBRARY_API void rocksdb_options_set_is_fd_close_on_exec( rocksdb_options_t*, unsigned char); extern ROCKSDB_LIBRARY_API unsigned char @@ -2021,12 +2725,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_memtable_huge_page_size( extern ROCKSDB_LIBRARY_API size_t rocksdb_options_get_memtable_huge_page_size(rocksdb_options_t*); -extern ROCKSDB_LIBRARY_API void -rocksdb_options_set_memtable_batch_lookup_optimization(rocksdb_options_t*, - unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_options_get_memtable_batch_lookup_optimization(rocksdb_options_t*); - extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_successive_merges( rocksdb_options_t*, size_t); extern ROCKSDB_LIBRARY_API size_t @@ -2284,6 +2982,23 @@ extern ROCKSDB_LIBRARY_API void rocksdb_compactionfilter_set_ignore_snapshots( extern ROCKSDB_LIBRARY_API void rocksdb_compactionfilter_destroy( rocksdb_compactionfilter_t*); +/* WAL Filter */ + +enum { + rocksdb_wal_filter_continue_processing = 0, + rocksdb_wal_filter_ignore_current_record = 1, + rocksdb_wal_filter_stop_replay = 2, + rocksdb_wal_filter_corrupted_record = 3, +}; + +extern ROCKSDB_LIBRARY_API rocksdb_walfilter_t* rocksdb_walfilter_create( + void* state, void (*destructor)(void*), + rocksdb_walfilter_column_family_log_number_map_cb + column_family_log_number_map, + rocksdb_walfilter_log_record_found_cb log_record_found, + const char* (*name)(void*)); +extern ROCKSDB_LIBRARY_API void rocksdb_walfilter_destroy(rocksdb_walfilter_t*); + /* Compaction Filter Context */ extern ROCKSDB_LIBRARY_API unsigned char @@ -2368,82 +3083,211 @@ extern ROCKSDB_LIBRARY_API rocksdb_readoptions_t* rocksdb_readoptions_create( void); extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_destroy( rocksdb_readoptions_t*); +// BEGIN generated: c_generated_readoptions_auto.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/options.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered ReadOptions simple + +/* ReadOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_deadline( + rocksdb_readoptions_t* opt, uint64_t microseconds); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_readoptions_get_deadline(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_io_timeout( + rocksdb_readoptions_t* opt, uint64_t microseconds); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_readoptions_get_io_timeout(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_read_tier( + rocksdb_readoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_readoptions_get_read_tier( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_rate_limiter_priority( + rocksdb_readoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_readoptions_get_rate_limiter_priority( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_value_size_soft_limit( + rocksdb_readoptions_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_readoptions_get_value_size_soft_limit(rocksdb_readoptions_t* opt); + extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_verify_checksums( - rocksdb_readoptions_t*, unsigned char); + rocksdb_readoptions_t* opt, unsigned char v); + extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_readoptions_get_verify_checksums(rocksdb_readoptions_t*); +rocksdb_readoptions_get_verify_checksums(rocksdb_readoptions_t* opt); + extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_fill_cache( - rocksdb_readoptions_t*, unsigned char); + rocksdb_readoptions_t* opt, unsigned char v); + extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_fill_cache( - rocksdb_readoptions_t*); + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_ignore_range_deletions( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_ignore_range_deletions(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_async_io( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_async_io( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_optimize_multiget_for_io(rocksdb_readoptions_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_optimize_multiget_for_io(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_readahead_size( + rocksdb_readoptions_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_max_skippable_internal_keys(rocksdb_readoptions_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_readoptions_get_max_skippable_internal_keys(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_tailing( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_tailing( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_total_order_seek( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_total_order_seek(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_auto_prefix_mode( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_auto_prefix_mode(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_prefix_same_as_start( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_prefix_same_as_start(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_pin_data( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_pin_data( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_adaptive_readahead( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_adaptive_readahead(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_background_purge_on_iterator_cleanup( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_background_purge_on_iterator_cleanup( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_auto_readahead_size( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_auto_readahead_size(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_allow_unprepared_value( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_allow_unprepared_value(rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_auto_refresh_iterator_with_snapshot( + rocksdb_readoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_get_auto_refresh_iterator_with_snapshot( + rocksdb_readoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_io_activity( + rocksdb_readoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_readoptions_get_io_activity( + rocksdb_readoptions_t* opt); +// END generated: c_generated_readoptions_auto.h.inc extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_snapshot( rocksdb_readoptions_t*, const rocksdb_snapshot_t*); extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_iterate_upper_bound( rocksdb_readoptions_t*, const char* key, size_t keylen); extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_iterate_lower_bound( rocksdb_readoptions_t*, const char* key, size_t keylen); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_read_tier( - rocksdb_readoptions_t*, int); -extern ROCKSDB_LIBRARY_API int rocksdb_readoptions_get_read_tier( - rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_tailing( - rocksdb_readoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_tailing( - rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_readahead_size( - rocksdb_readoptions_t*, size_t); -extern ROCKSDB_LIBRARY_API size_t -rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_prefix_same_as_start( - rocksdb_readoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_readoptions_get_prefix_same_as_start(rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_pin_data( - rocksdb_readoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_pin_data( - rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_total_order_seek( - rocksdb_readoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_readoptions_get_total_order_seek(rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void -rocksdb_readoptions_set_max_skippable_internal_keys(rocksdb_readoptions_t*, - uint64_t); -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_readoptions_get_max_skippable_internal_keys(rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void -rocksdb_readoptions_set_background_purge_on_iterator_cleanup( - rocksdb_readoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_readoptions_get_background_purge_on_iterator_cleanup( - rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_ignore_range_deletions( - rocksdb_readoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_readoptions_get_ignore_range_deletions(rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_deadline( - rocksdb_readoptions_t*, uint64_t microseconds); -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_readoptions_get_deadline(rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_io_timeout( - rocksdb_readoptions_t*, uint64_t microseconds); -extern ROCKSDB_LIBRARY_API uint64_t -rocksdb_readoptions_get_io_timeout(rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_async_io( - rocksdb_readoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_async_io( - rocksdb_readoptions_t*); -extern ROCKSDB_LIBRARY_API void -rocksdb_readoptions_set_optimize_multiget_for_io(rocksdb_readoptions_t*, - unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_readoptions_get_optimize_multiget_for_io(rocksdb_readoptions_t*); extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_timestamp( rocksdb_readoptions_t*, const char* ts, size_t tslen); extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_iter_start_ts( rocksdb_readoptions_t*, const char* ts, size_t tslen); -extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_auto_readahead_size( - rocksdb_readoptions_t*, unsigned char); +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_merge_operand_count_threshold(rocksdb_readoptions_t*, + size_t threshold); +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_clear_merge_operand_count_threshold(rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_has_merge_operand_count_threshold(rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_readoptions_get_merge_operand_count_threshold(rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_request_id( + rocksdb_readoptions_t*, const char* request_id, size_t request_id_len); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_clear_request_id( + rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API const char* rocksdb_readoptions_get_request_id( + rocksdb_readoptions_t*, size_t* request_id_len); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_table_filter( + rocksdb_readoptions_t*, void* state, void (*destructor)(void*), + rocksdb_readoptions_table_filter_cb table_filter); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_clear_table_filter( + rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_has_table_filter( + const rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_table_index_factory_from_string(rocksdb_readoptions_t*, + const char* value, + size_t value_len, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_clear_table_index_factory( + rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_readoptions_get_table_index_factory_name(const rocksdb_readoptions_t*, + size_t* name_len); /* Write options */ @@ -2451,37 +3295,22 @@ extern ROCKSDB_LIBRARY_API rocksdb_writeoptions_t* rocksdb_writeoptions_create( void); extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_destroy( rocksdb_writeoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_sync( - rocksdb_writeoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_sync( - rocksdb_writeoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_disable_WAL( - rocksdb_writeoptions_t* opt, int disable); -extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_disable_WAL( - rocksdb_writeoptions_t* opt); -extern ROCKSDB_LIBRARY_API void -rocksdb_writeoptions_set_ignore_missing_column_families(rocksdb_writeoptions_t*, - unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_writeoptions_get_ignore_missing_column_families( - rocksdb_writeoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_no_slowdown( - rocksdb_writeoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_no_slowdown( - rocksdb_writeoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_low_pri( - rocksdb_writeoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_low_pri( - rocksdb_writeoptions_t*); -extern ROCKSDB_LIBRARY_API void -rocksdb_writeoptions_set_memtable_insert_hint_per_batch(rocksdb_writeoptions_t*, - unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char -rocksdb_writeoptions_get_memtable_insert_hint_per_batch( - rocksdb_writeoptions_t*); /* Compact range options */ +extern ROCKSDB_LIBRARY_API rocksdb_compaction_options_t* +rocksdb_compaction_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_compaction_options_destroy( + rocksdb_compaction_options_t*); +extern ROCKSDB_LIBRARY_API unsigned char* +rocksdb_compaction_options_canceled_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_compaction_options_canceled_destroy( + unsigned char* canceled); +extern ROCKSDB_LIBRARY_API void rocksdb_compaction_options_canceled_set( + unsigned char* canceled, unsigned char value); +extern ROCKSDB_LIBRARY_API void rocksdb_compaction_options_set_canceled( + rocksdb_compaction_options_t* options, unsigned char* canceled); + extern ROCKSDB_LIBRARY_API rocksdb_compactoptions_t* rocksdb_compactoptions_create(void); extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_destroy( @@ -2527,10 +3356,12 @@ extern ROCKSDB_LIBRARY_API rocksdb_flushoptions_t* rocksdb_flushoptions_create( void); extern ROCKSDB_LIBRARY_API void rocksdb_flushoptions_destroy( rocksdb_flushoptions_t*); -extern ROCKSDB_LIBRARY_API void rocksdb_flushoptions_set_wait( - rocksdb_flushoptions_t*, unsigned char); -extern ROCKSDB_LIBRARY_API unsigned char rocksdb_flushoptions_get_wait( - rocksdb_flushoptions_t*); +extern ROCKSDB_LIBRARY_API rocksdb_flushwaloptions_t* +rocksdb_flushwaloptions_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_flushwaloptions_destroy( + rocksdb_flushwaloptions_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_flush_wal_with_options( + rocksdb_t* db, const rocksdb_flushwaloptions_t* options, char** errptr); /* Memory allocator */ @@ -2718,9 +3549,94 @@ extern ROCKSDB_LIBRARY_API rocksdb_envoptions_t* rocksdb_envoptions_create( void); extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_destroy( rocksdb_envoptions_t* opt); +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_rate_limiter( + rocksdb_envoptions_t* opt, rocksdb_ratelimiter_t* rate_limiter); extern ROCKSDB_LIBRARY_API void rocksdb_create_dir_if_missing( rocksdb_env_t* env, const char* path, char** errptr); +/* Tracing */ + +extern ROCKSDB_LIBRARY_API rocksdb_trace_options_t* +rocksdb_trace_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_trace_options_destroy( + rocksdb_trace_options_t* options); +extern ROCKSDB_LIBRARY_API rocksdb_trace_reader_t* rocksdb_trace_reader_create( + rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const char* trace_path, char** errptr); +extern ROCKSDB_LIBRARY_API char* rocksdb_trace_reader_read( + rocksdb_trace_reader_t* reader, size_t* size, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_trace_reader_reset( + rocksdb_trace_reader_t* reader, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_trace_reader_close( + rocksdb_trace_reader_t* reader, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_trace_reader_destroy( + rocksdb_trace_reader_t* reader); +extern ROCKSDB_LIBRARY_API rocksdb_replay_options_t* +rocksdb_replay_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_replay_options_destroy( + rocksdb_replay_options_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_replay_options_set_num_threads( + rocksdb_replay_options_t* options, uint32_t num_threads); +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_replay_options_get_num_threads(rocksdb_replay_options_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_replay_options_set_fast_forward( + rocksdb_replay_options_t* options, double fast_forward); +extern ROCKSDB_LIBRARY_API double rocksdb_replay_options_get_fast_forward( + rocksdb_replay_options_t* options); +extern ROCKSDB_LIBRARY_API rocksdb_replayer_t* rocksdb_new_default_replayer( + rocksdb_t* db, rocksdb_column_family_handle_t** column_families, + size_t num_column_families, rocksdb_env_t* env, + const rocksdb_envoptions_t* env_options, const char* trace_path, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_replayer_prepare( + rocksdb_replayer_t* replayer, char** errptr); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_replayer_get_header_timestamp(const rocksdb_replayer_t* replayer); +extern ROCKSDB_LIBRARY_API void rocksdb_replayer_replay( + rocksdb_replayer_t* replayer, const rocksdb_replay_options_t* options, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_replayer_destroy( + rocksdb_replayer_t* replayer); +enum { + rocksdb_trace_filter_none = 0x0, + rocksdb_trace_filter_get = 0x1 << 0, + rocksdb_trace_filter_write = 0x1 << 1, + rocksdb_trace_filter_iterator_seek = 0x1 << 2, + rocksdb_trace_filter_iterator_seek_for_prev = 0x1 << 3, + rocksdb_trace_filter_multi_get = 0x1 << 4, +}; +extern ROCKSDB_LIBRARY_API rocksdb_block_cache_trace_options_t* +rocksdb_block_cache_trace_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_block_cache_trace_options_destroy( + rocksdb_block_cache_trace_options_t* options); +extern ROCKSDB_LIBRARY_API rocksdb_block_cache_trace_writer_options_t* +rocksdb_block_cache_trace_writer_options_create(void); +extern ROCKSDB_LIBRARY_API void +rocksdb_block_cache_trace_writer_options_destroy( + rocksdb_block_cache_trace_writer_options_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_start_trace( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, const char* trace_path, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_end_trace(rocksdb_t* db, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_start_io_trace( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, const char* trace_path, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_end_io_trace(rocksdb_t* db, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_start_block_cache_trace( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, const char* trace_path, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_start_block_cache_trace_with_options( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const rocksdb_block_cache_trace_options_t* options, + const rocksdb_block_cache_trace_writer_options_t* writer_options, + const char* trace_path, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_end_block_cache_trace(rocksdb_t* db, + char** errptr); + /* SstFile */ extern ROCKSDB_LIBRARY_API rocksdb_sstfilewriter_t* @@ -2923,6 +3839,44 @@ rocksdb_livefiles_deletions(const rocksdb_livefiles_t*, int index); extern ROCKSDB_LIBRARY_API void rocksdb_livefiles_destroy( const rocksdb_livefiles_t*); +extern ROCKSDB_LIBRARY_API rocksdb_livefiles_storage_info_options_t* +rocksdb_livefiles_storage_info_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_livefiles_storage_info_options_destroy( + rocksdb_livefiles_storage_info_options_t* options); +extern ROCKSDB_LIBRARY_API rocksdb_livefiles_storage_info_t* +rocksdb_get_livefiles_storage_info( + rocksdb_t* db, const rocksdb_livefiles_storage_info_options_t* options, + char** errptr); +extern ROCKSDB_LIBRARY_API size_t rocksdb_livefiles_storage_info_count( + const rocksdb_livefiles_storage_info_t* info); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_livefiles_storage_info_relative_filename( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API const char* rocksdb_livefiles_storage_info_directory( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_livefiles_storage_info_file_number( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API int rocksdb_livefiles_storage_info_file_type( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_livefiles_storage_info_size( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API int rocksdb_livefiles_storage_info_temperature( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_livefiles_storage_info_file_checksum( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_livefiles_storage_info_file_checksum_func_name( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_livefiles_storage_info_replacement_contents( + const rocksdb_livefiles_storage_info_t* info, size_t index, size_t* size); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_livefiles_storage_info_trim_to_size( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API void rocksdb_livefiles_storage_info_destroy( + rocksdb_livefiles_storage_info_t* info); + extern ROCKSDB_LIBRARY_API rocksdb_livefile_t* rocksdb_livefile_create(void); extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_column_family_name( rocksdb_livefile_t*, const char*); @@ -2971,6 +3925,29 @@ extern ROCKSDB_LIBRARY_API void rocksdb_delete_file_in_range_cf( extern ROCKSDB_LIBRARY_API rocksdb_column_family_metadata_t* rocksdb_get_column_family_metadata(rocksdb_t* db); +extern ROCKSDB_LIBRARY_API rocksdb_column_family_metadata_t* +rocksdb_get_column_family_metadata_with_options( + rocksdb_t* db, const rocksdb_column_family_metadata_options_t* options); + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_metadata_options_t* +rocksdb_column_family_metadata_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_column_family_metadata_options_destroy( + rocksdb_column_family_metadata_options_t* options); +extern ROCKSDB_LIBRARY_API void +rocksdb_column_family_metadata_options_set_start_key( + rocksdb_column_family_metadata_options_t* options, const char* key, + size_t key_len); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_column_family_metadata_options_get_start_key( + const rocksdb_column_family_metadata_options_t* options, size_t* key_len); +extern ROCKSDB_LIBRARY_API void +rocksdb_column_family_metadata_options_set_end_key( + rocksdb_column_family_metadata_options_t* options, const char* key, + size_t key_len); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_column_family_metadata_options_get_end_key( + const rocksdb_column_family_metadata_options_t* options, size_t* key_len); + extern ROCKSDB_LIBRARY_API rocksdb_import_column_family_options_t* rocksdb_import_column_family_options_create(void); @@ -3013,6 +3990,11 @@ extern ROCKSDB_LIBRARY_API rocksdb_column_family_metadata_t* rocksdb_get_column_family_metadata_cf( rocksdb_t* db, rocksdb_column_family_handle_t* column_family); +extern ROCKSDB_LIBRARY_API rocksdb_column_family_metadata_t* +rocksdb_get_column_family_metadata_cf_with_options( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const rocksdb_column_family_metadata_options_t* options); + extern ROCKSDB_LIBRARY_API void rocksdb_column_family_metadata_destroy( rocksdb_column_family_metadata_t* cf_meta); @@ -3176,6 +4158,46 @@ extern ROCKSDB_LIBRARY_API char* rocksdb_transaction_get_name( extern ROCKSDB_LIBRARY_API void rocksdb_transaction_prepare( rocksdb_transaction_t* txn, char** errptr); +// BEGIN generated: c_generated_transaction_subset.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'Transaction' +// --header-out +// c_api_gen/c_generated_transaction_subset.h.inc +// --source-out +// c_api_gen/c_generated_transaction_subset.cc.inc + +/* Transaction */ + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put( + rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val, + size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge( + rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val, + size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete( + rocksdb_transaction_t* txn, const char* key, size_t klen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete_cf( + rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, char** errptr); extern ROCKSDB_LIBRARY_API void rocksdb_transaction_commit( rocksdb_transaction_t* txn, char** errptr); @@ -3183,11 +4205,15 @@ extern ROCKSDB_LIBRARY_API void rocksdb_transaction_commit( extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback( rocksdb_transaction_t* txn, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_log_data( + rocksdb_transaction_t* txn, const char* blob, size_t len); + extern ROCKSDB_LIBRARY_API void rocksdb_transaction_set_savepoint( rocksdb_transaction_t* txn); extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rollback_to_savepoint( rocksdb_transaction_t* txn, char** errptr); +// END generated: c_generated_transaction_subset.h.inc extern ROCKSDB_LIBRARY_API void rocksdb_transaction_destroy( rocksdb_transaction_t* txn); @@ -3315,14 +4341,23 @@ extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_multi_get_cf( size_t num_keys, const char* const* keys_list, const size_t* keys_list_sizes, char** values_list, size_t* values_list_sizes, char** errs); +// BEGIN generated: c_generated_transactiondb_subset.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/generate_c_api.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Source: tools/c_api_gen/spec.json +// ----------------------------------------------------------------------------- -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put( - rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val, - size_t vlen, char** errptr); +// To regenerate this file: +// python3 tools/c_api_gen/generate_c_api.py +// --spec tools/c_api_gen/spec.json --section 'TransactionDB simple' +// --header-out +// c_api_gen/c_generated_transactiondb_subset.h.inc +// --source-out +// c_api_gen/c_generated_transactiondb_subset.cc.inc -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_cf( - rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, - const char* key, size_t klen, const char* val, size_t vlen, char** errptr); +/* TransactionDB simple */ extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_put( rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, @@ -3334,17 +4369,9 @@ extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_put_cf( size_t keylen, const char* val, size_t vallen, char** errptr); extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_write( - rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, + rocksdb_transactiondb_t* db, const rocksdb_writeoptions_t* options, rocksdb_writebatch_t* batch, char** errptr); -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge( - rocksdb_transaction_t* txn, const char* key, size_t klen, const char* val, - size_t vlen, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_merge_cf( - rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, - const char* key, size_t klen, const char* val, size_t vlen, char** errptr); - extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge( rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, const char* key, size_t klen, const char* val, size_t vlen, char** errptr); @@ -3354,16 +4381,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_merge_cf( rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, const char* val, size_t vlen, char** errptr); -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete( - rocksdb_transaction_t* txn, const char* key, size_t klen, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_delete_cf( - rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family, - const char* key, size_t klen, char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_put_log_data( - rocksdb_transaction_t* txn, const char* blob, size_t len); - extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_delete( rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options, const char* key, size_t klen, char** errptr); @@ -3373,6 +4390,18 @@ extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_delete_cf( rocksdb_column_family_handle_t* column_family, const char* key, size_t keylen, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_wal( + rocksdb_transactiondb_t* txn_db, unsigned char sync, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t* column_family, char** errptr); +// END generated: c_generated_transactiondb_subset.h.inc + extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* rocksdb_transaction_create_iterator(rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options); @@ -3394,21 +4423,14 @@ rocksdb_transactiondb_create_iterator_cf( extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_close( rocksdb_transactiondb_t* txn_db); -extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush( - rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, - char** errptr); - -extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_cf( - rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, - rocksdb_column_family_handle_t* column_family, char** errptr); - extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_cfs( rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, rocksdb_column_family_handle_t** column_families, int num_column_families, char** errptr); -extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_wal( - rocksdb_transactiondb_t* txn_db, unsigned char sync, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_wal_with_options( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushwaloptions_t* options, + char** errptr); extern ROCKSDB_LIBRARY_API rocksdb_checkpoint_t* rocksdb_transactiondb_checkpoint_object_create(rocksdb_transactiondb_t* txn_db, @@ -3418,6 +4440,12 @@ extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_t* rocksdb_optimistictransactiondb_open(const rocksdb_options_t* options, const char* name, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open_with_otxn_db_options( + const rocksdb_options_t* options, + const rocksdb_optimistictransactiondb_options_t* otxn_db_options, + const char* name, char** errptr); + extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_t* rocksdb_optimistictransactiondb_open_column_families( const rocksdb_options_t* options, const char* name, int num_column_families, @@ -3425,6 +4453,15 @@ rocksdb_optimistictransactiondb_open_column_families( const rocksdb_options_t* const* column_family_options, rocksdb_column_family_handle_t** column_family_handles, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open_column_families_with_otxn_db_options( + const rocksdb_options_t* options, + const rocksdb_optimistictransactiondb_options_t* otxn_db_options, + const char* name, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr); + extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_optimistictransactiondb_get_base_db( rocksdb_optimistictransactiondb_t* otxn_db); @@ -3453,33 +4490,17 @@ rocksdb_optimistictransactiondb_checkpoint_object_create( /* Transaction Options */ -extern ROCKSDB_LIBRARY_API rocksdb_transactiondb_options_t* -rocksdb_transactiondb_options_create(void); - -extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_destroy( - rocksdb_transactiondb_options_t* opt); - -extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_set_max_num_locks( - rocksdb_transactiondb_options_t* opt, int64_t max_num_locks); - -extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_set_num_stripes( - rocksdb_transactiondb_options_t* opt, size_t num_stripes); - -extern ROCKSDB_LIBRARY_API void -rocksdb_transactiondb_options_set_transaction_lock_timeout( - rocksdb_transactiondb_options_t* opt, int64_t txn_lock_timeout); - -extern ROCKSDB_LIBRARY_API void -rocksdb_transactiondb_options_set_default_lock_timeout( - rocksdb_transactiondb_options_t* opt, int64_t default_lock_timeout); - enum { rocksdb_txndb_write_policy_write_committed = 0, rocksdb_txndb_write_policy_write_prepared = 1, rocksdb_txndb_write_policy_write_unprepared = 2 }; -extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_set_write_policy( - rocksdb_transactiondb_options_t* opt, int write_policy); + +extern ROCKSDB_LIBRARY_API rocksdb_transactiondb_options_t* +rocksdb_transactiondb_options_create(void); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_destroy( + rocksdb_transactiondb_options_t* opt); extern ROCKSDB_LIBRARY_API rocksdb_transaction_options_t* rocksdb_transaction_options_create(void); @@ -3487,38 +4508,34 @@ rocksdb_transaction_options_create(void); extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_destroy( rocksdb_transaction_options_t* opt); -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_set_snapshot( - rocksdb_transaction_options_t* opt, unsigned char v); - -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_deadlock_detect( - rocksdb_transaction_options_t* opt, unsigned char v); - -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_lock_timeout( - rocksdb_transaction_options_t* opt, int64_t lock_timeout); - -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_expiration( - rocksdb_transaction_options_t* opt, int64_t expiration); - -extern ROCKSDB_LIBRARY_API void -rocksdb_transaction_options_set_deadlock_detect_depth( - rocksdb_transaction_options_t* opt, int64_t depth); - -extern ROCKSDB_LIBRARY_API void -rocksdb_transaction_options_set_max_write_batch_size( - rocksdb_transaction_options_t* opt, size_t size); - -extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_skip_prepare( - rocksdb_transaction_options_t* opt, unsigned char v); - extern ROCKSDB_LIBRARY_API rocksdb_optimistictransaction_options_t* rocksdb_optimistictransaction_options_create(void); -extern ROCKSDB_LIBRARY_API void rocksdb_optimistictransaction_options_destroy( - rocksdb_optimistictransaction_options_t* opt); +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_lock_buckets_t* +rocksdb_optimistictransactiondb_lock_buckets_create( + size_t bucket_count, unsigned char cache_aligned); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_optimistictransactiondb_lock_buckets_approximate_memory_usage( + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets); extern ROCKSDB_LIBRARY_API void -rocksdb_optimistictransaction_options_set_set_snapshot( - rocksdb_optimistictransaction_options_t* opt, unsigned char v); +rocksdb_optimistictransactiondb_lock_buckets_destroy( + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets); + +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_options_t* +rocksdb_optimistictransactiondb_options_create(void); + +extern ROCKSDB_LIBRARY_API void rocksdb_optimistictransactiondb_options_destroy( + rocksdb_optimistictransactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_optimistictransactiondb_options_set_shared_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt, + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets); + +extern ROCKSDB_LIBRARY_API void rocksdb_optimistictransaction_options_destroy( + rocksdb_optimistictransaction_options_t* opt); extern ROCKSDB_LIBRARY_API char* rocksdb_optimistictransactiondb_property_value( rocksdb_optimistictransactiondb_t* db, const char* propname); @@ -3906,6 +4923,1722 @@ extern ROCKSDB_LIBRARY_API char* rocksdb_open_and_compact_with_options( const rocksdb_compaction_service_options_override_t* override_options, char** errptr); +// BEGIN generated: c_generated_option_structs_auto.h.inc +// @generated +// ----------------------------------------------------------------------------- +// Auto-generated by tools/c_api_gen/auto_simple_bindings.py. +// DO NOT EDIT THIS FILE DIRECTLY. +// Sources: +// - include/rocksdb/advanced_options.h +// - include/rocksdb/block_cache_trace_writer.h +// - include/rocksdb/env.h +// - include/rocksdb/metadata.h +// - include/rocksdb/options.h +// - include/rocksdb/table.h +// - include/rocksdb/universal_compaction.h +// - include/rocksdb/utilities/backup_engine.h +// - include/rocksdb/utilities/optimistic_transaction_db.h +// - include/rocksdb/utilities/transaction_db.h +// - tools/c_api_gen/auto_simple_bindings_blocklist.json +// - include/rocksdb/c.h +// - tools/c_api_gen/c_base.cc +// ----------------------------------------------------------------------------- + +// To regenerate this file: +// python3 tools/c_api_gen/auto_simple_bindings.py + +// Output group: Auto-discovered option structs simple + +/* DBOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_flush_verify_memtable_count( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_flush_verify_memtable_count(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_compaction_verify_record_count(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_compaction_verify_record_count(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_track_and_verify_wals( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_track_and_verify_wals(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_verify_sst_unique_id_in_manifest(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_verify_sst_unique_id_in_manifest(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_options_get_db_log_dir( + rocksdb_options_t* opt, size_t* size); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_options_get_wal_dir( + rocksdb_options_t* opt, size_t* size); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_async_wal_precreate( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_async_wal_precreate(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_verify_manifest_content_on_close(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_verify_manifest_content_on_close(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_optimize_manifest_for_recovery(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_optimize_manifest_for_recovery(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_reuse_manifest_on_open( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_reuse_manifest_on_open(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_manifest_space_amp_pct( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_max_manifest_space_amp_pct( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_use_direct_io_for_compaction_reads(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_use_direct_io_for_compaction_reads(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_fallocate( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_allow_fallocate( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_persist_stats_to_disk( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_persist_stats_to_disk(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_stats_history_buffer_size( + rocksdb_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_stats_history_buffer_size(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_strict_bytes_per_sync( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_strict_bytes_per_sync(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_enable_thread_tracking( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_enable_thread_tracking(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_delayed_write_rate( + rocksdb_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_delayed_write_rate(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_max_write_batch_group_size_bytes(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_max_write_batch_group_size_bytes(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_thread_max_yield_usec( + rocksdb_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_write_thread_max_yield_usec(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_write_thread_slow_yield_usec(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_write_thread_slow_yield_usec(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_2pc( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_allow_2pc( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_dump_malloc_stats( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_avoid_flush_during_recovery( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_avoid_flush_during_recovery(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_enforce_write_buffer_manager_during_recovery( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_enforce_write_buffer_manager_during_recovery( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_avoid_flush_during_shutdown( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_avoid_flush_during_shutdown(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_two_write_queues( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_two_write_queues( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_background_close_inactive_wals(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_background_close_inactive_wals(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_prefix_seek_opt_in_only( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_prefix_seek_opt_in_only(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_log_readahead_size( + rocksdb_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_log_readahead_size(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_best_efforts_recovery( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_best_efforts_recovery(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_bgerror_resume_count( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_max_bgerror_resume_count( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_bgerror_resume_retry_interval(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_bgerror_resume_retry_interval(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_data_in_errors( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_allow_data_in_errors(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_db_host_id( + rocksdb_options_t* opt, const char* v); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_options_get_db_host_id( + rocksdb_options_t* opt, size_t* size); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_lowest_used_cache_tier( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_lowest_used_cache_tier( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_enforce_single_del_contracts(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_enforce_single_del_contracts(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_daily_offpeak_time_utc( + rocksdb_options_t* opt, const char* v); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_options_get_daily_offpeak_time_utc(rocksdb_options_t* opt, + size_t* size); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_follower_refresh_catchup_period_ms(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_follower_refresh_catchup_period_ms(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_follower_catchup_retry_count(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_follower_catchup_retry_count(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_follower_catchup_retry_wait_ms(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_follower_catchup_retry_wait_ms(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_metadata_write_temperature( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_metadata_write_temperature( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_wal_write_temperature( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_wal_write_temperature( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_fast_sst_open( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_fast_sst_open( + rocksdb_options_t* opt); + +/* AdvancedColumnFamilyOptions */ + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_memtable_whole_key_filtering(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_target_file_size_is_upper_bound(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_target_file_size_is_upper_bound(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_strict_max_successive_merges(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_strict_max_successive_merges(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_paranoid_file_checks( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_paranoid_file_checks(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_verify_output_flags( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_verify_output_flags( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_force_consistency_checks( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_force_consistency_checks(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_disallow_memtable_writes( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_disallow_memtable_writes(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_sample_for_compression( + rocksdb_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_sample_for_compression(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_last_level_temperature( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_last_level_temperature( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_default_write_temperature( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_default_write_temperature( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_default_temperature( + rocksdb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_default_temperature( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_preclude_last_level_data_seconds(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_preclude_last_level_data_seconds(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_preserve_internal_time_seconds(rocksdb_options_t* opt, + uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_preserve_internal_time_seconds(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_enable_blob_direct_write( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_enable_blob_direct_write(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_blob_direct_write_partitions(rocksdb_options_t* opt, + uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_blob_direct_write_partitions(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_protection_bytes_per_key(rocksdb_options_t* opt, + uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_memtable_protection_bytes_per_key(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_persist_user_defined_timestamps(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_persist_user_defined_timestamps(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_block_protection_bytes_per_key(rocksdb_options_t* opt, + uint8_t v); + +extern ROCKSDB_LIBRARY_API uint8_t +rocksdb_options_get_block_protection_bytes_per_key(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_bottommost_file_compaction_delay(rocksdb_options_t* opt, + uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_bottommost_file_compaction_delay(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_paranoid_memory_checks( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_paranoid_memory_checks(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_verify_per_key_checksum_on_seek( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_memtable_verify_per_key_checksum_on_seek( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_cf_allow_ingest_behind( + rocksdb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_cf_allow_ingest_behind(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_batch_lookup_optimization(rocksdb_options_t* opt, + unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_memtable_batch_lookup_optimization(rocksdb_options_t* opt); + +/* ColumnFamilyOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_max_range_deletions(rocksdb_options_t* opt, + uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_memtable_max_range_deletions(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_uncache_aggressiveness( + rocksdb_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_uncache_aggressiveness(rocksdb_options_t* opt); + +/* WriteOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_sync( + rocksdb_writeoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_sync( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_disable_WAL( + rocksdb_writeoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_disable_WAL( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_writeoptions_set_ignore_missing_column_families( + rocksdb_writeoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_writeoptions_get_ignore_missing_column_families( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_no_slowdown( + rocksdb_writeoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_no_slowdown( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_low_pri( + rocksdb_writeoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_writeoptions_get_low_pri( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_writeoptions_set_memtable_insert_hint_per_batch( + rocksdb_writeoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_writeoptions_get_memtable_insert_hint_per_batch( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_rate_limiter_priority( + rocksdb_writeoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_writeoptions_get_rate_limiter_priority( + rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_writeoptions_set_protection_bytes_per_key(rocksdb_writeoptions_t* opt, + size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_writeoptions_get_protection_bytes_per_key(rocksdb_writeoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_set_io_activity( + rocksdb_writeoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_writeoptions_get_io_activity( + rocksdb_writeoptions_t* opt); + +/* FlushOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_flushoptions_set_wait( + rocksdb_flushoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_flushoptions_get_wait( + rocksdb_flushoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_flushoptions_set_allow_write_stall( + rocksdb_flushoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_flushoptions_get_allow_write_stall(rocksdb_flushoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_flushoptions_set_force_atomic_flush( + rocksdb_flushoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_flushoptions_get_force_atomic_flush(rocksdb_flushoptions_t* opt); + +/* FlushWALOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_flushwaloptions_set_sync( + rocksdb_flushwaloptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_flushwaloptions_get_sync( + rocksdb_flushwaloptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_flushwaloptions_set_rate_limiter_priority( + rocksdb_flushwaloptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_flushwaloptions_get_rate_limiter_priority( + rocksdb_flushwaloptions_t* opt); + +/* EnvOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_use_mmap_reads( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_envoptions_get_use_mmap_reads( + rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_use_mmap_writes( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_envoptions_get_use_mmap_writes( + rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_use_direct_reads( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_envoptions_get_use_direct_reads(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_use_direct_writes( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_envoptions_get_use_direct_writes(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_allow_fallocate( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_envoptions_get_allow_fallocate( + rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_fd_cloexec( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_envoptions_get_fd_cloexec( + rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_bytes_per_sync( + rocksdb_envoptions_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_envoptions_get_bytes_per_sync(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_strict_bytes_per_sync( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_envoptions_get_strict_bytes_per_sync(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_fallocate_with_keep_size( + rocksdb_envoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_envoptions_get_fallocate_with_keep_size(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_envoptions_set_compaction_readahead_size(rocksdb_envoptions_t* opt, + size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_envoptions_get_compaction_readahead_size(rocksdb_envoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_envoptions_set_writable_file_max_buffer_size(rocksdb_envoptions_t* opt, + size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_envoptions_get_writable_file_max_buffer_size(rocksdb_envoptions_t* opt); + +/* TraceOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_trace_options_set_max_trace_file_size( + rocksdb_trace_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_trace_options_get_max_trace_file_size(rocksdb_trace_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_trace_options_set_sampling_frequency( + rocksdb_trace_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_trace_options_get_sampling_frequency(rocksdb_trace_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_trace_options_set_filter( + rocksdb_trace_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_trace_options_get_filter(rocksdb_trace_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_trace_options_set_preserve_write_order( + rocksdb_trace_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_trace_options_get_preserve_write_order(rocksdb_trace_options_t* opt); + +/* BlockCacheTraceOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_cache_trace_options_set_sampling_frequency( + rocksdb_block_cache_trace_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_block_cache_trace_options_get_sampling_frequency( + rocksdb_block_cache_trace_options_t* opt); + +/* BlockCacheTraceWriterOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_cache_trace_writer_options_set_max_trace_file_size( + rocksdb_block_cache_trace_writer_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_block_cache_trace_writer_options_get_max_trace_file_size( + rocksdb_block_cache_trace_writer_options_t* opt); + +/* CompactionOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_compaction_options_set_compression( + rocksdb_compaction_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_compaction_options_get_compression( + rocksdb_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_options_set_output_file_size_limit( + rocksdb_compaction_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compaction_options_get_output_file_size_limit( + rocksdb_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_options_set_max_subcompactions( + rocksdb_compaction_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_compaction_options_get_max_subcompactions( + rocksdb_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_options_set_output_temperature_override( + rocksdb_compaction_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_compaction_options_get_output_temperature_override( + rocksdb_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_options_set_allow_trivial_move( + rocksdb_compaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compaction_options_get_allow_trivial_move( + rocksdb_compaction_options_t* opt); + +/* CompactRangeOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_compactoptions_set_blob_garbage_collection_policy( + rocksdb_compactoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_compactoptions_get_blob_garbage_collection_policy( + rocksdb_compactoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compactoptions_set_blob_garbage_collection_age_cutoff( + rocksdb_compactoptions_t* opt, double v); + +extern ROCKSDB_LIBRARY_API double +rocksdb_compactoptions_get_blob_garbage_collection_age_cutoff( + rocksdb_compactoptions_t* opt); + +/* IngestExternalFileOptions */ + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_move_files( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_link_files( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_link_files( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_failed_move_fall_back_to_copy( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_failed_move_fall_back_to_copy( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_snapshot_consistency( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_allow_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_allow_blocking_flush( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_ingest_behind( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_write_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_write_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_verify_checksums_before_ingest( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_verify_checksums_before_ingest( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_verify_checksums_readahead_size( + rocksdb_ingestexternalfileoptions_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_ingestexternalfileoptions_get_verify_checksums_readahead_size( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_verify_file_checksum( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_verify_file_checksum( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_fail_if_not_bottommost_level( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_allow_db_generated_files( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_allow_db_generated_files( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_fill_cache( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_fill_cache( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_prefetch_lmax_index_and_filter_blocks( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_ingestexternalfileoptions_get_prefetch_lmax_index_and_filter_blocks( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_file_opening_threads( + rocksdb_ingestexternalfileoptions_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_ingestexternalfileoptions_get_file_opening_threads( + rocksdb_ingestexternalfileoptions_t* opt); + +/* OpenAndCompactOptions */ + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_open_and_compact_options_get_allow_resumption( + rocksdb_open_and_compact_options_t* opt); + +/* ImportColumnFamilyOptions */ + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_import_column_family_options_get_move_files( + rocksdb_import_column_family_options_t* opt); + +/* SizeApproximationOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_size_approximation_options_set_include_memtables( + rocksdb_size_approximation_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_size_approximation_options_get_include_memtables( + rocksdb_size_approximation_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_size_approximation_options_set_include_files( + rocksdb_size_approximation_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_size_approximation_options_get_include_files( + rocksdb_size_approximation_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_size_approximation_options_set_include_blob_files( + rocksdb_size_approximation_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_size_approximation_options_get_include_blob_files( + rocksdb_size_approximation_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_size_approximation_options_set_files_size_error_margin( + rocksdb_size_approximation_options_t* opt, double v); + +extern ROCKSDB_LIBRARY_API double +rocksdb_size_approximation_options_get_files_size_error_margin( + rocksdb_size_approximation_options_t* opt); + +/* LiveFilesStorageInfoOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_livefiles_storage_info_options_set_include_checksum_info( + rocksdb_livefiles_storage_info_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_livefiles_storage_info_options_get_include_checksum_info( + rocksdb_livefiles_storage_info_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_livefiles_storage_info_options_set_wal_size_for_flush( + rocksdb_livefiles_storage_info_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_livefiles_storage_info_options_get_wal_size_for_flush( + rocksdb_livefiles_storage_info_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_livefiles_storage_info_options_set_atomic_flush( + rocksdb_livefiles_storage_info_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_livefiles_storage_info_options_get_atomic_flush( + rocksdb_livefiles_storage_info_options_t* opt); + +/* GetColumnFamilyMetaDataOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_column_family_metadata_options_set_level( + rocksdb_column_family_metadata_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_column_family_metadata_options_get_level( + rocksdb_column_family_metadata_options_t* opt); + +/* WaitForCompactOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_wait_for_compact_options_set_wait_for_purge( + rocksdb_wait_for_compact_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_wait_for_compact_options_get_wait_for_purge( + rocksdb_wait_for_compact_options_t* opt); + +/* BlockBasedTableOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_cache_index_and_filter_blocks( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_cache_index_and_filter_blocks( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_cache_index_and_filter_blocks_with_high_priority( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_pin_l0_filter_and_index_blocks_in_cache( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_pin_top_level_index_and_filter( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_pin_top_level_index_and_filter( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_index_type( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_block_based_options_get_index_type( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_index_block_search_type( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_index_block_search_type( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_data_block_index_type( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_data_block_index_type( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_data_block_hash_table_util_ratio( + rocksdb_block_based_table_options_t* opt, double v); + +extern ROCKSDB_LIBRARY_API double +rocksdb_block_based_options_get_data_block_hash_table_util_ratio( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_checksum( + rocksdb_block_based_table_options_t* opt, char v); + +extern ROCKSDB_LIBRARY_API int rocksdb_block_based_options_get_checksum( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_no_block_cache( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_no_block_cache( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_block_size( + rocksdb_block_based_table_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_block_based_options_get_block_size( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_block_size_deviation( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_block_size_deviation( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_block_restart_interval( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_block_restart_interval( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_index_block_restart_interval( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_index_block_restart_interval( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_metadata_block_size( + rocksdb_block_based_table_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_block_based_options_get_metadata_block_size( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_partition_filters( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_partition_filters( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_decouple_partitioned_filters( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_decouple_partitioned_filters( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_optimize_filters_for_memory( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_optimize_filters_for_memory( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_use_delta_encoding( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_use_delta_encoding( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_use_udi_as_primary_index( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_use_udi_as_primary_index( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_fail_if_no_udi_on_open( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_fail_if_no_udi_on_open( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_whole_key_filtering( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_whole_key_filtering( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_detect_filter_construct_corruption( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_detect_filter_construct_corruption( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_verify_compression( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_verify_compression( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_read_amp_bytes_per_bit( + rocksdb_block_based_table_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_block_based_options_get_read_amp_bytes_per_bit( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_format_version( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_block_based_options_get_format_version( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_separate_key_value_in_data_block( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_separate_key_value_in_data_block( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_uniform_cv_threshold( + rocksdb_block_based_table_options_t* opt, double v); + +extern ROCKSDB_LIBRARY_API double +rocksdb_block_based_options_get_uniform_cv_threshold( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_enable_index_compression( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_enable_index_compression( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_block_align( + rocksdb_block_based_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_block_based_options_get_block_align( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_super_block_alignment_size( + rocksdb_block_based_table_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_block_based_options_get_super_block_alignment_size( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_super_block_alignment_space_overhead_ratio( + rocksdb_block_based_table_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_block_based_options_get_super_block_alignment_space_overhead_ratio( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_index_shortening( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_block_based_options_get_index_shortening( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_max_auto_readahead_size( + rocksdb_block_based_table_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_block_based_options_get_max_auto_readahead_size( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_prepopulate_block_cache( + rocksdb_block_based_table_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_block_based_options_get_prepopulate_block_cache( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_initial_auto_readahead_size( + rocksdb_block_based_table_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_block_based_options_get_initial_auto_readahead_size( + rocksdb_block_based_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_num_file_reads_for_auto_readahead( + rocksdb_block_based_table_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_block_based_options_get_num_file_reads_for_auto_readahead( + rocksdb_block_based_table_options_t* opt); + +/* CuckooTableOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_hash_table_ratio( + rocksdb_cuckoo_table_options_t* opt, double v); + +extern ROCKSDB_LIBRARY_API double rocksdb_cuckoo_options_get_hash_table_ratio( + rocksdb_cuckoo_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_max_search_depth( + rocksdb_cuckoo_table_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t rocksdb_cuckoo_options_get_max_search_depth( + rocksdb_cuckoo_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_cuckoo_block_size( + rocksdb_cuckoo_table_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_cuckoo_options_get_cuckoo_block_size( + rocksdb_cuckoo_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_cuckoo_options_set_identity_as_first_hash( + rocksdb_cuckoo_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_cuckoo_options_get_identity_as_first_hash( + rocksdb_cuckoo_table_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_set_use_module_hash( + rocksdb_cuckoo_table_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_cuckoo_options_get_use_module_hash(rocksdb_cuckoo_table_options_t* opt); + +/* CompactionOptionsUniversal */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_max_read_amp( + rocksdb_universal_compaction_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_universal_compaction_options_get_max_read_amp( + rocksdb_universal_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_allow_trivial_move( + rocksdb_universal_compaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_universal_compaction_options_get_allow_trivial_move( + rocksdb_universal_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_incremental( + rocksdb_universal_compaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_universal_compaction_options_get_incremental( + rocksdb_universal_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_reduce_file_locking( + rocksdb_universal_compaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_universal_compaction_options_get_reduce_file_locking( + rocksdb_universal_compaction_options_t* opt); + +/* CompactionOptionsFIFO */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_fifo_compaction_options_set_age_for_warm( + rocksdb_fifo_compaction_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_fifo_compaction_options_get_age_for_warm( + rocksdb_fifo_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_fifo_compaction_options_set_allow_trivial_copy_when_change_temperature( + rocksdb_fifo_compaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_fifo_compaction_options_get_allow_trivial_copy_when_change_temperature( + rocksdb_fifo_compaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_fifo_compaction_options_set_trivial_copy_buffer_size( + rocksdb_fifo_compaction_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_fifo_compaction_options_get_trivial_copy_buffer_size( + rocksdb_fifo_compaction_options_t* opt); + +/* BackupEngineOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_set_backup_dir( + rocksdb_backup_engine_options_t* opt, const char* v); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_backup_engine_options_get_backup_dir( + rocksdb_backup_engine_options_t* opt, size_t* size); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_share_table_files( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_backup_engine_options_get_share_table_files( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_set_sync( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_backup_engine_options_get_sync( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_destroy_old_data( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_backup_engine_options_get_destroy_old_data( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_backup_log_files( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_backup_engine_options_get_backup_log_files( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_io_buffer_size( + rocksdb_backup_engine_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_backup_engine_options_get_io_buffer_size( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_backup_rate_limit( + rocksdb_backup_engine_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_backup_engine_options_get_backup_rate_limit( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_restore_rate_limit( + rocksdb_backup_engine_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_backup_engine_options_get_restore_rate_limit( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_share_files_with_checksum( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_backup_engine_options_get_share_files_with_checksum( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_max_background_operations( + rocksdb_backup_engine_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_backup_engine_options_get_max_background_operations( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_callback_trigger_interval_size( + rocksdb_backup_engine_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_backup_engine_options_get_callback_trigger_interval_size( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_max_valid_backups_to_open( + rocksdb_backup_engine_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_backup_engine_options_get_max_valid_backups_to_open( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_share_files_with_checksum_naming( + rocksdb_backup_engine_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_backup_engine_options_get_share_files_with_checksum_naming( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_schema_version( + rocksdb_backup_engine_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_backup_engine_options_get_schema_version( + rocksdb_backup_engine_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_current_temperatures_override_manifest( + rocksdb_backup_engine_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_backup_engine_options_get_current_temperatures_override_manifest( + rocksdb_backup_engine_options_t* opt); + +/* CreateBackupOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_create_backup_options_set_flush_before_backup( + rocksdb_create_backup_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_create_backup_options_get_flush_before_backup( + rocksdb_create_backup_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_create_backup_options_set_decrease_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_create_backup_options_get_decrease_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_create_backup_options_set_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_create_backup_options_get_background_thread_cpu_priority( + rocksdb_create_backup_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_create_backup_options_set_atomic_flush( + rocksdb_create_backup_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_create_backup_options_get_atomic_flush( + rocksdb_create_backup_options_t* opt); + +/* RestoreOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_restore_options_set_keep_log_files( + rocksdb_restore_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_restore_options_get_keep_log_files(rocksdb_restore_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_restore_options_set_mode( + rocksdb_restore_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_restore_options_get_mode( + rocksdb_restore_options_t* opt); + +/* TransactionDBOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_set_max_num_locks( + rocksdb_transactiondb_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transactiondb_options_get_max_num_locks( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_max_num_deadlocks( + rocksdb_transactiondb_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_transactiondb_options_get_max_num_deadlocks( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_set_num_stripes( + rocksdb_transactiondb_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_transactiondb_options_get_num_stripes( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_transaction_lock_timeout( + rocksdb_transactiondb_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transactiondb_options_get_transaction_lock_timeout( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_default_lock_timeout( + rocksdb_transactiondb_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transactiondb_options_get_default_lock_timeout( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_set_write_policy( + rocksdb_transactiondb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int rocksdb_transactiondb_options_get_write_policy( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_rollback_merge_operands( + rocksdb_transactiondb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transactiondb_options_get_rollback_merge_operands( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_use_per_key_point_lock_mgr( + rocksdb_transactiondb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transactiondb_options_get_use_per_key_point_lock_mgr( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_skip_concurrency_control( + rocksdb_transactiondb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transactiondb_options_get_skip_concurrency_control( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_default_write_batch_flush_threshold( + rocksdb_transactiondb_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transactiondb_options_get_default_write_batch_flush_threshold( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_enable_udt_validation( + rocksdb_transactiondb_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transactiondb_options_get_enable_udt_validation( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transactiondb_options_set_txn_commit_bypass_memtable_threshold( + rocksdb_transactiondb_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_transactiondb_options_get_txn_commit_bypass_memtable_threshold( + rocksdb_transactiondb_options_t* opt); + +/* TransactionOptions */ + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_set_snapshot( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_set_snapshot( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_deadlock_detect( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_deadlock_detect( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_use_only_the_last_commit_time_batch_for_recovery( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_use_only_the_last_commit_time_batch_for_recovery( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_lock_timeout( + rocksdb_transaction_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t rocksdb_transaction_options_get_lock_timeout( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_deadlock_timeout_us( + rocksdb_transaction_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transaction_options_get_deadlock_timeout_us( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_expiration( + rocksdb_transaction_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transaction_options_get_expiration(rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_deadlock_detect_depth( + rocksdb_transaction_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transaction_options_get_deadlock_detect_depth( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_max_write_batch_size( + rocksdb_transaction_options_t* opt, size_t v); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_transaction_options_get_max_write_batch_size( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_skip_concurrency_control( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_skip_concurrency_control( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_set_skip_prepare( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_skip_prepare( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_write_batch_flush_threshold( + rocksdb_transaction_options_t* opt, int64_t v); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_transaction_options_get_write_batch_flush_threshold( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_write_batch_track_timestamp_size( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_write_batch_track_timestamp_size( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_commit_bypass_memtable( + rocksdb_transaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_transaction_options_get_commit_bypass_memtable( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_large_txn_commit_optimize_threshold( + rocksdb_transaction_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_transaction_options_get_large_txn_commit_optimize_threshold( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_options_set_large_txn_commit_optimize_byte_threshold( + rocksdb_transaction_options_t* opt, uint64_t v); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_transaction_options_get_large_txn_commit_optimize_byte_threshold( + rocksdb_transaction_options_t* opt); + +/* OptimisticTransactionOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_optimistictransaction_options_set_set_snapshot( + rocksdb_optimistictransaction_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_optimistictransaction_options_get_set_snapshot( + rocksdb_optimistictransaction_options_t* opt); + +/* OptimisticTransactionDBOptions */ + +extern ROCKSDB_LIBRARY_API void +rocksdb_optimistictransactiondb_options_set_validate_policy( + rocksdb_optimistictransactiondb_options_t* opt, int v); + +extern ROCKSDB_LIBRARY_API int +rocksdb_optimistictransactiondb_options_get_validate_policy( + rocksdb_optimistictransactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_optimistictransactiondb_options_set_occ_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt, uint32_t v); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_optimistictransactiondb_options_get_occ_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt); +// END generated: c_generated_option_structs_auto.h.inc + #ifdef __cplusplus } /* end extern "C" */ #endif diff --git a/table/block_based/block_based_table_factory.cc b/table/block_based/block_based_table_factory.cc index bf1fa416c4..4de0b528ec 100644 --- a/table/block_based/block_based_table_factory.cc +++ b/table/block_based/block_based_table_factory.cc @@ -12,6 +12,7 @@ #include #include #include +#include #include #include "cache/cache_entry_roles.h" @@ -28,12 +29,14 @@ #include "rocksdb/table.h" #include "rocksdb/user_defined_index.h" #include "rocksdb/utilities/customizable_util.h" +#include "rocksdb/utilities/object_registry.h" #include "rocksdb/utilities/options_type.h" #include "table/block_based/block_based_table_builder.h" #include "table/block_based/block_based_table_reader.h" #include "table/format.h" #include "util/mutexlock.h" #include "util/string_util.h" +#include "utilities/trie_index/trie_index_factory.h" namespace ROCKSDB_NAMESPACE { @@ -1127,6 +1130,11 @@ TableFactory* NewBlockBasedTableFactory( Status UserDefinedIndexFactory::CreateFromString( const ConfigOptions& config_options, const std::string& value, std::shared_ptr* factory) { + static std::once_flag once; + std::call_once(once, [&]() { + trie_index::RegisterBuiltinTrieIndexFactory( + *(ObjectLibrary::Default().get()), ""); + }); return LoadSharedObject(config_options, value, factory); } diff --git a/tools/c_api_gen/README.md b/tools/c_api_gen/README.md new file mode 100644 index 0000000000..8536c43b70 --- /dev/null +++ b/tools/c_api_gen/README.md @@ -0,0 +1,350 @@ +# RocksDB C API Code Generation Prototype + +This directory contains a **prototype** for semi-automating parts of +RocksDB's C API based on the existing C++ public API and the current C API +conventions in `include/rocksdb/c.h` / `db/c.cc`. + +The intent is **not** to automatically wrap arbitrary C++ APIs. Instead, the +goal is to reduce maintenance burden for the parts of the C API that are +already highly mechanical today. + +## Why a semi-automated approach + +RocksDB's C API follows stable conventions that downstream users rely on: + +- opaque handle types like `rocksdb_t*`, `rocksdb_transaction_t*` +- `Status` translated to `char** errptr` +- `Slice` translated to `const char*` + `size_t` +- binary/string results copied into `malloc()`-owned buffers +- booleans represented as `unsigned char` +- `rocksdb__[_cf][_with_ts]` naming + +These conventions are valuable and should remain the source of truth for the +generated code. + +At the same time, the C++ public API includes features that are poor fits for +fully automatic wrapper generation: + +- callback-backed polymorphic types (`Comparator`, `MergeOperator`, etc.) +- complex object construction/open flows +- ownership-transferring factory setters +- vector-heavy marshalling APIs like the `MultiGet` family +- virtual extension points and custom bridging logic + +For those cases, hand-designed wrappers remain the right tool. + +## Why the spec-driven generator still exists + +The spec-driven generator is still needed for wrappers whose C shape cannot be +reliably inferred from the C++ declaration alone. + +Yes, this means `spec.json` is manually maintained. That is intentional. The +goal is not to eliminate human decisions; the goal is to stop hand-writing the +same declaration/definition boilerplate once those decisions have been made. + +For many wrappers, someone still has to decide: + +- the C function name and parameter order +- whether a C++ `Status` becomes `char** errptr` +- whether default C++ objects should be synthesized, such as `ReadOptions()` +- how ownership and lifetime should work for pointers, factories, and callbacks +- how vectors, maps, and option collections should be flattened into C +- whether the C API should intentionally differ from the C++ API shape + +Those are API design choices, not mechanical translations. The spec-driven +path keeps those choices explicit while still generating consistent boilerplate. + +Backward compatibility with the existing hand-written C API is one input, but +it is not the primary reason this layer exists. Even for brand-new wrappers, we +still need an explicit policy layer for non-trivial C bindings. + +## What this prototype focuses on + +The generator currently targets representative examples from the easiest and +most repetitive wrapper families: + +1. **Simple scalar field setters/getters** + - `rocksdb_options_set_create_if_missing` + - `rocksdb_options_get_create_if_missing` + - `rocksdb_readoptions_set_fill_cache` + - `rocksdb_writeoptions_set_sync` + - `rocksdb_block_based_options_set_block_size` + - `rocksdb_cuckoo_options_set_hash_ratio` + +2. **Simple forwarding wrappers with no `Status`** + - `rocksdb_writebatch_clear` + - `rocksdb_writebatch_put` + - `rocksdb_writebatch_put_cf` + - `rocksdb_writebatch_delete` + - `rocksdb_writebatch_put_log_data` + - `rocksdb_writebatch_set_save_point` + - `rocksdb_transaction_set_savepoint` + +3. **Simple forwarding wrappers with `Status` -> `char** errptr`** + - `rocksdb_put`, `rocksdb_put_cf` + - `rocksdb_delete`, `rocksdb_delete_cf` + - `rocksdb_merge`, `rocksdb_merge_cf` + - `rocksdb_write` + - `rocksdb_writebatch_rollback_to_save_point` + - `rocksdb_writebatch_pop_save_point` + - `rocksdb_transaction_put`, `rocksdb_transaction_put_cf` + - `rocksdb_transaction_merge`, `rocksdb_transaction_merge_cf` + - `rocksdb_transaction_delete`, `rocksdb_transaction_delete_cf` + - `rocksdb_transaction_commit` + - `rocksdb_transaction_rollback` + - `rocksdb_transaction_rollback_to_savepoint` + +4. **Simple metadata accessors** + - `rocksdb_flushjobinfo_cf_name` + - `rocksdb_flushjobinfo_largest_seqno` + +This is intentionally a constrained subset. The point is to demonstrate a +maintainable pattern and a spec format that can be extended gradually. + +## What should remain manual + +These families should stay hand-written unless a future design adds a much +richer generator: + +- comparators / merge operators / compaction filters / event listeners +- compaction service wrappers +- openers and constructors that build vectors/maps of descriptors/options +- `MultiGet` / batched `MultiGet` families +- wrappers involving `std::shared_ptr` / `std::unique_ptr` ownership transfer +- C APIs whose behavior intentionally differs from the C++ API shape + +## Design principles + +### 1. Keep the current C API conventions + +The code generator should not invent a new style. It should emit code that +looks like today's hand-written wrappers: + +- `SaveError(errptr, ...)` +- `Slice(key, keylen)` +- direct field assignments for plain option setters +- same function names and signatures + +### 2. Let auto-discovery handle the simple direct cases + +For a small set of mechanically mappable public structs, the generator can +discover missing bindings directly from the C++ headers and emit the missing C +wrappers automatically. Existing handwritten wrappers still win when they +already exist. + +Today this strict auto-discovery path is used for: + +- simple `ReadOptions` scalar / enum fields +- simple scalar / enum fields across selected public option structs +- simple metadata fields on listener/job-info structs +- simple metadata view structs such as table-properties and compaction metadata + +For those managed families, unsupported or intentionally deferred fields must +be explicitly recorded in `auto_simple_bindings_blocklist.json` rather than +being skipped silently. Anything outside those families remains hand-written. + +### 3. Keep explicit spec for non-trivial wrappers + +The spec-driven generator remains the right tool for method-style wrappers and +other APIs whose C surface requires an explicit design decision. In practice: + +- auto-discovery owns simple direct field coverage for selected struct families +- `spec.json` owns wrappers that are still manual in design but repetitive in + implementation +- fully irregular ownership-heavy or callback-heavy APIs remain hand-written + +### 4. Let C++ headers guide validation, not policy + +Longer term, Clang/libTooling can help validate that a wrapper spec still +matches the underlying C++ method signature. But the C naming, ownership, and +error-handling policy should remain explicit in the spec. + +## Files + +Source templates (hand-written; NOT user-includable and NOT compiled directly): + +- `c_base.h` + - hand-written template for `include/rocksdb/c.h`; the generated `.h.inc` + fragments are inlined into it to produce the self-contained public header +- `c_base.cc` + - hand-written template for `db/c.cc`; the generated `.cc.inc` fragments are + inlined into it to produce the compiled implementation + +Generators and inputs: + +- `spec.json` + - declarative input for the spec-driven generator +- `generate_c_api.py` + - emits header/source fragments from the spec +- `auto_simple_bindings.py` + - auto-discovers simple public field bindings and generates checked-in + `.inc` files for them +- `auto_simple_bindings_blocklist.json` + - checked-in exceptions for auto-managed fields that are intentionally manual + or temporarily deferred +- `abi_type_overrides.json` + - per-function C type pins so already-shipped wrappers keep their historical + C signature even when the C++ field type maps to a different C type +- `regen_all.py` + - orchestrates both generators and inlines the fragments into `c.h` / `c.cc` + +Verification (run by `make check-c-api-gen` and in CI): + +- `check_api_completeness.py` + - asserts every declared public C function has exactly one definition + (dependency-free; guards against link-time breakage of bindings) +- `check_api_compatibility.py` + `api_compatibility_allowlist.json` + - signature-level backward-compatibility gate against a reference revision; + the authoritative ABI/API-stability check +- `verify_generated_up_to_date.py` + - regenerates in a temp dir and confirms the checked-in output is current +- `validate_generated_equivalence.py` + `equivalence_allowlist.json` + - best-effort migration aid: compares generated wrapper *bodies* against a + PRE-migration hand-written revision. Body comparison is heuristic; for + backward-compatibility rely on `check_api_compatibility.py`. + +## Toolchain requirements + +Regeneration needs two external tools: + +- **`clang++`** (libclang) — used to dump the C++ struct ASTs that drive + auto-discovery. Resolution order is `$CXX` (if it names a clang), then bare + `clang++`, then versioned fallbacks (`clang++-21` … `clang++-13`). +- **`clang-format`** — used to canonicalize the generated `.inc` fragments (and + therefore the inlined `c.h` / `c.cc`). + +The checked-in generated output is byte-reproducible only for a **pinned +clang-format version**. CI uses **clang-format-21** (see +`.github/workflows/pr-jobs.yml`); pin the same version locally so your +regeneration matches CI: + +```bash +python3 tools/c_api_gen/regen_all.py --clang-format clang-format-21 +# or, when running the staleness check via make: +make check-c-api-gen CLANG_FORMAT_BINARY=clang-format-21 +``` + +If `clang++` is not installed, `make check` skips the C API staleness check +with a message instead of failing, so it still works without the codegen +toolchain. CI is the authoritative gate. + +The dedicated `build-linux-clang-21-no_test_run` CI job runs this target with +`CHECK_C_API_GEN_STRICT=1`, which turns every such "skip" (missing `clang++` or +clang-format, or an unresolvable compat baseline ref) into a hard error, so the +core CI coverage cannot silently regress to a no-op: + +```bash +make check-c-api-gen CHECK_C_API_GEN_STRICT=1 CLANG_FORMAT_BINARY=clang-format-21 +``` + +## Running the generators + +From the repo root, to regenerate all checked-in fragments and the inlined +`c.h` / `c.cc`: + +```bash +python3 tools/c_api_gen/regen_all.py +``` + +This regenerates: + +- the spec-driven fragments from `spec.json` +- the auto-discovered fragments produced by `auto_simple_bindings.py` +- the round-trip tests produced by `gen_roundtrip_tests.py` + +To preview only the spec-driven output for one section without touching the +checked-in fragments, run `generate_c_api.py` directly with `--header-out` / +`--source-out` pointing at a scratch path (e.g. under `/tmp`). + +To verify the auto-discovered checked-in output is up to date: + +```bash +python3 tools/c_api_gen/auto_simple_bindings.py --check +``` + +To verify the full checked-in generated set is stable without relying on Git +worktree metadata: + +```bash +python3 tools/c_api_gen/verify_generated_up_to_date.py +``` + +## Maintaining Auto-Managed Families + +When a new public field is added to an auto-managed family, use this decision +process: + +1. If it is a simple scalar, enum, string, or supported chrono field and the + desired C API shape matches the existing conventions, do not hand-edit + `include/rocksdb/c.h` or `db/c.cc`. Run `python3 tools/c_api_gen/regen_all.py` + and let `auto_simple_bindings.py` generate the wrapper. +2. If the field needs an explicit C API design because of ownership, callbacks, + vectors, maps, nested structs, or intentionally different C naming/behavior, + keep it out of auto-generation by adding an entry to + `tools/c_api_gen/auto_simple_bindings_blocklist.json` with + `"policy": "manual"`. +3. If the field belongs to an auto-managed family but you intentionally want to + postpone C API coverage for a short time, add a blocklist entry with + `"policy": "deferred"` and a concrete reason. Include `tracking_issue` when + you have one. +4. If none of the above applies, the build should fail. Extend + `auto_simple_bindings.py`, add a spec-driven wrapper, or add a hand-written + wrapper and then update the blocklist policy accordingly. + +The blocklist is intentionally strict: + +- each entry must identify the managed family and field +- each entry must have a non-empty reason +- policy must be either `manual` or `deferred` +- stale entries fail regeneration if the field disappears or is renamed + +Example deferred entry: + +```json +{ + "name": "ReadOptions", + "entries": [ + { + "field": "future_slice_option", + "policy": "deferred", + "reason": "Needs an explicit C buffer ownership design before exposing it.", + "tracking_issue": "T123456789" + } + ] +} +``` + +The blocklist only applies to the auto-managed families handled by +`auto_simple_bindings.py`. It is not a substitute for `spec.json`, which still +owns non-trivial method-style wrappers. It is also unrelated to +`equivalence_allowlist.json`, which only suppresses intentional diff mismatches +in the equivalence checker. + +To refresh the full checked-in generated set and confirm nothing changes: + +```bash +python3 tools/c_api_gen/verify_generated_up_to_date.py +``` + +To verify active generated wrappers are equivalent to the handwritten wrappers +from a reference revision: + +```bash +python3 tools/c_api_gen/validate_generated_equivalence.py --ref HEAD +``` + +This checks the generated fragments currently included by +`include/rocksdb/c.h` and `db/c.cc` against `HEAD:include/rocksdb/c.h` and +`HEAD:db/c.cc`. Known historical inconsistencies can be documented in +`equivalence_allowlist.json` with a reason instead of being silently ignored. + +## Suggested migration path + +1. Start with generated preview fragments only. +2. Migrate a few low-risk existing wrappers to generated sections. +3. Keep manual and generated sections clearly separated. +4. Let auto-discovery pick up new simple public fields automatically. +5. Extend the spec or keep manual wrappers for complex/manual families. + +This incremental approach minimizes downstream impact while still reducing +maintenance burden over time. diff --git a/tools/c_api_gen/abi_type_overrides.json b/tools/c_api_gen/abi_type_overrides.json new file mode 100644 index 0000000000..a2299d85e7 --- /dev/null +++ b/tools/c_api_gen/abi_type_overrides.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "description": [ + "ABI-preserving C type overrides for auto-generated C API wrappers.", + "", + "RocksDB's C API has a strong backward-compatibility guarantee: the C", + "signature of a function that has already shipped must never change, even", + "when the underlying C++ field type would naturally map to a different C", + "type. The auto-generator derives the C type from the C++ field (e.g. bool", + "-> unsigned char, uint64_t -> uint64_t, an enum -> int). For a handful of", + "pre-existing functions the historical hand-written C type differs from", + "that natural mapping, so we pin it here. The generated body still casts to", + "the real C++ field type via static_cast(value), so the", + "behavior is identical -- only the public C parameter/return type is held", + "stable.", + "", + "Only add entries for functions that already shipped with a different type.", + "Brand-new functions should use the natural mapping. The equivalence", + "validator (validate_generated_equivalence.py) enforces that generated", + "signatures match the reference revision, so any unintended drift here will", + "fail CI." + ], + "overrides": [ + { + "function": "rocksdb_writeoptions_disable_WAL", + "role": "setter", + "c_type": "int", + "field_cxx_type": "bool", + "reason": "Shipped as `int disable` long before codegen; the field is bool but the C parameter type must stay `int` for ABI compatibility." + }, + { + "function": "rocksdb_restore_options_set_keep_log_files", + "role": "setter", + "c_type": "int", + "field_cxx_type": "bool", + "reason": "Shipped as `int v`; the field is bool but the C parameter type must stay `int` for ABI compatibility." + }, + { + "function": "rocksdb_block_based_options_set_checksum", + "role": "setter", + "c_type": "char", + "field_cxx_type": "ChecksumType", + "reason": "Shipped as `char`; the field is the ChecksumType enum but the C parameter type must stay `char` for ABI compatibility." + }, + { + "function": "rocksdb_block_based_options_set_format_version", + "role": "setter", + "c_type": "int", + "field_cxx_type": "uint32_t", + "reason": "Shipped as `int`; the field is uint32_t but the C parameter type must stay `int` for ABI compatibility." + }, + { + "function": "rocksdb_block_based_options_set_block_size", + "role": "setter", + "c_type": "size_t", + "field_cxx_type": "uint64_t", + "reason": "Shipped as `size_t block_size`; the field is uint64_t but the C parameter type must stay `size_t` for ABI compatibility." + } + ] +} diff --git a/tools/c_api_gen/api_compatibility_allowlist.json b/tools/c_api_gen/api_compatibility_allowlist.json new file mode 100644 index 0000000000..a64937bdc5 --- /dev/null +++ b/tools/c_api_gen/api_compatibility_allowlist.json @@ -0,0 +1,19 @@ +{ + "schema_version": 1, + "description": [ + "Documented, intentional backward-incompatible changes to the public C API", + "(include/rocksdb/c.h), checked by check_api_compatibility.py.", + "", + "Each entry suppresses one otherwise-failing finding. 'kind' is 'removed'", + "(a function that existed in the baseline is gone) or 'changed' (its", + "signature changed). Only add entries for changes that are deliberate and", + "reviewed; every entry needs a reason." + ], + "allow": [ + { + "kind": "removed", + "function": "rocksdb_writebatch_wi_create_from", + "reason": "Declared in c.h but never implemented anywhere in RocksDB (WriteBatchWithIndex has no constructor from a serialized representation). The symbol never existed, so no consumer could have linked against it; the dead declaration was removed." + } + ] +} diff --git a/tools/c_api_gen/auto_simple_bindings.py b/tools/c_api_gen/auto_simple_bindings.py new file mode 100644 index 0000000000..673a6036eb --- /dev/null +++ b/tools/c_api_gen/auto_simple_bindings.py @@ -0,0 +1,1304 @@ +# 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 the Apache 2.0 License (found in the LICENSE.Apache file in the root directory). + +#!/usr/bin/env python3 +"""Auto-discover and generate simple RocksDB C API field bindings. + +This script follows a strict policy for the families it manages: + +- if a supported simple public C++ field already has matching C bindings, + leave the existing binding in place +- otherwise auto-generate the matching C binding +- if a managed field is explicitly blocklisted as manual or deferred, + leave it for explicit C API follow-up +- if a field is in a managed family but is not supported by the simple + generator and there is no manual C binding, fail regeneration +""" + +from __future__ import annotations + +import argparse +import json +import re +import shutil +import subprocess +import sys +from dataclasses import dataclass +from json import JSONDecoder +from pathlib import Path +from typing import Iterable + +from generate_c_api import render_decl, render_impl, write_if_changed + + +ROOT = Path(__file__).resolve().parents[2] +INCLUDE_ROOT = ROOT / "include/rocksdb" +SOURCE_ROOT = ROOT / "db" +# Hand-written source templates for the C API. These are generator inputs (not +# user-includable / not compiled), so they live next to the generator rather +# than in include/rocksdb or db/. +TEMPLATE_ROOT = ROOT / "tools/c_api_gen" +GENERATED_INCLUDE_ROOT = ROOT / "c_api_gen" +GENERATED_SOURCE_ROOT = ROOT / "c_api_gen" +CLANG_FORMAT = shutil.which("clang-format") +BLOCKLIST_PATH = ROOT / "tools/c_api_gen/auto_simple_bindings_blocklist.json" +BLOCKLIST_POLICIES = frozenset({"manual", "deferred"}) +# ABI-preserving C type overrides: function name -> pinned C type. See +# abi_type_overrides.json for the rationale (RocksDB's C API must not change the +# signature of an already-shipped function even when the C++ field type maps to +# a different C type). +ABI_TYPE_OVERRIDES_PATH = ROOT / "tools/c_api_gen/abi_type_overrides.json" + + +def load_abi_type_overrides(path: Path) -> dict[str, str]: + import json + + if not path.exists(): + return {} + data = json.loads(path.read_text()) + overrides: dict[str, str] = {} + for entry in data.get("overrides", []): + name = entry["function"] + if name in overrides and overrides[name] != entry["c_type"]: + raise ValueError( + f"Conflicting ABI type overrides for {name}: " + f"{overrides[name]} vs {entry['c_type']}" + ) + overrides[name] = entry["c_type"] + return overrides + + +ABI_TYPE_OVERRIDES = load_abi_type_overrides(ABI_TYPE_OVERRIDES_PATH) + + +@dataclass(frozen=True) +class FamilyConfig: + struct_name: str + header: Path + c_receiver_type: str + c_receiver_name: str + c_prefix: str + mode: str + field_expr_format: str = "{receiver_name}->rep.{field_name}" + enum_types: tuple[str, ...] = () + # C integer type used for enum-typed fields. This is intentionally + # per-family to preserve each family's historical ABI: the option families + # have always exposed enums as `int`, while the listener/job-info families + # shipped them as `uint32_t` (e.g. the pre-existing + # rocksdb_flushjobinfo_flush_reason). Do NOT "unify" these to one type -- + # it would change the signatures of already-shipped functions. + enum_c_type: str = "int" + section_name: str | None = None + setter_name_overrides: tuple[tuple[str, str], ...] = () + getter_name_overrides: tuple[tuple[str, str], ...] = () + + +@dataclass(frozen=True) +class OutputGroup: + name: str + header_out: Path + source_out: Path + families: tuple[FamilyConfig, ...] + + +@dataclass(frozen=True) +class BlocklistEntry: + family_name: str + field_name: str + policy: str + reason: str + tracking_issue: str | None = None + + +READ_OPTIONS_GROUP = OutputGroup( + name="Auto-discovered ReadOptions simple", + header_out=GENERATED_INCLUDE_ROOT / "c_generated_readoptions_auto.h.inc", + source_out=GENERATED_SOURCE_ROOT / "c_generated_readoptions_auto.cc.inc", + families=( + FamilyConfig( + struct_name="ReadOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_readoptions_t*", + c_receiver_name="opt", + c_prefix="rocksdb_readoptions", + mode="options", + enum_types=("ReadTier", "Env::IOPriority", "Env::IOActivity"), + enum_c_type="int", + ), + ), +) + +OPTION_STRUCTS_GROUP = OutputGroup( + name="Auto-discovered option structs simple", + header_out=GENERATED_INCLUDE_ROOT / "c_generated_option_structs_auto.h.inc", + source_out=GENERATED_SOURCE_ROOT / "c_generated_option_structs_auto.cc.inc", + families=( + FamilyConfig( + struct_name="DBOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_options", + mode="options", + enum_types=( + "InfoLogLevel", + "WALRecoveryMode", + "CompressionType", + "CacheTier", + "Temperature", + ), + setter_name_overrides=( + ("compaction_readahead_size", "rocksdb_options_compaction_readahead_size"), + ), + ), + FamilyConfig( + struct_name="AdvancedColumnFamilyOptions", + header=INCLUDE_ROOT / "advanced_options.h", + c_receiver_type="rocksdb_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_options", + mode="options", + enum_types=( + "CompressionType", + "CompactionStyle", + "CompactionPri", + "Temperature", + "PrepopulateBlobCache", + "VerifyOutputFlags", + ), + setter_name_overrides=( + ( + "enable_blob_garbage_collection", + "rocksdb_options_set_enable_blob_gc", + ), + ( + "blob_garbage_collection_age_cutoff", + "rocksdb_options_set_blob_gc_age_cutoff", + ), + ( + "blob_garbage_collection_force_threshold", + "rocksdb_options_set_blob_gc_force_threshold", + ), + ), + getter_name_overrides=( + ( + "enable_blob_garbage_collection", + "rocksdb_options_get_enable_blob_gc", + ), + ( + "blob_garbage_collection_age_cutoff", + "rocksdb_options_get_blob_gc_age_cutoff", + ), + ( + "blob_garbage_collection_force_threshold", + "rocksdb_options_get_blob_gc_force_threshold", + ), + ), + ), + FamilyConfig( + struct_name="ColumnFamilyOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_options", + mode="options", + enum_types=("CompressionType",), + ), + FamilyConfig( + struct_name="WriteOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_writeoptions_t*", + c_receiver_name="opt", + c_prefix="rocksdb_writeoptions", + mode="options", + enum_types=("Env::IOPriority", "Env::IOActivity"), + setter_name_overrides=( + ("disableWAL", "rocksdb_writeoptions_disable_WAL"), + ), + ), + FamilyConfig( + struct_name="FlushOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_flushoptions_t*", + c_receiver_name="opt", + c_prefix="rocksdb_flushoptions", + mode="options", + ), + FamilyConfig( + struct_name="FlushWALOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_flushwaloptions_t*", + c_receiver_name="opt", + c_prefix="rocksdb_flushwaloptions", + mode="options", + enum_types=("Env::IOPriority",), + ), + FamilyConfig( + struct_name="EnvOptions", + header=INCLUDE_ROOT / "env.h", + c_receiver_type="rocksdb_envoptions_t*", + c_receiver_name="opt", + c_prefix="rocksdb_envoptions", + mode="options", + setter_name_overrides=( + ("set_fd_cloexec", "rocksdb_envoptions_set_fd_cloexec"), + ), + getter_name_overrides=( + ("set_fd_cloexec", "rocksdb_envoptions_get_fd_cloexec"), + ), + ), + FamilyConfig( + struct_name="TraceOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_trace_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_trace_options", + mode="options", + ), + FamilyConfig( + struct_name="BlockCacheTraceOptions", + header=INCLUDE_ROOT / "block_cache_trace_writer.h", + c_receiver_type="rocksdb_block_cache_trace_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_block_cache_trace_options", + mode="options", + ), + FamilyConfig( + struct_name="BlockCacheTraceWriterOptions", + header=INCLUDE_ROOT / "block_cache_trace_writer.h", + c_receiver_type="rocksdb_block_cache_trace_writer_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_block_cache_trace_writer_options", + mode="options", + ), + FamilyConfig( + struct_name="CompactionOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_compaction_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_compaction_options", + mode="options", + enum_types=("CompressionType", "Temperature"), + ), + FamilyConfig( + struct_name="CompactRangeOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_compactoptions_t*", + c_receiver_name="opt", + c_prefix="rocksdb_compactoptions", + mode="options", + enum_types=("BottommostLevelCompaction", "BlobGarbageCollectionPolicy"), + enum_c_type="int", + ), + FamilyConfig( + struct_name="IngestExternalFileOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_ingestexternalfileoptions_t*", + c_receiver_name="opt", + c_prefix="rocksdb_ingestexternalfileoptions", + mode="options", + ), + FamilyConfig( + struct_name="OpenAndCompactOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_open_and_compact_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_open_and_compact_options", + mode="options", + ), + FamilyConfig( + struct_name="ImportColumnFamilyOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_import_column_family_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_import_column_family_options", + mode="options", + ), + FamilyConfig( + struct_name="SizeApproximationOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_size_approximation_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_size_approximation_options", + mode="options", + ), + FamilyConfig( + struct_name="LiveFilesStorageInfoOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_livefiles_storage_info_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_livefiles_storage_info_options", + mode="options", + ), + FamilyConfig( + struct_name="GetColumnFamilyMetaDataOptions", + header=INCLUDE_ROOT / "metadata.h", + c_receiver_type="rocksdb_column_family_metadata_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_column_family_metadata_options", + mode="options", + ), + FamilyConfig( + struct_name="WaitForCompactOptions", + header=INCLUDE_ROOT / "options.h", + c_receiver_type="rocksdb_wait_for_compact_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_wait_for_compact_options", + mode="options", + ), + FamilyConfig( + struct_name="BlockBasedTableOptions", + header=INCLUDE_ROOT / "table.h", + c_receiver_type="rocksdb_block_based_table_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_block_based_options", + mode="options", + enum_types=( + "IndexType", + "BlockSearchType", + "DataBlockIndexType", + "ChecksumType", + "IndexShorteningMode", + "PrepopulateBlockCache", + ), + ), + FamilyConfig( + struct_name="CuckooTableOptions", + header=INCLUDE_ROOT / "table.h", + c_receiver_type="rocksdb_cuckoo_table_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_cuckoo_options", + mode="options", + ), + FamilyConfig( + struct_name="CompactionOptionsUniversal", + header=INCLUDE_ROOT / "universal_compaction.h", + c_receiver_type="rocksdb_universal_compaction_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_universal_compaction_options", + mode="options", + field_expr_format="{receiver_name}->rep->{field_name}", + enum_types=("CompactionStopStyle",), + ), + FamilyConfig( + struct_name="CompactionOptionsFIFO", + header=INCLUDE_ROOT / "advanced_options.h", + c_receiver_type="rocksdb_fifo_compaction_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_fifo_compaction_options", + mode="options", + ), + FamilyConfig( + struct_name="BackupEngineOptions", + header=INCLUDE_ROOT / "utilities/backup_engine.h", + c_receiver_type="rocksdb_backup_engine_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_backup_engine_options", + mode="options", + enum_types=("ShareFilesNaming",), + ), + FamilyConfig( + struct_name="CreateBackupOptions", + header=INCLUDE_ROOT / "utilities/backup_engine.h", + c_receiver_type="rocksdb_create_backup_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_create_backup_options", + mode="options", + enum_types=("CpuPriority",), + ), + FamilyConfig( + struct_name="RestoreOptions", + header=INCLUDE_ROOT / "utilities/backup_engine.h", + c_receiver_type="rocksdb_restore_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_restore_options", + mode="options", + enum_types=("Mode",), + ), + FamilyConfig( + struct_name="TransactionDBOptions", + header=INCLUDE_ROOT / "utilities/transaction_db.h", + c_receiver_type="rocksdb_transactiondb_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_transactiondb_options", + mode="options", + enum_types=("TxnDBWritePolicy",), + ), + FamilyConfig( + struct_name="TransactionOptions", + header=INCLUDE_ROOT / "utilities/transaction_db.h", + c_receiver_type="rocksdb_transaction_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_transaction_options", + mode="options", + ), + FamilyConfig( + struct_name="OptimisticTransactionOptions", + header=INCLUDE_ROOT / "utilities/optimistic_transaction_db.h", + c_receiver_type="rocksdb_optimistictransaction_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_optimistictransaction_options", + mode="options", + ), + FamilyConfig( + struct_name="OptimisticTransactionDBOptions", + header=INCLUDE_ROOT / "utilities/optimistic_transaction_db.h", + c_receiver_type="rocksdb_optimistictransactiondb_options_t*", + c_receiver_name="opt", + c_prefix="rocksdb_optimistictransactiondb_options", + mode="options", + enum_types=("OccValidationPolicy",), + ), + ), +) + +JOBINFO_GROUP = OutputGroup( + name="Auto-discovered JobInfo metadata simple", + header_out=GENERATED_INCLUDE_ROOT / "c_generated_jobinfo_auto.h.inc", + source_out=GENERATED_SOURCE_ROOT / "c_generated_jobinfo_auto.cc.inc", + families=( + FamilyConfig( + struct_name="FlushJobInfo", + header=INCLUDE_ROOT / "listener.h", + c_receiver_type="const rocksdb_flushjobinfo_t*", + c_receiver_name="info", + c_prefix="rocksdb_flushjobinfo", + mode="metadata", + enum_types=("FlushReason", "CompressionType"), + enum_c_type="uint32_t", + ), + FamilyConfig( + struct_name="CompactionJobInfo", + header=INCLUDE_ROOT / "listener.h", + c_receiver_type="const rocksdb_compactionjobinfo_t*", + c_receiver_name="info", + c_prefix="rocksdb_compactionjobinfo", + mode="metadata", + enum_types=("CompactionReason", "CompressionType"), + enum_c_type="uint32_t", + ), + FamilyConfig( + struct_name="SubcompactionJobInfo", + header=INCLUDE_ROOT / "listener.h", + c_receiver_type="const rocksdb_subcompactionjobinfo_t*", + c_receiver_name="info", + c_prefix="rocksdb_subcompactionjobinfo", + mode="metadata", + enum_types=("CompactionReason", "CompressionType"), + enum_c_type="uint32_t", + ), + FamilyConfig( + struct_name="ExternalFileIngestionInfo", + header=INCLUDE_ROOT / "listener.h", + c_receiver_type="const rocksdb_externalfileingestioninfo_t*", + c_receiver_name="info", + c_prefix="rocksdb_externalfileingestioninfo", + mode="metadata", + ), + FamilyConfig( + struct_name="MemTableInfo", + header=INCLUDE_ROOT / "listener.h", + c_receiver_type="const rocksdb_memtableinfo_t*", + c_receiver_name="info", + c_prefix="rocksdb_memtableinfo", + mode="metadata", + ), + ), +) + +METADATA_VIEW_GROUP = OutputGroup( + name="Auto-discovered metadata view structs simple", + header_out=GENERATED_INCLUDE_ROOT / "c_generated_metadata_structs_auto.h.inc", + source_out=GENERATED_SOURCE_ROOT / "c_generated_metadata_structs_auto.cc.inc", + families=( + FamilyConfig( + struct_name="TableProperties", + header=INCLUDE_ROOT / "table_properties.h", + c_receiver_type="const rocksdb_table_properties_t*", + c_receiver_name="props", + c_prefix="rocksdb_table_properties", + mode="metadata", + ), + FamilyConfig( + struct_name="CompactionJobStats", + header=INCLUDE_ROOT / "compaction_job_stats.h", + c_receiver_type="const rocksdb_compaction_job_stats_t*", + c_receiver_name="stats", + c_prefix="rocksdb_compaction_job_stats", + mode="metadata", + ), + FamilyConfig( + struct_name="CompactionFileInfo", + header=INCLUDE_ROOT / "listener.h", + c_receiver_type="const rocksdb_compaction_file_info_t*", + c_receiver_name="info", + c_prefix="rocksdb_compaction_file_info", + mode="metadata", + ), + FamilyConfig( + struct_name="BlobFileAdditionInfo", + header=INCLUDE_ROOT / "listener.h", + c_receiver_type="const rocksdb_blob_file_addition_info_t*", + c_receiver_name="info", + c_prefix="rocksdb_blob_file_addition_info", + mode="metadata", + ), + FamilyConfig( + struct_name="BlobFileGarbageInfo", + header=INCLUDE_ROOT / "listener.h", + c_receiver_type="const rocksdb_blob_file_garbage_info_t*", + c_receiver_name="info", + c_prefix="rocksdb_blob_file_garbage_info", + mode="metadata", + ), + ), +) + +OUTPUT_GROUPS = ( + READ_OPTIONS_GROUP, + OPTION_STRUCTS_GROUP, + JOBINFO_GROUP, + METADATA_VIEW_GROUP, +) +MANAGED_FAMILY_NAMES = frozenset( + family.struct_name for group in OUTPUT_GROUPS for family in group.families +) +AUTO_OUTPUTS = { + group.header_out.resolve() for group in OUTPUT_GROUPS +} | {group.source_out.resolve() for group in OUTPUT_GROUPS} + +FUNCTION_RE = re.compile(r"\brocksdb_[A-Za-z0-9_]+\b(?=\s*\()") +HEADER_INCLUDE_RE = re.compile(r'^#include "(c_api_gen/[^"]+\.inc)"$', re.MULTILINE) +SOURCE_INCLUDE_RE = re.compile(r'^#include "(c_api_gen/[^"]+\.inc)"$', re.MULTILINE) +TOKEN_RE = re.compile(r"[A-Z]+(?=[A-Z][a-z0-9]|_|$)|[A-Z]?[a-z0-9]+|[A-Z]+") + + +def display_path(path: Path) -> str: + try: + return str(path.relative_to(ROOT)) + except ValueError: + return str(path) + + +def _require_non_empty_string(value: object, context: str, errors: list[str]) -> str | None: + if not isinstance(value, str): + errors.append(f"{context} must be a non-empty string") + return None + stripped = value.strip() + if not stripped: + errors.append(f"{context} must be a non-empty string") + return None + return stripped + + +def load_blocklist(path: Path) -> tuple[dict[str, dict[str, BlocklistEntry]], list[str]]: + rel_path = display_path(path) + try: + raw = json.loads(path.read_text()) + except FileNotFoundError: + return {}, [f"blocklist file not found: {rel_path}"] + except json.JSONDecodeError as exc: + return {}, [ + f"invalid blocklist JSON: {rel_path}:{exc.lineno}:{exc.colno}: {exc.msg}" + ] + + errors: list[str] = [] + blocklist: dict[str, dict[str, BlocklistEntry]] = {} + + if not isinstance(raw, dict): + return {}, [f"blocklist root must be an object: {rel_path}"] + + schema_version = raw.get("schema_version") + if schema_version != 1: + errors.append( + f"unsupported blocklist schema_version in {rel_path}: {schema_version!r}" + ) + + families = raw.get("families") + if not isinstance(families, list): + errors.append(f"{rel_path}: `families` must be a list") + return {}, errors + + seen_families: set[str] = set() + for family_index, family_raw in enumerate(families): + family_context = f"{rel_path}:families[{family_index}]" + if not isinstance(family_raw, dict): + errors.append(f"{family_context} must be an object") + continue + unknown_family_keys = sorted(set(family_raw) - {"name", "entries"}) + if unknown_family_keys: + errors.append( + f"{family_context} has unknown keys: {', '.join(unknown_family_keys)}" + ) + + family_name = _require_non_empty_string( + family_raw.get("name"), f"{family_context}.name", errors + ) + if family_name is None: + continue + if family_name in seen_families: + errors.append(f"duplicate blocklist family: {family_name}") + continue + seen_families.add(family_name) + if family_name not in MANAGED_FAMILY_NAMES: + errors.append(f"unknown blocklist family: {family_name}") + continue + + entries = family_raw.get("entries") + if not isinstance(entries, list): + errors.append(f"{family_context}.entries must be a list") + continue + if not entries: + errors.append(f"{family_context}.entries must not be empty") + continue + + family_entries: dict[str, BlocklistEntry] = {} + for entry_index, entry_raw in enumerate(entries): + entry_context = f"{family_context}.entries[{entry_index}]" + if not isinstance(entry_raw, dict): + errors.append(f"{entry_context} must be an object") + continue + unknown_entry_keys = sorted( + set(entry_raw) - {"field", "policy", "reason", "tracking_issue"} + ) + if unknown_entry_keys: + errors.append( + f"{entry_context} has unknown keys: {', '.join(unknown_entry_keys)}" + ) + + field_name = _require_non_empty_string( + entry_raw.get("field"), f"{entry_context}.field", errors + ) + policy = _require_non_empty_string( + entry_raw.get("policy"), f"{entry_context}.policy", errors + ) + reason = _require_non_empty_string( + entry_raw.get("reason"), f"{entry_context}.reason", errors + ) + + tracking_issue_raw = entry_raw.get("tracking_issue") + tracking_issue: str | None = None + if tracking_issue_raw is not None: + tracking_issue = _require_non_empty_string( + tracking_issue_raw, f"{entry_context}.tracking_issue", errors + ) + + if field_name is None or policy is None or reason is None: + continue + if policy not in BLOCKLIST_POLICIES: + errors.append( + f"{entry_context}.policy must be one of: " + f"{', '.join(sorted(BLOCKLIST_POLICIES))}" + ) + continue + if field_name in family_entries: + errors.append(f"duplicate blocklist entry: {family_name}.{field_name}") + continue + + family_entries[field_name] = BlocklistEntry( + family_name=family_name, + field_name=field_name, + policy=policy, + reason=reason, + tracking_issue=tracking_issue, + ) + + if family_entries: + blocklist[family_name] = family_entries + + return blocklist, errors + + +def iter_json_docs(text: str) -> Iterable[dict]: + decoder = JSONDecoder() + index = 0 + length = len(text) + while index < length: + while index < length and text[index].isspace(): + index += 1 + if index >= length: + return + obj, index = decoder.raw_decode(text, index) + yield obj + + +def _find_clang_binary() -> str: + """Return the clang++ binary to use for AST dumping. + + Resolution order: + 1. a clang token from $CXX -- which may be empty, a single binary, or + compiler-launcher-prefixed and/or versioned (e.g. "ccache clang++-21"); + we use the clang word itself (a bare compiler, not the launcher, since + we run -ast-dump rather than compile) + 2. bare 'clang++' + 3. versioned fallbacks, newest first + Raises RuntimeError if none found. + """ + import os + cxx = os.environ.get("CXX", "") + for token in cxx.split(): + if "clang" in token and shutil.which(token): + return token + for candidate in ( + "clang++", + "clang++-21", + "clang++-20", + "clang++-19", + "clang++-18", + "clang++-17", + "clang++-16", + "clang++-15", + "clang++-14", + "clang++-13", + ): + if shutil.which(candidate): + return candidate + raise RuntimeError( + "clang++ not found. Install clang or set CXX to a clang++ binary. " + "Alternatively, run tools/c_api_gen/regen_all.py on a machine " + "with clang++ and commit the resulting .inc files." + ) + + +_CLANG_BINARY_CACHE: list[str] = [] + + +def get_clang_binary() -> str: + if not _CLANG_BINARY_CACHE: + _CLANG_BINARY_CACHE.append(_find_clang_binary()) + return _CLANG_BINARY_CACHE[0] + + +def walk_ast(node: dict) -> Iterable[dict]: + yield node + for child in node.get("inner", []): + yield from walk_ast(child) + + +def discover_fields(family: FamilyConfig) -> list[tuple[str, str]]: + cmd = [ + get_clang_binary(), + "-std=c++20", + "-Wno-pragma-once-outside-header", + "-I.", + "-I./include", + "-x", + "c++", + "-Xclang", + "-ast-dump=json", + "-Xclang", + f"-ast-dump-filter={family.struct_name}", + "-fsyntax-only", + str(family.header.relative_to(ROOT)), + ] + proc = subprocess.run( + cmd, + cwd=ROOT, + check=True, + text=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + ) + for doc in iter_json_docs(proc.stdout): + for node in walk_ast(doc): + if ( + node.get("kind") in ("RecordDecl", "CXXRecordDecl") + and node.get("name") == family.struct_name + and node.get("completeDefinition") + ): + fields = [] + for child in node.get("inner", []): + if child.get("kind") == "FieldDecl": + fields.append((child["name"], child["type"]["qualType"])) + return fields + raise RuntimeError(f"Could not find AST definition for {family.struct_name}") + + +def collect_function_names(root_file: Path, include_re: re.Pattern[str]) -> set[str]: + names = set(FUNCTION_RE.findall(root_file.read_text())) + for rel in include_re.findall(root_file.read_text()): + include_path = ROOT / Path(rel) + if include_path.resolve() in AUTO_OUTPUTS or not include_path.exists(): + continue + names.update(FUNCTION_RE.findall(include_path.read_text())) + return names + + +def collect_existing_bindings() -> tuple[set[str], set[str]]: + decls = collect_function_names(TEMPLATE_ROOT / "c_base.h", HEADER_INCLUDE_RE) + defs = collect_function_names(TEMPLATE_ROOT / "c_base.cc", SOURCE_INCLUDE_RE) + return decls, defs + + +def normalize_token(token: str) -> str: + if len(token) > 1 and token.isupper(): + return token + return token.lower() + + +def to_c_suffix(name: str) -> str: + tokens = TOKEN_RE.findall(name) + return "_".join(normalize_token(token) for token in tokens) + + +def lookup_override(overrides: tuple[tuple[str, str], ...], field_name: str) -> str | None: + for override_field_name, override_name in overrides: + if override_field_name == field_name: + return override_name + return None + + +def setter_name(family: FamilyConfig, field_name: str) -> str: + override = lookup_override(family.setter_name_overrides, field_name) + if override is not None: + return override + return f"{family.c_prefix}_set_{to_c_suffix(field_name)}" + + +def getter_name(family: FamilyConfig, field_name: str) -> str: + override = lookup_override(family.getter_name_overrides, field_name) + if override is not None: + return override + return f"{family.c_prefix}_get_{to_c_suffix(field_name)}" + + +def scalar_return_type(qual_type: str) -> str | None: + if qual_type in ( + "uint8_t", + "uint32_t", + "uint64_t", + "int", + "int64_t", + "unsigned int", + "size_t", + "double", + ): + return qual_type + if qual_type == "SequenceNumber": + return "uint64_t" + return None + + +def build_option_specs(family: FamilyConfig, field_name: str, qual_type: str) -> list[dict] | None: + expr = family.field_expr_format.format( + receiver_name=family.c_receiver_name, field_name=field_name + ) + setter = setter_name(family, field_name) + getter = getter_name(family, field_name) + if qual_type == "bool": + c_type = "unsigned char" + return [ + { + "kind": "field_setter", + "name": setter, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "value_type": c_type, + "value_name": "v", + "field": expr, + }, + { + "kind": "field_getter", + "name": getter, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "return_type": c_type, + "expr": expr, + }, + ] + + scalar_type = scalar_return_type(qual_type) + if scalar_type is not None: + return [ + { + "kind": "field_setter", + "name": setter, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "value_type": scalar_type, + "value_name": "v", + "field": expr, + }, + { + "kind": "field_getter", + "name": getter, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "return_type": scalar_type, + "expr": expr, + }, + ] + + if qual_type == "std::string": + return [ + { + "kind": "field_setter", + "name": setter, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "value_type": "const char*", + "value_name": "v", + "field": expr, + }, + { + "kind": "string_field_getter", + "name": getter, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "len_type": "size_t*", + "len_name": "size", + "expr": expr, + }, + ] + + if qual_type == "std::chrono::microseconds": + return [ + { + "kind": "field_setter", + "name": setter, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "value_type": "uint64_t", + "value_name": "microseconds", + "field": expr, + "value_expr": "std::chrono::microseconds(microseconds)", + }, + { + "kind": "field_getter", + "name": getter, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "return_type": "uint64_t", + "expr": f"{expr}.count()", + }, + ] + + if qual_type in family.enum_types: + return [ + { + "kind": "field_setter", + "name": setter, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "value_type": family.enum_c_type, + "value_name": "v", + "field": expr, + "value_expr": f"static_cast(v)", + }, + { + "kind": "field_getter", + "name": getter, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "return_type": family.enum_c_type, + "expr": f"static_cast<{family.enum_c_type}>({expr})", + }, + ] + + return None + + +def build_metadata_specs( + family: FamilyConfig, field_name: str, qual_type: str +) -> list[dict] | None: + expr = family.field_expr_format.format( + receiver_name=family.c_receiver_name, field_name=field_name + ) + fn_name = f"{family.c_prefix}_{to_c_suffix(field_name)}" + + if qual_type == "std::string": + return [ + { + "kind": "string_field_getter", + "name": fn_name, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "len_type": "size_t*", + "len_name": "size", + "expr": expr, + } + ] + + if qual_type == "Status": + return [ + { + "kind": "status_getter", + "name": fn_name, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "expr": expr, + } + ] + + if qual_type == "bool": + return [ + { + "kind": "field_getter", + "name": fn_name, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "return_type": "unsigned char", + "expr": expr, + } + ] + + scalar_type = scalar_return_type(qual_type) + if scalar_type is not None: + return [ + { + "kind": "field_getter", + "name": fn_name, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "return_type": scalar_type, + "expr": expr, + } + ] + + if qual_type in family.enum_types: + return [ + { + "kind": "field_getter", + "name": fn_name, + "receiver_type": family.c_receiver_type, + "receiver_name": family.c_receiver_name, + "return_type": family.enum_c_type, + "expr": f"static_cast<{family.enum_c_type}>({expr})", + } + ] + + return None + + +def apply_abi_type_overrides(specs: list[dict] | None) -> list[dict] | None: + """Pin the public C type of already-shipped functions for ABI stability. + + The generated body still assigns/returns through the real C++ field type + via static_cast, so only the C signature is held stable. See + abi_type_overrides.json. + """ + if not specs: + return specs + for spec in specs: + c_type = ABI_TYPE_OVERRIDES.get(spec.get("name", "")) + if c_type is None: + continue + if spec["kind"] == "field_setter": + spec["value_type"] = c_type + # Cast the (ABI-pinned) C value to the actual C++ field type. + spec["value_expr"] = ( + f"static_cast({spec['value_name']})" + ) + elif spec["kind"] == "field_getter": + spec["return_type"] = c_type + spec["expr"] = f"static_cast<{c_type}>({spec['expr']})" + else: + raise ValueError( + f"ABI type override for {spec['name']} targets unsupported " + f"spec kind {spec['kind']!r}" + ) + return specs + + +def build_specs(family: FamilyConfig, field_name: str, qual_type: str) -> list[dict] | None: + if family.mode == "options": + return apply_abi_type_overrides( + build_option_specs(family, field_name, qual_type) + ) + if family.mode == "metadata": + return apply_abi_type_overrides( + build_metadata_specs(family, field_name, qual_type) + ) + raise ValueError(f"Unknown family mode: {family.mode}") + + +def regen_comment_lines(output_group: OutputGroup) -> list[str]: + return [ + "// To regenerate this file:", + "// python3 tools/c_api_gen/auto_simple_bindings.py", + "", + f"// Output group: {output_group.name}", + "", + ] + + +def auto_header_banner(output_group: OutputGroup) -> list[str]: + sources = sorted( + { + str(family.header.relative_to(ROOT)) + for family in output_group.families + } + ) + lines = [ + "// @generated", + "// -----------------------------------------------------------------------------", + "// Auto-generated by tools/c_api_gen/auto_simple_bindings.py.", + "// DO NOT EDIT THIS FILE DIRECTLY.", + "// Sources:", + ] + for source in sources: + lines.append(f"// - {source}") + lines.extend( + [ + f"// - {display_path(BLOCKLIST_PATH)}", + "// - include/rocksdb/c.h", + "// - tools/c_api_gen/c_base.cc", + "// -----------------------------------------------------------------------------", + "", + ] + ) + return lines + + +def render_group(output_group: OutputGroup, functions_by_family: dict[str, list[dict]], mode: str) -> str: + lines: list[str] = [] + lines.extend(auto_header_banner(output_group)) + lines.extend(regen_comment_lines(output_group)) + for family in output_group.families: + section_name = family.section_name or family.struct_name + lines.append(f"/* {section_name} */") + lines.append("") + render = render_decl if mode == "header" else render_impl + for fn in functions_by_family[family.struct_name]: + lines.extend(render(fn)) + lines.append("") + return "\n".join(lines).rstrip() + "\n" + + +def classify_function_coverage( + fn_name: str, decls: set[str], defs: set[str], errors: list[str] +) -> str: + in_decl = fn_name in decls + in_def = fn_name in defs + if in_decl and in_def: + return "covered" + if in_decl and not in_def: + return "missing_def" + if not in_decl and not in_def: + return "missing_both" + errors.append( + f"partial binding coverage: {fn_name} " + f"(declared={in_decl}, defined={in_def})" + ) + return "partial" + + +def generate_groups(blocklist_path: Path) -> tuple[dict[Path, str], list[str]]: + blocklist, errors = load_blocklist(blocklist_path) + decls, defs = collect_existing_bindings() + outputs: dict[Path, str] = {} + + for output_group in OUTPUT_GROUPS: + header_generated: dict[str, list[dict]] = { + family.struct_name: [] for family in output_group.families + } + source_generated: dict[str, list[dict]] = { + family.struct_name: [] for family in output_group.families + } + for family in output_group.families: + fields = discover_fields(family) + blocked_fields = blocklist.get(family.struct_name, {}) + discovered_field_names = {field_name for field_name, _ in fields} + for blocked_field_name in sorted(blocked_fields): + if blocked_field_name not in discovered_field_names: + errors.append( + "stale blocklist entry: " + f"{family.struct_name}.{blocked_field_name} not found in " + f"{family.header.relative_to(ROOT)}" + ) + for field_name, qual_type in fields: + if field_name in blocked_fields: + continue + specs = build_specs(family, field_name, qual_type) + if specs is None: + errors.append( + "unsupported field in managed family: " + f"{family.struct_name}.{field_name} ({qual_type}); " + f"extend auto_simple_bindings.py or add an entry to " + f"{display_path(blocklist_path)}" + ) + continue + for spec in specs: + coverage = classify_function_coverage( + spec["name"], decls, defs, errors + ) + if coverage == "missing_both": + header_generated[family.struct_name].append(spec) + source_generated[family.struct_name].append(spec) + elif coverage == "missing_def": + source_generated[family.struct_name].append(spec) + + outputs[output_group.header_out] = render_group( + output_group, header_generated, "header" + ) + outputs[output_group.source_out] = render_group( + output_group, source_generated, "source" + ) + + return outputs, errors + + +def format_generated_output(path: Path, content: str) -> str: + if CLANG_FORMAT is None: + return content + result = subprocess.run( + [CLANG_FORMAT, "--assume-filename", str(path)], + input=content, + text=True, + capture_output=True, + check=True, + cwd=ROOT, + ) + return result.stdout + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument( + "--check", + action="store_true", + help="fail instead of writing if outputs are stale", + ) + parser.add_argument( + "--blocklist", + type=Path, + default=BLOCKLIST_PATH, + help="path to the checked-in auto-binding blocklist JSON", + ) + args = parser.parse_args() + + blocklist_path = args.blocklist + if not blocklist_path.is_absolute(): + blocklist_path = ROOT / blocklist_path + + outputs, errors = generate_groups(blocklist_path) + if errors: + for error in errors: + print(f"error: {error}", file=sys.stderr) + return 1 + + outputs = { + path: format_generated_output(path, content) + for path, content in outputs.items() + } + + if args.check: + stale = [ + str(path) + for path, content in outputs.items() + if not path.exists() or path.read_text() != content + ] + if stale: + for path in stale: + print(f"stale generated file: {path}", file=sys.stderr) + return 1 + return 0 + + for path, content in outputs.items(): + write_if_changed(path, content) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/c_api_gen/auto_simple_bindings_blocklist.json b/tools/c_api_gen/auto_simple_bindings_blocklist.json new file mode 100644 index 0000000000..069c795754 --- /dev/null +++ b/tools/c_api_gen/auto_simple_bindings_blocklist.json @@ -0,0 +1,590 @@ +{ + "schema_version": 1, + "families": [ + { + "name": "ReadOptions", + "entries": [ + { + "field": "snapshot", + "policy": "manual", + "reason": "Needs pointer, slice, callback, or other non-trivial C binding policy that the simple generator cannot infer." + }, + { + "field": "timestamp", + "policy": "manual", + "reason": "Needs pointer, slice, callback, or other non-trivial C binding policy that the simple generator cannot infer." + }, + { + "field": "iter_start_ts", + "policy": "manual", + "reason": "Needs pointer, slice, callback, or other non-trivial C binding policy that the simple generator cannot infer." + }, + { + "field": "merge_operand_count_threshold", + "policy": "manual", + "reason": "Needs pointer, slice, callback, or other non-trivial C binding policy that the simple generator cannot infer." + }, + { + "field": "iterate_lower_bound", + "policy": "manual", + "reason": "Needs pointer, slice, callback, or other non-trivial C binding policy that the simple generator cannot infer." + }, + { + "field": "iterate_upper_bound", + "policy": "manual", + "reason": "Needs pointer, slice, callback, or other non-trivial C binding policy that the simple generator cannot infer." + }, + { + "field": "table_filter", + "policy": "manual", + "reason": "Needs pointer, slice, callback, or other non-trivial C binding policy that the simple generator cannot infer." + }, + { + "field": "table_index_factory", + "policy": "manual", + "reason": "Needs pointer, slice, callback, or other non-trivial C binding policy that the simple generator cannot infer." + }, + { + "field": "request_id", + "policy": "manual", + "reason": "Needs pointer, slice, callback, or other non-trivial C binding policy that the simple generator cannot infer." + }, + { + "field": "read_scoped_block_buffer_provider", + "policy": "manual", + "reason": "Field type 'ReadScopedBlockBufferProvider *' is a pointer/owning handle to a complex type; needs an explicit C ownership and lifetime design rather than a simple scalar/enum/string wrapper." + } + ] + }, + { + "name": "DBOptions", + "entries": [ + { + "field": "env", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "rate_limiter", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "sst_file_manager", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "info_log", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "statistics", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "db_paths", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "write_buffer_manager", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "listeners", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "row_cache", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "wal_filter", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "file_checksum_gen_factory", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "checksum_handoff_file_types", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "compaction_service", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "calculate_sst_write_lifetime_hint_set", + "policy": "manual", + "reason": "Stores external objects, callback collections, or nested aggregates that need explicit C ownership and lifetime policy." + }, + { + "field": "max_manifest_file_size", + "policy": "manual", + "reason": "ABI type mismatch: legacy C API uses size_t but C++ field is uint64_t. Hand-written binding preserved for ABI compatibility." + }, + { + "field": "writable_file_max_buffer_size", + "policy": "manual", + "reason": "ABI type mismatch: legacy C API uses uint64_t but C++ field is size_t. Hand-written binding preserved for ABI compatibility." + } + ] + }, + { + "name": "AdvancedColumnFamilyOptions", + "entries": [ + { + "field": "inplace_callback", + "policy": "manual", + "reason": "Uses callbacks, factories, vectors, or nested option structs that need explicit C bridging." + }, + { + "field": "memtable_insert_with_hint_prefix_extractor", + "policy": "manual", + "reason": "Uses callbacks, factories, vectors, or nested option structs that need explicit C bridging." + }, + { + "field": "compression_per_level", + "policy": "manual", + "reason": "Uses callbacks, factories, vectors, or nested option structs that need explicit C bridging." + }, + { + "field": "max_bytes_for_level_multiplier_additional", + "policy": "manual", + "reason": "Uses callbacks, factories, vectors, or nested option structs that need explicit C bridging." + }, + { + "field": "compaction_options_universal", + "policy": "manual", + "reason": "Uses callbacks, factories, vectors, or nested option structs that need explicit C bridging." + }, + { + "field": "compaction_options_fifo", + "policy": "manual", + "reason": "Uses callbacks, factories, vectors, or nested option structs that need explicit C bridging." + }, + { + "field": "memtable_factory", + "policy": "manual", + "reason": "Uses callbacks, factories, vectors, or nested option structs that need explicit C bridging." + }, + { + "field": "table_properties_collector_factories", + "policy": "manual", + "reason": "Uses callbacks, factories, vectors, or nested option structs that need explicit C bridging." + }, + { + "field": "blob_cache", + "policy": "manual", + "reason": "Uses callbacks, factories, vectors, or nested option structs that need explicit C bridging." + }, + { + "field": "blob_compression_opts", + "policy": "manual", + "reason": "CompressionOptions is a nested struct; needs explicit C bridging (matches existing compaction_options_universal/fifo pattern)." + }, + { + "field": "blob_direct_write_partition_strategy", + "policy": "manual", + "reason": "std::shared_ptr \u2014 factory/ownership-transfer type; needs explicit C bridging." + }, + { + "field": "soft_pending_compaction_bytes_limit", + "policy": "manual", + "reason": "ABI type mismatch: legacy C API uses size_t but C++ field is uint64_t. Hand-written binding preserved for ABI compatibility." + }, + { + "field": "hard_pending_compaction_bytes_limit", + "policy": "manual", + "reason": "ABI type mismatch: legacy C API uses size_t but C++ field is uint64_t. Hand-written binding preserved for ABI compatibility." + } + ] + }, + { + "name": "ColumnFamilyOptions", + "entries": [ + { + "field": "comparator", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "merge_operator", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "compaction_filter", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "compaction_filter_factory", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "bottommost_compression_opts", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "compression_opts", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "compression_manager", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "prefix_extractor", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "table_factory", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "cf_paths", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "compaction_thread_limiter", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + }, + { + "field": "sst_partitioner_factory", + "policy": "manual", + "reason": "Uses custom components or nested option objects that need hand-designed C bridging." + } + ] + }, + { + "name": "EnvOptions", + "entries": [ + { + "field": "rate_limiter", + "policy": "manual", + "reason": "Stores an external object pointer that needs explicit ownership policy in the C API." + } + ] + }, + { + "name": "CompactionOptions", + "entries": [ + { + "field": "canceled", + "policy": "manual", + "reason": "Uses caller-owned cancellation state that should not be exposed as a blind auto-generated field wrapper." + } + ] + }, + { + "name": "CompactRangeOptions", + "entries": [ + { + "field": "full_history_ts_low", + "policy": "manual", + "reason": "Uses caller-owned cancellation or timestamp state that needs explicit C API policy." + }, + { + "field": "canceled", + "policy": "manual", + "reason": "Uses caller-owned cancellation or timestamp state that needs explicit C API policy." + } + ] + }, + { + "name": "OpenAndCompactOptions", + "entries": [ + { + "field": "canceled", + "policy": "manual", + "reason": "Uses caller-owned cancellation state that should not be exposed as a blind auto-generated field wrapper." + } + ] + }, + { + "name": "GetColumnFamilyMetaDataOptions", + "entries": [ + { + "field": "range", + "policy": "manual", + "reason": "Uses a range object that needs dedicated marshalling rather than a simple scalar binding." + } + ] + }, + { + "name": "BlockBasedTableOptions", + "entries": [ + { + "field": "flush_block_policy_factory", + "policy": "manual", + "reason": "Uses factories, caches, or nested option objects that need explicit ownership or non-scalar marshalling." + }, + { + "field": "metadata_cache_options", + "policy": "manual", + "reason": "Uses factories, caches, or nested option objects that need explicit ownership or non-scalar marshalling." + }, + { + "field": "block_cache", + "policy": "manual", + "reason": "Uses factories, caches, or nested option objects that need explicit ownership or non-scalar marshalling." + }, + { + "field": "persistent_cache", + "policy": "manual", + "reason": "Uses factories, caches, or nested option objects that need explicit ownership or non-scalar marshalling." + }, + { + "field": "cache_usage_options", + "policy": "manual", + "reason": "Uses factories, caches, or nested option objects that need explicit ownership or non-scalar marshalling." + }, + { + "field": "filter_policy", + "policy": "manual", + "reason": "Uses factories, caches, or nested option objects that need explicit ownership or non-scalar marshalling." + }, + { + "field": "user_defined_index_factory", + "policy": "manual", + "reason": "Uses factories, caches, or nested option objects that need explicit ownership or non-scalar marshalling." + } + ] + }, + { + "name": "CompactionOptionsFIFO", + "entries": [ + { + "field": "file_temperature_age_thresholds", + "policy": "manual", + "reason": "Uses collection-style configuration that needs dedicated marshalling rather than a simple scalar binding." + } + ] + }, + { + "name": "BackupEngineOptions", + "entries": [ + { + "field": "backup_env", + "policy": "manual", + "reason": "Stores external objects and rate limiters that need explicit C ownership and lifetime policy." + }, + { + "field": "info_log", + "policy": "manual", + "reason": "Stores external objects and rate limiters that need explicit C ownership and lifetime policy." + }, + { + "field": "backup_rate_limiter", + "policy": "manual", + "reason": "Stores external objects and rate limiters that need explicit C ownership and lifetime policy." + }, + { + "field": "restore_rate_limiter", + "policy": "manual", + "reason": "Stores external objects and rate limiters that need explicit C ownership and lifetime policy." + } + ] + }, + { + "name": "CreateBackupOptions", + "entries": [ + { + "field": "progress_callback", + "policy": "manual", + "reason": "Uses callback hooks that need dedicated C callback plumbing." + }, + { + "field": "exclude_files_callback", + "policy": "manual", + "reason": "Uses callback hooks that need dedicated C callback plumbing." + } + ] + }, + { + "name": "RestoreOptions", + "entries": [ + { + "field": "alternate_dirs", + "policy": "manual", + "reason": "Uses a collection of alternate directories that needs explicit marshalling." + } + ] + }, + { + "name": "TransactionDBOptions", + "entries": [ + { + "field": "custom_mutex_factory", + "policy": "manual", + "reason": "Uses factories, handles, callbacks, or internal collections that need hand-designed C bridging." + }, + { + "field": "lock_mgr_handle", + "policy": "manual", + "reason": "Uses factories, handles, callbacks, or internal collections that need hand-designed C bridging." + }, + { + "field": "rollback_deletion_type_callback", + "policy": "manual", + "reason": "Uses factories, handles, callbacks, or internal collections that need hand-designed C bridging." + }, + { + "field": "secondary_indices", + "policy": "manual", + "reason": "Uses factories, handles, callbacks, or internal collections that need hand-designed C bridging." + }, + { + "field": "wp_snapshot_cache_bits", + "policy": "manual", + "reason": "Uses factories, handles, callbacks, or internal collections that need hand-designed C bridging." + }, + { + "field": "wp_commit_cache_bits", + "policy": "manual", + "reason": "Uses factories, handles, callbacks, or internal collections that need hand-designed C bridging." + }, + { + "field": "autogenerate_name", + "policy": "manual", + "reason": "Uses factories, handles, callbacks, or internal collections that need hand-designed C bridging." + } + ] + }, + { + "name": "OptimisticTransactionOptions", + "entries": [ + { + "field": "cmp", + "policy": "manual", + "reason": "Stores a comparator-like object pointer that needs explicit ownership policy." + } + ] + }, + { + "name": "OptimisticTransactionDBOptions", + "entries": [ + { + "field": "shared_lock_buckets", + "policy": "manual", + "reason": "Uses shared internal synchronization state that should not be exposed as a blind field wrapper." + } + ] + }, + { + "name": "FlushJobInfo", + "entries": [ + { + "field": "table_properties", + "policy": "manual", + "reason": "Returns nested metadata objects that need dedicated accessors rather than a simple scalar getter." + }, + { + "field": "blob_file_addition_infos", + "policy": "manual", + "reason": "Returns nested metadata objects that need dedicated accessors rather than a simple scalar getter." + } + ] + }, + { + "name": "CompactionJobInfo", + "entries": [ + { + "field": "input_files", + "policy": "manual", + "reason": "Returns nested metadata objects or collections that need dedicated accessors rather than a simple scalar getter." + }, + { + "field": "input_file_infos", + "policy": "manual", + "reason": "Returns nested metadata objects or collections that need dedicated accessors rather than a simple scalar getter." + }, + { + "field": "output_files", + "policy": "manual", + "reason": "Returns nested metadata objects or collections that need dedicated accessors rather than a simple scalar getter." + }, + { + "field": "output_file_infos", + "policy": "manual", + "reason": "Returns nested metadata objects or collections that need dedicated accessors rather than a simple scalar getter." + }, + { + "field": "table_properties", + "policy": "manual", + "reason": "Returns nested metadata objects or collections that need dedicated accessors rather than a simple scalar getter." + }, + { + "field": "stats", + "policy": "manual", + "reason": "Returns nested metadata objects or collections that need dedicated accessors rather than a simple scalar getter." + }, + { + "field": "blob_file_addition_infos", + "policy": "manual", + "reason": "Returns nested metadata objects or collections that need dedicated accessors rather than a simple scalar getter." + }, + { + "field": "blob_file_garbage_infos", + "policy": "manual", + "reason": "Returns nested metadata objects or collections that need dedicated accessors rather than a simple scalar getter." + } + ] + }, + { + "name": "SubcompactionJobInfo", + "entries": [ + { + "field": "stats", + "policy": "manual", + "reason": "Returns nested metadata objects that need dedicated accessors rather than a simple scalar getter." + } + ] + }, + { + "name": "ExternalFileIngestionInfo", + "entries": [ + { + "field": "table_properties", + "policy": "manual", + "reason": "Returns nested metadata objects that need dedicated accessors rather than a simple scalar getter." + } + ] + }, + { + "name": "TableProperties", + "entries": [ + { + "field": "user_collected_properties", + "policy": "manual", + "reason": "Returns map-like metadata that needs dedicated marshalling rather than a simple scalar getter." + }, + { + "field": "readable_properties", + "policy": "manual", + "reason": "Returns map-like metadata that needs dedicated marshalling rather than a simple scalar getter." + } + ] + } + ] +} diff --git a/tools/c_api_gen/c_base.cc b/tools/c_api_gen/c_base.cc new file mode 100644 index 0000000000..5a17f9389e --- /dev/null +++ b/tools/c_api_gen/c_base.cc @@ -0,0 +1,8752 @@ +// 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). +// SOURCE TEMPLATE -- DO NOT COMPILE DIRECTLY. +// Edit this file to modify the C API implementation, then run: +// python3 tools/c_api_gen/regen_all.py +// The compiled file is db/c.cc +// + +#include +#include +#include +#include +#include +#include + +#include "port/port.h" +#include "rocksdb/advanced_cache.h" +#include "rocksdb/compaction_filter.h" +#include "rocksdb/comparator.h" +#include "rocksdb/convenience.h" +#include "rocksdb/db.h" +#include "rocksdb/env.h" +#include "rocksdb/experimental.h" +#include "rocksdb/filter_policy.h" +#include "rocksdb/iterator.h" +#include "rocksdb/listener.h" +#include "rocksdb/memtablerep.h" +#include "rocksdb/merge_operator.h" +#include "rocksdb/options.h" +#include "rocksdb/perf_context.h" +#include "rocksdb/rate_limiter.h" +#include "rocksdb/slice_transform.h" +#include "rocksdb/sst_file_manager.h" +#include "rocksdb/statistics.h" +#include "rocksdb/status.h" +#include "rocksdb/table.h" +#include "rocksdb/trace_reader_writer.h" +#include "rocksdb/universal_compaction.h" +#include "rocksdb/user_defined_index.h" +#include "rocksdb/utilities/backup_engine.h" +#include "rocksdb/utilities/checkpoint.h" +#include "rocksdb/utilities/db_ttl.h" +#include "rocksdb/utilities/memory_util.h" +#include "rocksdb/utilities/optimistic_transaction_db.h" +#include "rocksdb/utilities/options_util.h" +#include "rocksdb/utilities/replayer.h" +#include "rocksdb/utilities/table_properties_collectors.h" +#include "rocksdb/utilities/transaction.h" +#include "rocksdb/utilities/transaction_db.h" +#include "rocksdb/utilities/write_batch_with_index.h" +#include "rocksdb/wal_filter.h" +#include "rocksdb/write_batch.h" +#include "rocksdb/write_buffer_manager.h" +#include "util/stderr_logger.h" +#include "utilities/merge_operators.h" + +using ROCKSDB_NAMESPACE::BackgroundErrorReason; +using ROCKSDB_NAMESPACE::BackupEngine; +using ROCKSDB_NAMESPACE::BackupEngineOptions; +using ROCKSDB_NAMESPACE::BackupID; +using ROCKSDB_NAMESPACE::BackupInfo; +using ROCKSDB_NAMESPACE::BatchResult; +using ROCKSDB_NAMESPACE::BlobFileAdditionInfo; +using ROCKSDB_NAMESPACE::BlobFileGarbageInfo; +using ROCKSDB_NAMESPACE::BlockBasedTableOptions; +using ROCKSDB_NAMESPACE::BlockCacheTraceOptions; +using ROCKSDB_NAMESPACE::BlockCacheTraceWriterOptions; +using ROCKSDB_NAMESPACE::BottommostLevelCompaction; +using ROCKSDB_NAMESPACE::BytewiseComparator; +using ROCKSDB_NAMESPACE::Cache; +using ROCKSDB_NAMESPACE::Checkpoint; +using ROCKSDB_NAMESPACE::ColumnFamilyDescriptor; +using ROCKSDB_NAMESPACE::ColumnFamilyHandle; +using ROCKSDB_NAMESPACE::ColumnFamilyMetaData; +using ROCKSDB_NAMESPACE::ColumnFamilyOptions; +using ROCKSDB_NAMESPACE::CompactionFileInfo; +using ROCKSDB_NAMESPACE::CompactionFilter; +using ROCKSDB_NAMESPACE::CompactionFilterFactory; +using ROCKSDB_NAMESPACE::CompactionJobInfo; +using ROCKSDB_NAMESPACE::CompactionJobStats; +using ROCKSDB_NAMESPACE::CompactionOptions; +using ROCKSDB_NAMESPACE::CompactionOptionsFIFO; +using ROCKSDB_NAMESPACE::CompactionReason; +using ROCKSDB_NAMESPACE::CompactionService; +using ROCKSDB_NAMESPACE::CompactionServiceJobInfo; +using ROCKSDB_NAMESPACE::CompactionServiceJobStatus; +using ROCKSDB_NAMESPACE::CompactionServiceOptionsOverride; +using ROCKSDB_NAMESPACE::CompactionServiceScheduleResponse; +using ROCKSDB_NAMESPACE::CompactionStyle; +using ROCKSDB_NAMESPACE::CompactRangeOptions; +using ROCKSDB_NAMESPACE::Comparator; +using ROCKSDB_NAMESPACE::CompressionType; +using ROCKSDB_NAMESPACE::ConfigOptions; +using ROCKSDB_NAMESPACE::CreateBackupOptions; +using ROCKSDB_NAMESPACE::CuckooTableOptions; +using ROCKSDB_NAMESPACE::DB; +using ROCKSDB_NAMESPACE::DBOptions; +using ROCKSDB_NAMESPACE::DbPath; +using ROCKSDB_NAMESPACE::Env; +using ROCKSDB_NAMESPACE::EnvOptions; +using ROCKSDB_NAMESPACE::EventListener; +using ROCKSDB_NAMESPACE::ExportImportFilesMetaData; +using ROCKSDB_NAMESPACE::ExternalFileIngestionInfo; +using ROCKSDB_NAMESPACE::FileChecksumGenFactory; +using ROCKSDB_NAMESPACE::FileLock; +using ROCKSDB_NAMESPACE::FileType; +using ROCKSDB_NAMESPACE::FilterPolicy; +using ROCKSDB_NAMESPACE::FlushJobInfo; +using ROCKSDB_NAMESPACE::FlushOptions; +using ROCKSDB_NAMESPACE::FlushWALOptions; +using ROCKSDB_NAMESPACE::GetColumnFamilyMetaDataOptions; +using ROCKSDB_NAMESPACE::GetFileChecksumGenCrc32cFactory; +using ROCKSDB_NAMESPACE::HistogramData; +using ROCKSDB_NAMESPACE::HyperClockCacheOptions; +using ROCKSDB_NAMESPACE::ImportColumnFamilyOptions; +using ROCKSDB_NAMESPACE::InfoLogLevel; +using ROCKSDB_NAMESPACE::IngestExternalFileOptions; +using ROCKSDB_NAMESPACE::Iterator; +using ROCKSDB_NAMESPACE::LevelMetaData; +using ROCKSDB_NAMESPACE::LiveFileMetaData; +using ROCKSDB_NAMESPACE::LiveFilesStorageInfoOptions; +using ROCKSDB_NAMESPACE::LiveFileStorageInfo; +using ROCKSDB_NAMESPACE::Logger; +using ROCKSDB_NAMESPACE::LRUCacheOptions; +using ROCKSDB_NAMESPACE::MakeSharedOccLockBuckets; +using ROCKSDB_NAMESPACE::MaybeExcludeBackupFile; +using ROCKSDB_NAMESPACE::MemoryAllocator; +using ROCKSDB_NAMESPACE::MemoryUtil; +using ROCKSDB_NAMESPACE::MemTableInfo; +using ROCKSDB_NAMESPACE::MergeOperator; +using ROCKSDB_NAMESPACE::NewBlockCacheTraceWriter; +using ROCKSDB_NAMESPACE::NewBloomFilterPolicy; +using ROCKSDB_NAMESPACE::NewCompactOnDeletionCollectorFactory; +using ROCKSDB_NAMESPACE::NewFileTraceReader; +using ROCKSDB_NAMESPACE::NewFileTraceWriter; +using ROCKSDB_NAMESPACE::NewGenericRateLimiter; +using ROCKSDB_NAMESPACE::NewLRUCache; +using ROCKSDB_NAMESPACE::NewRibbonFilterPolicy; +using ROCKSDB_NAMESPACE::NewSstPartitionerFixedPrefixFactory; +using ROCKSDB_NAMESPACE::OccLockBuckets; +using ROCKSDB_NAMESPACE::OpenAndCompactOptions; +using ROCKSDB_NAMESPACE::OptimisticTransactionDB; +using ROCKSDB_NAMESPACE::OptimisticTransactionDBOptions; +using ROCKSDB_NAMESPACE::OptimisticTransactionOptions; +using ROCKSDB_NAMESPACE::Options; +using ROCKSDB_NAMESPACE::PerfContext; +using ROCKSDB_NAMESPACE::PerfLevel; +using ROCKSDB_NAMESPACE::PinnableSlice; +using ROCKSDB_NAMESPACE::PrepopulateBlobCache; +using ROCKSDB_NAMESPACE::RandomAccessFile; +using ROCKSDB_NAMESPACE::Range; +using ROCKSDB_NAMESPACE::RateLimiter; +using ROCKSDB_NAMESPACE::ReadOptions; +using ROCKSDB_NAMESPACE::Replayer; +using ROCKSDB_NAMESPACE::ReplayOptions; +using ROCKSDB_NAMESPACE::RestoreOptions; +using ROCKSDB_NAMESPACE::SequentialFile; +using ROCKSDB_NAMESPACE::SizeApproximationOptions; +using ROCKSDB_NAMESPACE::Slice; +using ROCKSDB_NAMESPACE::SliceParts; +using ROCKSDB_NAMESPACE::SliceTransform; +using ROCKSDB_NAMESPACE::Snapshot; +using ROCKSDB_NAMESPACE::SstFileManager; +using ROCKSDB_NAMESPACE::SstFileMetaData; +using ROCKSDB_NAMESPACE::SstFileWriter; +using ROCKSDB_NAMESPACE::SstPartitionerFactory; +using ROCKSDB_NAMESPACE::Status; +using ROCKSDB_NAMESPACE::StderrLogger; +using ROCKSDB_NAMESPACE::SubcompactionJobInfo; +using ROCKSDB_NAMESPACE::TableFactory; +using ROCKSDB_NAMESPACE::TableProperties; +using ROCKSDB_NAMESPACE::TablePropertiesCollection; +using ROCKSDB_NAMESPACE::TablePropertiesCollectorFactory; +using ROCKSDB_NAMESPACE::TraceOptions; +using ROCKSDB_NAMESPACE::TraceReader; +using ROCKSDB_NAMESPACE::Transaction; +using ROCKSDB_NAMESPACE::TransactionDB; +using ROCKSDB_NAMESPACE::TransactionDBOptions; +using ROCKSDB_NAMESPACE::TransactionLogIterator; +using ROCKSDB_NAMESPACE::TransactionOptions; +using ROCKSDB_NAMESPACE::UserCollectedProperties; +using ROCKSDB_NAMESPACE::UserDefinedIndexFactory; +using ROCKSDB_NAMESPACE::VectorWalPtr; +using ROCKSDB_NAMESPACE::WaitForCompactOptions; +using ROCKSDB_NAMESPACE::WalFile; +using ROCKSDB_NAMESPACE::WalFilter; +using ROCKSDB_NAMESPACE::WALRecoveryMode; +using ROCKSDB_NAMESPACE::WritableFile; +using ROCKSDB_NAMESPACE::WriteBatch; +using ROCKSDB_NAMESPACE::WriteBatchWithIndex; +using ROCKSDB_NAMESPACE::WriteBufferManager; +using ROCKSDB_NAMESPACE::WriteOptions; +using ROCKSDB_NAMESPACE::WriteStallCondition; +using ROCKSDB_NAMESPACE::WriteStallInfo; + +using std::unordered_set; +using std::vector; + +template +// Returns iterator to the element at position `pos`, or cend() if out of +// bounds. NOTE: O(n) per call due to std::advance on non-random-access +// iterators (std::map). Callers iterating the full map are O(n^2). +static typename MapType::const_iterator GetMapEntryAt(const MapType& map, + size_t pos) { + if (pos >= map.size()) { + return map.cend(); + } + auto it = map.cbegin(); + std::advance(it, pos); + return it; +} + +static std::unique_ptr BuildRanges(int num_ranges, + const char* const* range_start_key, + const size_t* range_start_key_len, + const char* const* range_limit_key, + const size_t* range_limit_key_len) { + std::unique_ptr ranges(new Range[num_ranges]); + for (int i = 0; i < num_ranges; ++i) { + ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]); + ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]); + } + return ranges; +} + +struct rocksdb_wal_file_t { + std::string path_name; + uint64_t log_number = 0; + int type = 0; + uint64_t start_sequence = 0; + uint64_t size_file_bytes = 0; +}; + +static rocksdb_wal_file_t CaptureWalFile(const WalFile& wal_file) { + rocksdb_wal_file_t result; + result.path_name = wal_file.PathName(); + result.log_number = wal_file.LogNumber(); + result.type = static_cast(wal_file.Type()); + result.start_sequence = wal_file.StartSequence(); + result.size_file_bytes = wal_file.SizeFileBytes(); + return result; +} + +extern "C" { + +struct rocksdb_t { + DB* rep; +}; +struct rocksdb_status_ptr_t { + Status* rep; +}; +struct rocksdb_backup_engine_t { + BackupEngine* rep; +}; +struct rocksdb_backup_engine_info_t { + std::vector rep; +}; +struct rocksdb_create_backup_options_t { + CreateBackupOptions rep; + void* progress_state = nullptr; + rocksdb_create_backup_options_progress_cb progress_callback = nullptr; + void* exclude_files_state = nullptr; + rocksdb_create_backup_options_exclude_files_cb exclude_files_callback = + nullptr; +}; +struct rocksdb_restore_options_t { + RestoreOptions rep; +}; +struct rocksdb_iterator_t { + Iterator* rep; +}; +struct rocksdb_writebatch_t { + WriteBatch rep; +}; +struct rocksdb_writebatch_wi_t { + WriteBatchWithIndex* rep; +}; +struct rocksdb_table_properties_t { + TableProperties rep; +}; +struct rocksdb_compaction_job_stats_t { + CompactionJobStats rep; +}; +struct rocksdb_compaction_file_info_t { + CompactionFileInfo rep; +}; +struct rocksdb_blob_file_addition_info_t { + BlobFileAdditionInfo rep; +}; +struct rocksdb_blob_file_garbage_info_t { + BlobFileGarbageInfo rep; +}; +struct rocksdb_walfilter_t : public WalFilter { + void* state_ = nullptr; + void (*destructor_)(void*) = nullptr; + rocksdb_walfilter_column_family_log_number_map_cb + column_family_log_number_map_ = nullptr; + rocksdb_walfilter_log_record_found_cb log_record_found_ = nullptr; + const char* (*name_)(void*) = nullptr; + + rocksdb_walfilter_t() = default; + rocksdb_walfilter_t(const rocksdb_walfilter_t&) = delete; + rocksdb_walfilter_t& operator=(const rocksdb_walfilter_t&) = delete; + rocksdb_walfilter_t(rocksdb_walfilter_t&&) = delete; + rocksdb_walfilter_t& operator=(rocksdb_walfilter_t&&) = delete; + ~rocksdb_walfilter_t() override { + if (destructor_) { + (*destructor_)(state_); + } + } + + void ColumnFamilyLogNumberMap( + const std::map& cf_lognumber_map, + const std::map& cf_name_id_map) override { + if (column_family_log_number_map_ == nullptr) { + return; + } + + std::vector cf_ids; + std::vector log_numbers; + cf_ids.reserve(cf_lognumber_map.size()); + log_numbers.reserve(cf_lognumber_map.size()); + for (const auto& entry : cf_lognumber_map) { + cf_ids.push_back(entry.first); + log_numbers.push_back(entry.second); + } + + std::vector cf_names; + std::vector cf_name_lengths; + std::vector cf_name_ids; + cf_names.reserve(cf_name_id_map.size()); + cf_name_lengths.reserve(cf_name_id_map.size()); + cf_name_ids.reserve(cf_name_id_map.size()); + for (const auto& entry : cf_name_id_map) { + cf_names.push_back(entry.first.data()); + cf_name_lengths.push_back(entry.first.size()); + cf_name_ids.push_back(entry.second); + } + + column_family_log_number_map_(state_, cf_ids.data(), log_numbers.data(), + cf_ids.size(), cf_names.data(), + cf_name_lengths.data(), cf_name_ids.data(), + cf_name_ids.size()); + } + + WalProcessingOption LogRecordFound(unsigned long long log_number, + const std::string& log_file_name, + const WriteBatch& batch, + WriteBatch* new_batch, + bool* batch_changed) override { + if (log_record_found_ == nullptr) { + return WalProcessingOption::kContinueProcessing; + } + + // Avoid deep copy: rocksdb_writebatch_t has WriteBatch as its only member + const rocksdb_writebatch_t* c_batch = + reinterpret_cast(&batch); + rocksdb_writebatch_t c_new_batch = {WriteBatch()}; + unsigned char c_batch_changed = 0; + int option = log_record_found_(state_, log_number, log_file_name.data(), + log_file_name.size(), c_batch, &c_new_batch, + &c_batch_changed); + if (c_batch_changed != 0) { + // c_new_batch is a local about to be destroyed; move instead of copying + // the WriteBatch out of it. + *new_batch = std::move(c_new_batch.rep); + } + *batch_changed = c_batch_changed != 0; + + switch (option) { + case rocksdb_wal_filter_continue_processing: + return WalProcessingOption::kContinueProcessing; + case rocksdb_wal_filter_ignore_current_record: + return WalProcessingOption::kIgnoreCurrentRecord; + case rocksdb_wal_filter_stop_replay: + return WalProcessingOption::kStopReplay; + case rocksdb_wal_filter_corrupted_record: + return WalProcessingOption::kCorruptedRecord; + default: + return WalProcessingOption::kCorruptedRecord; + } + } + + const char* Name() const override { return name_ ? (*name_)(state_) : ""; } +}; +struct rocksdb_snapshot_t { + const Snapshot* rep; +}; +struct rocksdb_flushoptions_t { + FlushOptions rep; +}; +struct rocksdb_flushwaloptions_t { + FlushWALOptions rep; +}; +struct rocksdb_fifo_compaction_options_t { + CompactionOptionsFIFO rep; +}; +struct rocksdb_readoptions_t { + ReadOptions rep; + // stack variables to set pointers to in ReadOptions + Slice upper_bound; + Slice lower_bound; + Slice timestamp; + Slice iter_start_ts; + std::unique_ptr request_id; + void* table_filter_state = nullptr; + void (*table_filter_destructor)(void*) = nullptr; + rocksdb_readoptions_table_filter_cb table_filter_callback = nullptr; + std::shared_ptr table_index_factory; + + ~rocksdb_readoptions_t() { ClearTableFilter(); } + + void ClearTableFilter() { + rep.table_filter = {}; + if (table_filter_destructor != nullptr) { + (*table_filter_destructor)(table_filter_state); + } + table_filter_state = nullptr; + table_filter_destructor = nullptr; + table_filter_callback = nullptr; + } + + void SetTableFilter(void* state, void (*destructor)(void*), + rocksdb_readoptions_table_filter_cb callback) { + ClearTableFilter(); + table_filter_state = state; + table_filter_destructor = destructor; + table_filter_callback = callback; + if (callback != nullptr) { + auto cb = table_filter_callback; + auto filter_state = table_filter_state; + rep.table_filter = [cb, filter_state](const TableProperties& props) { + return cb(filter_state, + reinterpret_cast( + &props)) != 0; + }; + } + } +}; + +struct rocksdb_writeoptions_t { + WriteOptions rep; +}; +struct rocksdb_options_t { + Options rep; +}; +struct rocksdb_compaction_options_t { + CompactionOptions rep; +}; +struct rocksdb_compactoptions_t { + CompactRangeOptions rep; + Slice full_history_ts_low; +}; +struct rocksdb_block_based_table_options_t { + BlockBasedTableOptions rep; + std::shared_ptr user_defined_index_factory; +}; +struct rocksdb_block_cache_trace_options_t { + BlockCacheTraceOptions rep; +}; +struct rocksdb_block_cache_trace_writer_options_t { + BlockCacheTraceWriterOptions rep; +}; +struct rocksdb_cuckoo_table_options_t { + CuckooTableOptions rep; +}; +struct rocksdb_seqfile_t { + SequentialFile* rep; +}; +struct rocksdb_randomfile_t { + RandomAccessFile* rep; +}; +struct rocksdb_writablefile_t { + WritableFile* rep; +}; +struct rocksdb_wal_iterator_t { + TransactionLogIterator* rep; +}; +struct rocksdb_wal_readoptions_t { + TransactionLogIterator::ReadOptions rep; +}; + +struct rocksdb_wal_files_t { + std::vector rep; +}; +struct rocksdb_filelock_t { + FileLock* rep; +}; +struct rocksdb_logger_t { + std::shared_ptr rep; +}; +struct rocksdb_file_checksum_gen_factory_t { + std::shared_ptr rep; +}; +struct rocksdb_sst_partitioner_factory_t { + std::shared_ptr rep; +}; +struct rocksdb_table_properties_collector_factory_t { + std::shared_ptr rep; +}; +struct rocksdb_lru_cache_options_t { + LRUCacheOptions rep; +}; +struct rocksdb_hyper_clock_cache_options_t { + HyperClockCacheOptions rep; +}; +struct rocksdb_memory_allocator_t { + std::shared_ptr rep; +}; +struct rocksdb_cache_t { + std::shared_ptr rep; +}; +struct rocksdb_write_buffer_manager_t { + std::shared_ptr rep; +}; +struct rocksdb_sst_file_manager_t { + std::shared_ptr rep; +}; +struct rocksdb_livefile_t { + LiveFileMetaData rep; +}; +struct rocksdb_livefiles_t { + std::vector rep; +}; +struct rocksdb_column_family_handle_t { + ColumnFamilyHandle* rep; + bool immortal; /* only true for default cf */ +}; +struct rocksdb_column_family_metadata_t { + ColumnFamilyMetaData rep; +}; +struct rocksdb_column_family_metadata_options_t { + GetColumnFamilyMetaDataOptions rep; + std::string start_key; + std::string end_key; + bool has_start_key = false; + bool has_end_key = false; +}; +struct rocksdb_export_import_files_metadata_t { + ExportImportFilesMetaData* rep; +}; +struct rocksdb_import_column_family_options_t { + ImportColumnFamilyOptions rep; +}; +struct rocksdb_level_metadata_t { + const LevelMetaData* rep; +}; +struct rocksdb_sst_file_metadata_t { + const SstFileMetaData* rep; +}; +struct rocksdb_envoptions_t { + EnvOptions rep; + std::shared_ptr rate_limiter; +}; +struct rocksdb_ingestexternalfileoptions_t { + IngestExternalFileOptions rep; +}; +struct rocksdb_trace_options_t { + TraceOptions rep; +}; +struct rocksdb_trace_reader_t { + std::unique_ptr rep; +}; +struct rocksdb_replay_options_t { + ReplayOptions rep; +}; +struct rocksdb_replayer_t { + std::unique_ptr rep; +}; +struct rocksdb_size_approximation_options_t { + SizeApproximationOptions rep; +}; +struct rocksdb_livefiles_storage_info_options_t { + LiveFilesStorageInfoOptions rep; +}; +struct rocksdb_livefiles_storage_info_t { + std::vector rep; +}; +struct rocksdb_sstfilewriter_t { + SstFileWriter* rep; +}; +struct rocksdb_ratelimiter_t { + std::shared_ptr rep; +}; +struct rocksdb_perfcontext_t { + PerfContext* rep; +}; +struct rocksdb_pinnableslice_t { + PinnableSlice rep; +}; +struct rocksdb_transactiondb_options_t { + TransactionDBOptions rep; +}; +struct rocksdb_transactiondb_t { + TransactionDB* rep; +}; +struct rocksdb_transaction_options_t { + TransactionOptions rep; +}; +struct rocksdb_transaction_t { + Transaction* rep; +}; +struct rocksdb_backup_engine_options_t { + BackupEngineOptions rep; +}; +struct rocksdb_checkpoint_t { + Checkpoint* rep; +}; +struct rocksdb_optimistictransactiondb_t { + OptimisticTransactionDB* rep; +}; +struct rocksdb_optimistictransactiondb_options_t { + OptimisticTransactionDBOptions rep; +}; +struct rocksdb_optimistictransactiondb_lock_buckets_t { + std::shared_ptr rep; +}; +struct rocksdb_optimistictransaction_options_t { + OptimisticTransactionOptions rep; +}; +struct rocksdb_wait_for_compact_options_t { + WaitForCompactOptions rep; +}; + +struct rocksdb_compactionfiltercontext_t { + CompactionFilter::Context rep; +}; + +struct rocksdb_flushjobinfo_t { + FlushJobInfo rep; +}; +struct rocksdb_writestallcondition_t { + WriteStallCondition rep; +}; +struct rocksdb_writestallinfo_t { + WriteStallInfo rep; +}; +struct rocksdb_memtableinfo_t { + MemTableInfo rep; +}; +struct rocksdb_compactionjobinfo_t { + CompactionJobInfo rep; +}; +struct rocksdb_subcompactionjobinfo_t { + SubcompactionJobInfo rep; +}; +struct rocksdb_externalfileingestioninfo_t { + ExternalFileIngestionInfo rep; +}; + +struct rocksdb_statistics_histogram_data_t { + rocksdb_statistics_histogram_data_t() : rep() {} + HistogramData rep; +}; + +struct rocksdb_compactionservice_scheduleresponse_t { + CompactionServiceScheduleResponse rep; +}; + +struct rocksdb_compactionservice_jobinfo_t { + CompactionServiceJobInfo rep; +}; +// Layout assertions: these structs must be reinterpret_cast-compatible +// with their rep field (single-member struct, standard-layout). +static_assert(sizeof(rocksdb_writebatch_t) == sizeof(WriteBatch), + "Layout mismatch: rocksdb_writebatch_t vs WriteBatch"); +static_assert(offsetof(rocksdb_writebatch_t, rep) == 0, + "rep must be at offset 0 in rocksdb_writebatch_t"); +static_assert(sizeof(rocksdb_table_properties_t) == sizeof(TableProperties), + "Layout mismatch: rocksdb_table_properties_t vs TableProperties"); +static_assert(offsetof(rocksdb_table_properties_t, rep) == 0, + "rep must be at offset 0 in rocksdb_table_properties_t"); +static_assert(sizeof(rocksdb_blob_file_addition_info_t) == + sizeof(BlobFileAdditionInfo), + "Layout mismatch: rocksdb_blob_file_addition_info_t vs " + "BlobFileAdditionInfo"); +static_assert(offsetof(rocksdb_blob_file_addition_info_t, rep) == 0, + "rep must be at offset 0 in rocksdb_blob_file_addition_info_t"); +static_assert( + sizeof(rocksdb_blob_file_garbage_info_t) == sizeof(BlobFileGarbageInfo), + "Layout mismatch: rocksdb_blob_file_garbage_info_t vs BlobFileGarbageInfo"); +static_assert(offsetof(rocksdb_blob_file_garbage_info_t, rep) == 0, + "rep must be at offset 0 in rocksdb_blob_file_garbage_info_t"); +static_assert( + sizeof(rocksdb_compaction_file_info_t) == sizeof(CompactionFileInfo), + "Layout mismatch: rocksdb_compaction_file_info_t vs CompactionFileInfo"); +static_assert(offsetof(rocksdb_compaction_file_info_t, rep) == 0, + "rep must be at offset 0 in rocksdb_compaction_file_info_t"); +static_assert( + sizeof(rocksdb_compactionjobinfo_t) == sizeof(CompactionJobInfo), + "Layout mismatch: rocksdb_compactionjobinfo_t vs CompactionJobInfo"); +static_assert(offsetof(rocksdb_compactionjobinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_compactionjobinfo_t"); +static_assert( + sizeof(rocksdb_compaction_job_stats_t) == sizeof(CompactionJobStats), + "Layout mismatch: rocksdb_compaction_job_stats_t vs CompactionJobStats"); +static_assert(offsetof(rocksdb_compaction_job_stats_t, rep) == 0, + "rep must be at offset 0 in rocksdb_compaction_job_stats_t"); +static_assert(sizeof(rocksdb_compactionservice_jobinfo_t) == + sizeof(CompactionServiceJobInfo), + "Layout mismatch: rocksdb_compactionservice_jobinfo_t vs " + "CompactionServiceJobInfo"); +static_assert(offsetof(rocksdb_compactionservice_jobinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_compactionservice_jobinfo_t"); +static_assert(sizeof(rocksdb_externalfileingestioninfo_t) == + sizeof(ExternalFileIngestionInfo), + "Layout mismatch: rocksdb_externalfileingestioninfo_t vs " + "ExternalFileIngestionInfo"); +static_assert(offsetof(rocksdb_externalfileingestioninfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_externalfileingestioninfo_t"); +static_assert(sizeof(rocksdb_flushjobinfo_t) == sizeof(FlushJobInfo), + "Layout mismatch: rocksdb_flushjobinfo_t vs FlushJobInfo"); +static_assert(offsetof(rocksdb_flushjobinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_flushjobinfo_t"); +static_assert(sizeof(rocksdb_memtableinfo_t) == sizeof(MemTableInfo), + "Layout mismatch: rocksdb_memtableinfo_t vs MemTableInfo"); +static_assert(offsetof(rocksdb_memtableinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_memtableinfo_t"); +static_assert( + sizeof(rocksdb_subcompactionjobinfo_t) == sizeof(SubcompactionJobInfo), + "Layout mismatch: rocksdb_subcompactionjobinfo_t vs SubcompactionJobInfo"); +static_assert(offsetof(rocksdb_subcompactionjobinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_subcompactionjobinfo_t"); +static_assert(sizeof(rocksdb_writestallinfo_t) == sizeof(WriteStallInfo), + "Layout mismatch: rocksdb_writestallinfo_t vs WriteStallInfo"); +static_assert(offsetof(rocksdb_writestallinfo_t, rep) == 0, + "rep must be at offset 0 in rocksdb_writestallinfo_t"); + +struct rocksdb_compaction_service_options_override_t { + CompactionServiceOptionsOverride rep; +}; + +struct rocksdb_open_and_compact_options_t { + OpenAndCompactOptions rep; +}; + +struct rocksdb_compactionfilter_t : public CompactionFilter { + void* state_; + void (*destructor_)(void*); + unsigned char (*filter_)(void*, int level, const char* key, size_t key_length, + const char* existing_value, size_t value_length, + char** new_value, size_t* new_value_length, + unsigned char* value_changed); + const char* (*name_)(void*); + unsigned char ignore_snapshots_; + + ~rocksdb_compactionfilter_t() override { (*destructor_)(state_); } + + bool Filter(int level, const Slice& key, const Slice& existing_value, + std::string* new_value, bool* value_changed) const override { + char* c_new_value = nullptr; + size_t new_value_length = 0; + unsigned char c_value_changed = 0; + unsigned char result = + (*filter_)(state_, level, key.data(), key.size(), existing_value.data(), + existing_value.size(), &c_new_value, &new_value_length, + &c_value_changed); + if (c_value_changed) { + new_value->assign(c_new_value, new_value_length); + *value_changed = true; + } + return result; + } + + const char* Name() const override { return (*name_)(state_); } + + bool IgnoreSnapshots() const override { return ignore_snapshots_; } +}; + +struct rocksdb_compactionfilterfactory_t : public CompactionFilterFactory { + void* state_; + void (*destructor_)(void*); + rocksdb_compactionfilter_t* (*create_compaction_filter_)( + void*, rocksdb_compactionfiltercontext_t* context); + const char* (*name_)(void*); + + ~rocksdb_compactionfilterfactory_t() override { (*destructor_)(state_); } + + std::unique_ptr CreateCompactionFilter( + const CompactionFilter::Context& context) override { + rocksdb_compactionfiltercontext_t ccontext; + ccontext.rep = context; + CompactionFilter* cf = (*create_compaction_filter_)(state_, &ccontext); + return std::unique_ptr(cf); + } + + const char* Name() const override { return (*name_)(state_); } +}; + +struct rocksdb_comparator_t : public Comparator { + void* state_; + void (*destructor_)(void*); + int (*compare_)(void*, const char* a, size_t alen, const char* b, + size_t blen); + const char* (*name_)(void*); + int (*compare_ts_)(void*, const char* a_ts, size_t a_tslen, const char* b_ts, + size_t b_tslen); + int (*compare_without_ts_)(void*, const char* a, size_t alen, + unsigned char a_has_ts, const char* b, size_t blen, + unsigned char b_has_ts); + + rocksdb_comparator_t() : Comparator() {} + + rocksdb_comparator_t(size_t ts_size) : Comparator(ts_size) {} + + ~rocksdb_comparator_t() override { (*destructor_)(state_); } + + int Compare(const Slice& a, const Slice& b) const override { + return (*compare_)(state_, a.data(), a.size(), b.data(), b.size()); + } + + int CompareTimestamp(const Slice& a_ts, const Slice& b_ts) const override { + if (compare_ts_ == nullptr) { + return 0; + } + return (*compare_ts_)(state_, a_ts.data(), a_ts.size(), b_ts.data(), + b_ts.size()); + } + + int CompareWithoutTimestamp(const Slice& a, bool a_has_ts, const Slice& b, + bool b_has_ts) const override { + if (compare_without_ts_ == nullptr) { + return Compare(a, b); + } + return (*compare_without_ts_)(state_, a.data(), a.size(), a_has_ts, + b.data(), b.size(), b_has_ts); + } + + const char* Name() const override { return (*name_)(state_); } + + // No-ops since the C binding does not support key shortening methods. + void FindShortestSeparator(std::string*, const Slice&) const override {} + void FindShortSuccessor(std::string* /*key*/) const override {} +}; + +struct rocksdb_filterpolicy_t : public FilterPolicy { + void* state_; + void (*destructor_)(void*); + const char* (*name_)(void*); + + ~rocksdb_filterpolicy_t() override { (*destructor_)(state_); } + + const char* Name() const override { return (*name_)(state_); } +}; + +struct rocksdb_mergeoperator_t : public MergeOperator { + void* state_; + void (*destructor_)(void*); + const char* (*name_)(void*); + char* (*full_merge_)(void*, const char* key, size_t key_length, + const char* existing_value, size_t existing_value_length, + const char* const* operands_list, + const size_t* operands_list_length, int num_operands, + unsigned char* success, size_t* new_value_length); + char* (*partial_merge_)(void*, const char* key, size_t key_length, + const char* const* operands_list, + const size_t* operands_list_length, int num_operands, + unsigned char* success, size_t* new_value_length); + void (*delete_value_)(void*, const char* value, size_t value_length); + + ~rocksdb_mergeoperator_t() override { (*destructor_)(state_); } + + const char* Name() const override { return (*name_)(state_); } + + bool FullMergeV2(const MergeOperationInput& merge_in, + MergeOperationOutput* merge_out) const override { + size_t n = merge_in.operand_list.size(); + std::vector operand_pointers(n); + std::vector operand_sizes(n); + for (size_t i = 0; i < n; i++) { + Slice operand(merge_in.operand_list[i]); + operand_pointers[i] = operand.data(); + operand_sizes[i] = operand.size(); + } + + const char* existing_value_data = nullptr; + size_t existing_value_len = 0; + if (merge_in.existing_value != nullptr) { + existing_value_data = merge_in.existing_value->data(); + existing_value_len = merge_in.existing_value->size(); + } + + unsigned char success; + size_t new_value_len; + char* tmp_new_value = (*full_merge_)( + state_, merge_in.key.data(), merge_in.key.size(), existing_value_data, + existing_value_len, operand_pointers.data(), operand_sizes.data(), + static_cast(n), &success, &new_value_len); + merge_out->new_value.assign(tmp_new_value, new_value_len); + + if (delete_value_ != nullptr) { + (*delete_value_)(state_, tmp_new_value, new_value_len); + } else { + free(tmp_new_value); + } + + return success; + } + + bool PartialMergeMulti(const Slice& key, + const std::deque& operand_list, + std::string* new_value, + Logger* /*logger*/) const override { + size_t operand_count = operand_list.size(); + std::vector operand_pointers(operand_count); + std::vector operand_sizes(operand_count); + for (size_t i = 0; i < operand_count; ++i) { + Slice operand(operand_list[i]); + operand_pointers[i] = operand.data(); + operand_sizes[i] = operand.size(); + } + + unsigned char success; + size_t new_value_len; + char* tmp_new_value = (*partial_merge_)( + state_, key.data(), key.size(), operand_pointers.data(), + operand_sizes.data(), static_cast(operand_count), &success, + &new_value_len); + new_value->assign(tmp_new_value, new_value_len); + + if (delete_value_ != nullptr) { + (*delete_value_)(state_, tmp_new_value, new_value_len); + } else { + free(tmp_new_value); + } + + return success; + } +}; + +struct rocksdb_dbpath_t { + DbPath rep; +}; + +struct rocksdb_env_t { + Env* rep; + bool is_default; +}; + +struct rocksdb_slicetransform_t : public SliceTransform { + void* state_; + void (*destructor_)(void*); + const char* (*name_)(void*); + char* (*transform_)(void*, const char* key, size_t length, + size_t* dst_length); + unsigned char (*in_domain_)(void*, const char* key, size_t length); + + ~rocksdb_slicetransform_t() override { (*destructor_)(state_); } + + const char* Name() const override { return (*name_)(state_); } + + Slice Transform(const Slice& src) const override { + size_t len; + char* dst = (*transform_)(state_, src.data(), src.size(), &len); + return Slice(dst, len); + } + + bool InDomain(const Slice& src) const override { + return (*in_domain_)(state_, src.data(), src.size()); + } +}; + +struct rocksdb_universal_compaction_options_t { + ROCKSDB_NAMESPACE::CompactionOptionsUniversal* rep; +}; + +struct rocksdb_callback_logger_t : public Logger { + static const ssize_t STACK_BUFSZ = 512; + rocksdb_callback_logger_t(InfoLogLevel log_level, + void (*logv_cb)(void*, unsigned, char*, size_t), + void* priv) + : Logger(log_level), logv_cb_(logv_cb), priv_(priv) {} + + using Logger::Logv; + void Logv(const InfoLogLevel level, const char* fmt, va_list ap0) override { + char stack_buf[STACK_BUFSZ]; + char* alloc_buf = nullptr; + char* buf = stack_buf; + int len = 0; + va_list ap1; + if (!logv_cb_) { + return; + } + va_copy(ap1, ap0); + len = vsnprintf(buf, STACK_BUFSZ, fmt, ap0); + if (len <= 0) { + goto cleanup; + } else if (len >= STACK_BUFSZ) { + buf = alloc_buf = reinterpret_cast(malloc(len + 1)); + if (!buf) { + goto cleanup; + } + len = vsnprintf(buf, len + 1, fmt, ap1); + if (len <= 0) { + goto cleanup; + } + } + logv_cb_(priv_, unsigned(level), buf, size_t(len)); + cleanup: + va_end(ap1); + free(alloc_buf); + } + + private: + void (*logv_cb_)(void*, unsigned, char*, size_t) = nullptr; + void* priv_ = nullptr; +}; + +static bool SaveError(char** errptr, const Status& s) { + assert(errptr != nullptr); + if (s.ok()) { + return false; + } else if (*errptr == nullptr) { + *errptr = strdup(s.ToString().c_str()); + } else { + // TODO(sanjay): Merge with existing error? + // This is a bug if *errptr is not created by malloc() + free(*errptr); + *errptr = strdup(s.ToString().c_str()); + } + return true; +} + +static const CreateBackupOptions& GetCreateBackupOptions( + const rocksdb_create_backup_options_t* options, + CreateBackupOptions* default_options) { + if (options != nullptr) { + return options->rep; + } + *default_options = CreateBackupOptions(); + return *default_options; +} + +static const FlushWALOptions& GetFlushWALOptions( + const rocksdb_flushwaloptions_t* options, + FlushWALOptions* default_options) { + if (options != nullptr) { + return options->rep; + } + *default_options = FlushWALOptions(); + return *default_options; +} + +static const OptimisticTransactionDBOptions& GetOptimisticTransactionDBOptions( + const rocksdb_optimistictransactiondb_options_t* options, + OptimisticTransactionDBOptions* default_options) { + if (options != nullptr) { + return options->rep; + } + *default_options = OptimisticTransactionDBOptions(); + return *default_options; +} + +static rocksdb_optimistictransactiondb_t* WrapOptimisticTransactionDB( + OptimisticTransactionDB* otxn_db) { + auto* result = new rocksdb_optimistictransactiondb_t; + result->rep = otxn_db; + return result; +} + +// Helper function to copy string data to a malloc'd buffer +// Works with std::string, Slice, and PinnableSlice through implicit conversion +static inline char* CopyString(const Slice& slice) { + char* result = reinterpret_cast(malloc(slice.size())); + memcpy(result, slice.data(), slice.size()); + return result; +} + +static inline char** CopyStringVector(const std::vector& values) { + if (values.empty()) { + return nullptr; + } + char** result = static_cast(malloc(sizeof(char*) * values.size())); + if (result == nullptr) { + return nullptr; + } + for (size_t i = 0; i < values.size(); ++i) { + result[i] = strdup(values[i].c_str()); + } + return result; +} + +static void SyncColumnFamilyMetadataOptionsRange( + rocksdb_column_family_metadata_options_t* options) { + options->rep.range.start = options->has_start_key + ? options->start_key + : ROCKSDB_NAMESPACE::OptSlice(); + options->rep.range.limit = + options->has_end_key ? options->end_key : ROCKSDB_NAMESPACE::OptSlice(); +} + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4190) // C-linkage function returning C++ type +#endif +static Status LoadUserDefinedIndexFactoryFromString( + const char* value, size_t value_len, + std::shared_ptr* factory) { + ConfigOptions config_options; + config_options.ignore_unknown_options = false; + config_options.ignore_unsupported_options = false; + return UserDefinedIndexFactory::CreateFromString( + config_options, std::string(value, value_len), factory); +} +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +const char* rocksdb_compactionservice_jobinfo_t_get_db_name( + const rocksdb_compactionservice_jobinfo_t* info, size_t* len) { + *len = info->rep.db_name.size(); + return info->rep.db_name.data(); +} + +const char* rocksdb_compactionservice_jobinfo_t_get_db_id( + const rocksdb_compactionservice_jobinfo_t* info, size_t* len) { + *len = info->rep.db_id.size(); + return info->rep.db_id.data(); +} + +const char* rocksdb_compactionservice_jobinfo_t_get_db_session_id( + const rocksdb_compactionservice_jobinfo_t* info, size_t* len) { + *len = info->rep.db_session_id.size(); + return info->rep.db_session_id.data(); +} + +const char* rocksdb_compactionservice_jobinfo_t_get_cf_name( + const rocksdb_compactionservice_jobinfo_t* info, size_t* len) { + *len = info->rep.cf_name.size(); + return info->rep.cf_name.data(); +} + +uint32_t rocksdb_compactionservice_jobinfo_t_get_cf_id( + const rocksdb_compactionservice_jobinfo_t* info) { + return info->rep.cf_id; +} + +uint64_t rocksdb_compactionservice_jobinfo_t_get_job_id( + const rocksdb_compactionservice_jobinfo_t* info) { + return info->rep.job_id; +} + +int rocksdb_compactionservice_jobinfo_t_get_priority( + const rocksdb_compactionservice_jobinfo_t* info) { + return static_cast(info->rep.priority); +} + +int rocksdb_compactionservice_jobinfo_t_get_compaction_reason( + const rocksdb_compactionservice_jobinfo_t* info) { + return static_cast(info->rep.compaction_reason); +} + +int rocksdb_compactionservice_jobinfo_t_get_base_input_level( + const rocksdb_compactionservice_jobinfo_t* info) { + return info->rep.base_input_level; +} + +int rocksdb_compactionservice_jobinfo_t_get_output_level( + const rocksdb_compactionservice_jobinfo_t* info) { + return info->rep.output_level; +} + +unsigned char rocksdb_compactionservice_jobinfo_t_is_full_compaction( + const rocksdb_compactionservice_jobinfo_t* info) { + return info->rep.is_full_compaction; +} + +unsigned char rocksdb_compactionservice_jobinfo_t_is_manual_compaction( + const rocksdb_compactionservice_jobinfo_t* info) { + return info->rep.is_manual_compaction; +} + +unsigned char rocksdb_compactionservice_jobinfo_t_is_bottommost_level( + const rocksdb_compactionservice_jobinfo_t* info) { + return info->rep.bottommost_level; +} + +// Helper function to validate compaction service job status +static inline bool IsValidCompactionServiceJobStatus(int status) { + return status >= rocksdb_compactionservice_jobstatus_success && + status <= rocksdb_compactionservice_jobstatus_use_local; +} + +rocksdb_compactionservice_scheduleresponse_t* +rocksdb_compactionservice_scheduleresponse_create(const char* scheduled_job_id, + int status, char** errptr) { + // Validate status is in range [success=0, failure=1, aborted=2, use_local=3] + if (!IsValidCompactionServiceJobStatus(status)) { + SaveError(errptr, + Status::InvalidArgument("Invalid status value. Must be 0-3.")); + return nullptr; + } + + rocksdb_compactionservice_scheduleresponse_t* response = + new rocksdb_compactionservice_scheduleresponse_t{ + CompactionServiceScheduleResponse( + scheduled_job_id ? std::string(scheduled_job_id) : "", + static_cast(status))}; + return response; +} + +rocksdb_compactionservice_scheduleresponse_t* +rocksdb_compactionservice_scheduleresponse_create_with_status(int status, + char** errptr) { + // Validate status is in range [success=0, failure=1, aborted=2, use_local=3] + if (!IsValidCompactionServiceJobStatus(status)) { + SaveError(errptr, + Status::InvalidArgument("Invalid status value. Must be 0-3.")); + return nullptr; + } + + rocksdb_compactionservice_scheduleresponse_t* response = + new rocksdb_compactionservice_scheduleresponse_t{ + CompactionServiceScheduleResponse( + static_cast(status))}; + return response; +} + +void rocksdb_compactionservice_scheduleresponse_t_destroy( + rocksdb_compactionservice_scheduleresponse_t* response) { + if (response) { + delete response; + } +} + +int rocksdb_compactionservice_scheduleresponse_getstatus( + const rocksdb_compactionservice_scheduleresponse_t* response) { + if (!response) { + return rocksdb_compactionservice_jobstatus_failure; + } + return static_cast(response->rep.status); +} + +const char* rocksdb_compactionservice_scheduleresponse_get_scheduled_job_id( + const rocksdb_compactionservice_scheduleresponse_t* response, size_t* len) { + if (!response || !len) { + if (len) { + *len = 0; + } + return ""; + } + *len = response->rep.scheduled_job_id.size(); + return response->rep.scheduled_job_id.data(); +} + +struct rocksdb_compactionservice_t : public CompactionService { + void* state_; + void (*destructor_)(void*); + rocksdb_compaction_service_schedule_cb schedule_; + std::string name_; + rocksdb_compaction_service_wait_cb wait_; + rocksdb_compaction_service_cancel_awaiting_jobs_cb cancel_awaiting_jobs_; + rocksdb_compaction_service_on_installation_cb on_installation_; + + rocksdb_compactionservice_t( + void* state, void (*destructor)(void*), + rocksdb_compaction_service_schedule_cb + rocksdb_compaction_service_schedule_ptr, + const char* name, rocksdb_compaction_service_wait_cb wait, + rocksdb_compaction_service_cancel_awaiting_jobs_cb cancel_awaiting_jobs, + rocksdb_compaction_service_on_installation_cb on_installation) + : state_(state), + destructor_(destructor), + schedule_(rocksdb_compaction_service_schedule_ptr), + name_(name ? name : "CompactionService"), + wait_(wait), + cancel_awaiting_jobs_(cancel_awaiting_jobs), + on_installation_(on_installation) {} + + ~rocksdb_compactionservice_t() override { + if (destructor_) { + (*destructor_)(state_); + } + } + + const char* Name() const override { return name_.c_str(); } + + CompactionServiceScheduleResponse Schedule( + const CompactionServiceJobInfo& info, + const std::string& compaction_service_input) override { + if (schedule_ == nullptr) { + return CompactionServiceScheduleResponse( + CompactionServiceJobStatus::kUseLocal); + } + + rocksdb_compactionservice_scheduleresponse_t* c_response = (*schedule_)( + state_, + reinterpret_cast(&info), + compaction_service_input.data(), compaction_service_input.size()); + + if (c_response == nullptr) { + return CompactionServiceScheduleResponse( + CompactionServiceJobStatus::kFailure); + } + + CompactionServiceScheduleResponse response = std::move(c_response->rep); + delete c_response; + return response; + } + + CompactionServiceJobStatus Wait(const std::string& scheduled_job_id, + std::string* result) override { + if (wait_ == nullptr) { + return CompactionServiceJobStatus::kUseLocal; + } + + char* c_result = nullptr; + size_t result_len = 0; + + int status = + (*wait_)(state_, scheduled_job_id.c_str(), &c_result, &result_len); + + if (c_result != nullptr) { + if (result != nullptr) { + result->assign(c_result, result_len); + } + free(c_result); + } + + return static_cast(status); + } + + void CancelAwaitingJobs() override { + if (cancel_awaiting_jobs_ != nullptr) { + (*cancel_awaiting_jobs_)(state_); + } + } + + void OnInstallation(const std::string& scheduled_job_id, + CompactionServiceJobStatus status) override { + if (on_installation_ != nullptr) { + (*on_installation_)(state_, scheduled_job_id.c_str(), + static_cast(status)); + } + } +}; + +rocksdb_compactionservice_t* rocksdb_compactionservice_create( + void* state, void (*destructor)(void*), + rocksdb_compaction_service_schedule_cb schedule, const char* name, + rocksdb_compaction_service_wait_cb wait, + rocksdb_compaction_service_cancel_awaiting_jobs_cb cancel_awaiting_jobs, + rocksdb_compaction_service_on_installation_cb on_installation) { + return new rocksdb_compactionservice_t(state, destructor, schedule, name, + wait, cancel_awaiting_jobs, + on_installation); +} + +void rocksdb_options_set_compaction_service( + rocksdb_options_t* opt, rocksdb_compactionservice_t* service) { + if (!opt || !service) { + return; + } + + opt->rep.compaction_service = std::shared_ptr(service); +} + +// CompactionServiceOptionsOverride functions +rocksdb_compaction_service_options_override_t* +rocksdb_compaction_service_options_override_create() { + return new rocksdb_compaction_service_options_override_t; +} + +rocksdb_compaction_service_options_override_t* +rocksdb_compaction_service_options_override_create_from_options( + rocksdb_options_t* options) { + if (!options) { + return nullptr; + } + + rocksdb_compaction_service_options_override_t* override_opts = + new rocksdb_compaction_service_options_override_t; + + // Copy all relevant options from rocksdb_options_t + override_opts->rep.env = options->rep.env; + override_opts->rep.file_checksum_gen_factory = + options->rep.file_checksum_gen_factory; + override_opts->rep.comparator = options->rep.comparator; + override_opts->rep.merge_operator = options->rep.merge_operator; + override_opts->rep.compaction_filter = options->rep.compaction_filter; + override_opts->rep.compaction_filter_factory = + options->rep.compaction_filter_factory; + override_opts->rep.prefix_extractor = options->rep.prefix_extractor; + override_opts->rep.table_factory = options->rep.table_factory; + override_opts->rep.sst_partitioner_factory = + options->rep.sst_partitioner_factory; + override_opts->rep.listeners = options->rep.listeners; + override_opts->rep.statistics = options->rep.statistics; + override_opts->rep.info_log = options->rep.info_log; + override_opts->rep.table_properties_collector_factories = + options->rep.table_properties_collector_factories; + + return override_opts; +} + +void rocksdb_compaction_service_options_override_destroy( + rocksdb_compaction_service_options_override_t* override_options) { + if (override_options) { + delete override_options; + } +} + +void rocksdb_compaction_service_options_override_set_env( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_env_t* env) { + if (override_options && env) { + override_options->rep.env = env->rep; + } +} + +void rocksdb_compaction_service_options_override_set_comparator( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_comparator_t* comparator) { + if (override_options && comparator) { + override_options->rep.comparator = comparator; + } +} + +void rocksdb_compaction_service_options_override_set_merge_operator( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_mergeoperator_t* merge_operator) { + if (override_options && merge_operator) { + override_options->rep.merge_operator = + std::shared_ptr(merge_operator); + } +} + +void rocksdb_compaction_service_options_override_set_compaction_filter( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_compactionfilter_t* compaction_filter) { + if (override_options && compaction_filter) { + override_options->rep.compaction_filter = compaction_filter; + } +} + +void rocksdb_compaction_service_options_override_set_compaction_filter_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_compactionfilterfactory_t* compaction_filter_factory) { + if (override_options && compaction_filter_factory) { + override_options->rep.compaction_filter_factory = + std::shared_ptr(compaction_filter_factory); + } +} + +void rocksdb_compaction_service_options_override_set_prefix_extractor( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_slicetransform_t* prefix_extractor) { + if (override_options && prefix_extractor) { + override_options->rep.prefix_extractor = + std::shared_ptr(prefix_extractor); + } +} + +void rocksdb_compaction_service_options_override_set_block_based_table_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_block_based_table_options_t* table_options) { + if (override_options && table_options) { + override_options->rep.table_factory = std::shared_ptr( + NewBlockBasedTableFactory(table_options->rep)); + } +} + +void rocksdb_compaction_service_options_override_set_cuckoo_table_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_cuckoo_table_options_t* table_options) { + if (override_options && table_options) { + override_options->rep.table_factory = std::shared_ptr( + NewCuckooTableFactory(table_options->rep)); + } +} + +// Note: add_event_listener is defined later after rocksdb_eventlistener_t +// struct + +void rocksdb_compaction_service_options_override_set_statistics( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_options_t* options) { + if (override_options && options) { + override_options->rep.statistics = options->rep.statistics; + } +} + +void rocksdb_compaction_service_options_override_set_info_log( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_logger_t* logger) { + if (override_options && logger) { + override_options->rep.info_log = logger->rep; + } +} + +void rocksdb_compaction_service_options_override_set_option( + rocksdb_compaction_service_options_override_t* override_options, + const char* key, const char* value) { + if (override_options && key && value) { + override_options->rep.options_map[std::string(key)] = std::string(value); + } +} + +void rocksdb_compaction_service_options_override_set_file_checksum_gen_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_file_checksum_gen_factory_t* factory) { + if (override_options && factory) { + override_options->rep.file_checksum_gen_factory = factory->rep; + } +} + +void rocksdb_compaction_service_options_override_set_sst_partitioner_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_sst_partitioner_factory_t* factory) { + if (override_options && factory) { + override_options->rep.sst_partitioner_factory = factory->rep; + } +} + +void rocksdb_compaction_service_options_override_add_table_properties_collector_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_table_properties_collector_factory_t* factory) { + if (override_options && factory) { + override_options->rep.table_properties_collector_factories.push_back( + factory->rep); + } +} + +// Atomic bool management for cancellation +unsigned char* rocksdb_open_and_compact_canceled_create() { + return reinterpret_cast(new std::atomic(false)); +} + +void rocksdb_open_and_compact_canceled_destroy(unsigned char* canceled) { + if (canceled) { + delete reinterpret_cast*>(canceled); + } +} + +void rocksdb_open_and_compact_canceled_set(unsigned char* canceled, + unsigned char value) { + if (canceled) { + reinterpret_cast*>(canceled)->store(value != 0); + } +} + +// OpenAndCompactOptions functions +rocksdb_open_and_compact_options_t* rocksdb_open_and_compact_options_create() { + return new rocksdb_open_and_compact_options_t; +} + +void rocksdb_open_and_compact_options_destroy( + rocksdb_open_and_compact_options_t* options) { + if (options) { + delete options; + } +} + +void rocksdb_open_and_compact_options_set_canceled( + rocksdb_open_and_compact_options_t* options, unsigned char* canceled) { + if (options && canceled) { + options->rep.canceled = reinterpret_cast*>(canceled); + } +} + +void rocksdb_open_and_compact_options_set_allow_resumption( + rocksdb_open_and_compact_options_t* options, + unsigned char allow_resumption) { + if (options) { + options->rep.allow_resumption = allow_resumption != 0; + } +} + +// OpenAndCompact functions +char* rocksdb_open_and_compact( + const char* db_path, const char* output_directory, const char* input, + size_t input_len, size_t* output_len, + const rocksdb_compaction_service_options_override_t* override_options, + char** errptr) { + if (!db_path || !output_directory || !input || !override_options) { + SaveError(errptr, Status::InvalidArgument("Invalid arguments")); + return nullptr; + } + + std::string input_str(input, input_len); + std::string output_str; + + Status s = DB::OpenAndCompact(db_path, output_directory, input_str, + &output_str, override_options->rep); + + if (!s.ok()) { + SaveError(errptr, s); + return nullptr; + } + + // Allocate +1 for null terminator + char* result = static_cast(malloc(output_str.size() + 1)); + if (!result) { + SaveError(errptr, Status::MemoryLimit("Failed to allocate output buffer")); + return nullptr; + } + + memcpy(result, output_str.data(), output_str.size()); + result[output_str.size()] = '\0'; + + // Only set output_len after successful allocation + if (output_len) { + *output_len = output_str.size(); + } + + return result; +} + +char* rocksdb_open_and_compact_with_options( + const rocksdb_open_and_compact_options_t* options, const char* db_path, + const char* output_directory, const char* input, size_t input_len, + size_t* output_len, + const rocksdb_compaction_service_options_override_t* override_options, + char** errptr) { + if (!options || !db_path || !output_directory || !input || + !override_options) { + SaveError(errptr, Status::InvalidArgument("Invalid arguments")); + return nullptr; + } + + std::string input_str(input, input_len); + std::string output_str; + + Status s = DB::OpenAndCompact(options->rep, db_path, output_directory, + input_str, &output_str, override_options->rep); + + if (!s.ok()) { + SaveError(errptr, s); + return nullptr; + } + + // Allocate +1 for null terminator + char* result = static_cast(malloc(output_str.size() + 1)); + if (!result) { + SaveError(errptr, Status::MemoryLimit("Failed to allocate output buffer")); + return nullptr; + } + + memcpy(result, output_str.data(), output_str.size()); + result[output_str.size()] = '\0'; // Null terminate + + // Only set output_len after successful allocation + if (output_len) { + *output_len = output_str.size(); + } + + return result; +} + +rocksdb_t* rocksdb_open(const rocksdb_options_t* options, const char* name, + char** errptr) { + std::unique_ptr dbptr; + if (SaveError(errptr, DB::Open(options->rep, std::string(name), &dbptr))) { + return nullptr; + } + rocksdb_t* result = new rocksdb_t; + result->rep = dbptr.release(); + return result; +} + +rocksdb_t* rocksdb_open_with_ttl(const rocksdb_options_t* options, + const char* name, int ttl, char** errptr) { + ROCKSDB_NAMESPACE::DBWithTTL* db; + if (SaveError(errptr, ROCKSDB_NAMESPACE::DBWithTTL::Open( + options->rep, std::string(name), &db, ttl))) { + return nullptr; + } + rocksdb_t* result = new rocksdb_t; + result->rep = db; + return result; +} + +rocksdb_t* rocksdb_open_for_read_only(const rocksdb_options_t* options, + const char* name, + unsigned char error_if_wal_file_exists, + char** errptr) { + std::unique_ptr dbptr; + if (SaveError(errptr, + DB::OpenForReadOnly(options->rep, std::string(name), &dbptr, + error_if_wal_file_exists))) { + return nullptr; + } + rocksdb_t* result = new rocksdb_t; + result->rep = dbptr.release(); + return result; +} + +rocksdb_t* rocksdb_open_as_secondary(const rocksdb_options_t* options, + const char* name, + const char* secondary_path, + char** errptr) { + std::unique_ptr dbptr; + if (SaveError(errptr, + DB::OpenAsSecondary(options->rep, std::string(name), + std::string(secondary_path), &dbptr))) { + return nullptr; + } + rocksdb_t* result = new rocksdb_t; + result->rep = dbptr.release(); + return result; +} + +rocksdb_backup_engine_t* rocksdb_backup_engine_open( + const rocksdb_options_t* options, const char* path, char** errptr) { + BackupEngine* be; + if (SaveError(errptr, BackupEngine::Open( + options->rep.env, + BackupEngineOptions(path, nullptr, true, + options->rep.info_log.get()), + &be))) { + return nullptr; + } + rocksdb_backup_engine_t* result = new rocksdb_backup_engine_t; + result->rep = be; + return result; +} + +rocksdb_backup_engine_t* rocksdb_backup_engine_open_opts( + const rocksdb_backup_engine_options_t* options, rocksdb_env_t* env, + char** errptr) { + BackupEngine* be; + if (SaveError(errptr, BackupEngine::Open(options->rep, env->rep, &be))) { + return nullptr; + } + rocksdb_backup_engine_t* result = new rocksdb_backup_engine_t; + result->rep = be; + return result; +} + +rocksdb_create_backup_options_t* rocksdb_create_backup_options_create() { + return new rocksdb_create_backup_options_t; +} + +void rocksdb_create_backup_options_destroy( + rocksdb_create_backup_options_t* options) { + delete options; +} + +void rocksdb_create_backup_options_set_progress_callback( + rocksdb_create_backup_options_t* options, void* state, + rocksdb_create_backup_options_progress_cb callback) { + options->progress_state = state; + options->progress_callback = callback; + if (callback == nullptr) { + options->rep.progress_callback = {}; + return; + } + auto progress_cb = callback; + auto progress_state = options->progress_state; + options->rep.progress_callback = [progress_cb, progress_state]() { + progress_cb(progress_state); + }; +} + +void rocksdb_create_backup_options_set_exclude_files_callback( + rocksdb_create_backup_options_t* options, void* state, + rocksdb_create_backup_options_exclude_files_cb callback) { + options->exclude_files_state = state; + options->exclude_files_callback = callback; + if (callback == nullptr) { + options->rep.exclude_files_callback = {}; + return; + } + // Capture the callback and state by value (matching progress_callback above) + // rather than the options wrapper pointer, so the lambda does not depend on + // the wrapper outliving it. + options->rep.exclude_files_callback = [callback, state]( + MaybeExcludeBackupFile* files_begin, + MaybeExcludeBackupFile* files_end) { + for (auto* file = files_begin; file != files_end; ++file) { + file->exclude_decision = callback(state, file->info.relative_file.data(), + file->info.relative_file.size()); + } + }; +} + +void rocksdb_backup_engine_create_new_backup(rocksdb_backup_engine_t* be, + rocksdb_t* db, char** errptr) { + SaveError(errptr, be->rep->CreateNewBackup(db->rep)); +} + +void rocksdb_backup_engine_create_new_backup_flush( + rocksdb_backup_engine_t* be, rocksdb_t* db, + unsigned char flush_before_backup, char** errptr) { + SaveError(errptr, be->rep->CreateNewBackup(db->rep, flush_before_backup)); +} + +void rocksdb_backup_engine_create_new_backup_with_options( + rocksdb_backup_engine_t* be, rocksdb_t* db, + const rocksdb_create_backup_options_t* options, uint32_t* backup_id, + char** errptr) { + CreateBackupOptions default_options; + const CreateBackupOptions& effective_options = + GetCreateBackupOptions(options, &default_options); + BackupID new_backup_id = 0; + BackupID* new_backup_id_ptr = backup_id != nullptr ? &new_backup_id : nullptr; + if (!SaveError(errptr, be->rep->CreateNewBackup(effective_options, db->rep, + new_backup_id_ptr)) && + backup_id != nullptr) { + *backup_id = new_backup_id; + } +} + +void rocksdb_backup_engine_create_new_backup_with_metadata( + rocksdb_backup_engine_t* be, rocksdb_t* db, + const rocksdb_create_backup_options_t* options, const char* app_metadata, + size_t app_metadata_len, uint32_t* backup_id, char** errptr) { + CreateBackupOptions default_options; + const CreateBackupOptions& effective_options = + GetCreateBackupOptions(options, &default_options); + const char* effective_app_metadata = + app_metadata != nullptr ? app_metadata : ""; + if (app_metadata == nullptr) { + app_metadata_len = 0; + } + BackupID new_backup_id = 0; + BackupID* new_backup_id_ptr = backup_id != nullptr ? &new_backup_id : nullptr; + if (!SaveError(errptr, + be->rep->CreateNewBackupWithMetadata( + effective_options, db->rep, + std::string(effective_app_metadata, app_metadata_len), + new_backup_id_ptr)) && + backup_id != nullptr) { + *backup_id = new_backup_id; + } +} + +void rocksdb_backup_engine_purge_old_backups(rocksdb_backup_engine_t* be, + uint32_t num_backups_to_keep, + char** errptr) { + SaveError(errptr, be->rep->PurgeOldBackups(num_backups_to_keep)); +} + +rocksdb_restore_options_t* rocksdb_restore_options_create() { + return new rocksdb_restore_options_t; +} + +void rocksdb_restore_options_destroy(rocksdb_restore_options_t* opt) { + delete opt; +} + +void rocksdb_backup_engine_verify_backup(rocksdb_backup_engine_t* be, + uint32_t backup_id, char** errptr) { + SaveError(errptr, be->rep->VerifyBackup(static_cast(backup_id))); +} + +void rocksdb_backup_engine_restore_db_from_latest_backup( + rocksdb_backup_engine_t* be, const char* db_dir, const char* wal_dir, + const rocksdb_restore_options_t* restore_options, char** errptr) { + SaveError(errptr, be->rep->RestoreDBFromLatestBackup(std::string(db_dir), + std::string(wal_dir), + restore_options->rep)); +} + +void rocksdb_backup_engine_restore_db_from_backup( + rocksdb_backup_engine_t* be, const char* db_dir, const char* wal_dir, + const rocksdb_restore_options_t* restore_options, const uint32_t backup_id, + char** errptr) { + SaveError(errptr, be->rep->RestoreDBFromBackup(backup_id, std::string(db_dir), + std::string(wal_dir), + restore_options->rep)); +} + +const rocksdb_backup_engine_info_t* rocksdb_backup_engine_get_backup_info( + rocksdb_backup_engine_t* be) { + rocksdb_backup_engine_info_t* result = new rocksdb_backup_engine_info_t; + be->rep->GetBackupInfo(&result->rep); + return result; +} + +int rocksdb_backup_engine_info_count(const rocksdb_backup_engine_info_t* info) { + return static_cast(info->rep.size()); +} + +int64_t rocksdb_backup_engine_info_timestamp( + const rocksdb_backup_engine_info_t* info, int index) { + return info->rep[index].timestamp; +} + +uint32_t rocksdb_backup_engine_info_backup_id( + const rocksdb_backup_engine_info_t* info, int index) { + return info->rep[index].backup_id; +} + +uint64_t rocksdb_backup_engine_info_size( + const rocksdb_backup_engine_info_t* info, int index) { + return info->rep[index].size; +} + +uint32_t rocksdb_backup_engine_info_number_files( + const rocksdb_backup_engine_info_t* info, int index) { + return info->rep[index].number_files; +} + +const char* rocksdb_backup_engine_info_app_metadata( + const rocksdb_backup_engine_info_t* info, int index, size_t* len) { + const std::string& app_metadata = info->rep[index].app_metadata; + *len = app_metadata.size(); + return app_metadata.data(); +} + +void rocksdb_backup_engine_info_destroy( + const rocksdb_backup_engine_info_t* info) { + delete info; +} + +void rocksdb_backup_engine_stop_backup(rocksdb_backup_engine_t* be) { + be->rep->StopBackup(); +} + +void rocksdb_backup_engine_close(rocksdb_backup_engine_t* be) { + delete be->rep; + delete be; +} + +rocksdb_backup_engine_options_t* rocksdb_backup_engine_options_create( + const char* backup_dir) { + return new rocksdb_backup_engine_options_t{ + BackupEngineOptions(std::string(backup_dir))}; +} + +void rocksdb_backup_engine_options_set_env( + rocksdb_backup_engine_options_t* options, rocksdb_env_t* env) { + options->rep.backup_env = (env ? env->rep : nullptr); +} + +void rocksdb_backup_engine_options_set_backup_rate_limiter( + rocksdb_backup_engine_options_t* options, rocksdb_ratelimiter_t* limiter) { + if (limiter) { + options->rep.backup_rate_limiter = limiter->rep; + } +} + +void rocksdb_backup_engine_options_set_restore_rate_limiter( + rocksdb_backup_engine_options_t* options, rocksdb_ratelimiter_t* limiter) { + if (limiter) { + options->rep.restore_rate_limiter = limiter->rep; + } +} + +void rocksdb_backup_engine_options_destroy( + rocksdb_backup_engine_options_t* options) { + delete options; +} + +void rocksdb_status_ptr_get_error(rocksdb_status_ptr_t* status, char** errptr) { + SaveError(errptr, *(status->rep)); +} + +rocksdb_checkpoint_t* rocksdb_checkpoint_object_create(rocksdb_t* db, + char** errptr) { + Checkpoint* checkpoint; + if (SaveError(errptr, Checkpoint::Create(db->rep, &checkpoint))) { + return nullptr; + } + rocksdb_checkpoint_t* result = new rocksdb_checkpoint_t; + result->rep = checkpoint; + return result; +} + +void rocksdb_checkpoint_create(rocksdb_checkpoint_t* checkpoint, + const char* checkpoint_dir, + uint64_t log_size_for_flush, char** errptr) { + SaveError(errptr, checkpoint->rep->CreateCheckpoint( + std::string(checkpoint_dir), log_size_for_flush)); +} + +rocksdb_export_import_files_metadata_t* rocksdb_checkpoint_export_column_family( + rocksdb_checkpoint_t* checkpoint, + rocksdb_column_family_handle_t* column_family, const char* export_dir, + char** errptr) { + ExportImportFilesMetaData* metadata = nullptr; + if (SaveError(errptr, + checkpoint->rep->ExportColumnFamily( + column_family->rep, std::string(export_dir), &metadata))) { + return nullptr; + } + rocksdb_export_import_files_metadata_t* result = + new rocksdb_export_import_files_metadata_t; + result->rep = metadata; + return result; +} + +void rocksdb_checkpoint_object_destroy(rocksdb_checkpoint_t* checkpoint) { + delete checkpoint->rep; + delete checkpoint; +} + +void rocksdb_close(rocksdb_t* db) { + delete db->rep; + delete db; +} + +void rocksdb_options_set_uint64add_merge_operator(rocksdb_options_t* opt) { + opt->rep.merge_operator = + ROCKSDB_NAMESPACE::MergeOperators::CreateUInt64AddOperator(); +} + +rocksdb_t* rocksdb_open_and_trim_history( + const rocksdb_options_t* db_options, const char* name, + int num_column_families, const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char* trim_ts, + size_t trim_tslen, char** errptr) { + std::vector column_families; + column_families.reserve(num_column_families); + for (int i = 0; i < num_column_families; i++) { + column_families.emplace_back( + std::string(column_family_names[i]), + ColumnFamilyOptions(column_family_options[i]->rep)); + } + + std::string trim_ts_(trim_ts, trim_tslen); + + std::unique_ptr dbptr; + std::vector handles; + if (SaveError(errptr, DB::OpenAndTrimHistory( + DBOptions(db_options->rep), std::string(name), + column_families, &handles, &dbptr, trim_ts_))) { + return nullptr; + } + + for (size_t i = 0; i < handles.size(); i++) { + rocksdb_column_family_handle_t* c_handle = + new rocksdb_column_family_handle_t; + c_handle->rep = handles[i]; + c_handle->immortal = false; + column_family_handles[i] = c_handle; + } + rocksdb_t* result = new rocksdb_t; + result->rep = dbptr.release(); + return result; +} + +rocksdb_t* rocksdb_open_column_families( + const rocksdb_options_t* db_options, const char* name, + int num_column_families, const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr) { + std::vector column_families; + for (int i = 0; i < num_column_families; i++) { + column_families.emplace_back( + std::string(column_family_names[i]), + ColumnFamilyOptions(column_family_options[i]->rep)); + } + + std::unique_ptr dbptr; + std::vector handles; + if (SaveError(errptr, DB::Open(DBOptions(db_options->rep), std::string(name), + column_families, &handles, &dbptr))) { + return nullptr; + } + + for (size_t i = 0; i < handles.size(); i++) { + rocksdb_column_family_handle_t* c_handle = + new rocksdb_column_family_handle_t; + c_handle->rep = handles[i]; + c_handle->immortal = false; + column_family_handles[i] = c_handle; + } + rocksdb_t* result = new rocksdb_t; + result->rep = dbptr.release(); + return result; +} + +rocksdb_t* rocksdb_open_column_families_with_ttl( + const rocksdb_options_t* db_options, const char* name, + int num_column_families, const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, const int* ttls, + char** errptr) { + std::vector ttls_vec; + std::vector column_families; + for (int i = 0; i < num_column_families; i++) { + ttls_vec.push_back(ttls[i]); + + column_families.emplace_back( + std::string(column_family_names[i]), + ColumnFamilyOptions(column_family_options[i]->rep)); + } + + ROCKSDB_NAMESPACE::DBWithTTL* db; + std::vector handles; + if (SaveError(errptr, ROCKSDB_NAMESPACE::DBWithTTL::Open( + DBOptions(db_options->rep), std::string(name), + column_families, &handles, &db, ttls_vec))) { + return nullptr; + } + + for (size_t i = 0; i < handles.size(); i++) { + rocksdb_column_family_handle_t* c_handle = + new rocksdb_column_family_handle_t; + c_handle->rep = handles[i]; + c_handle->immortal = false; + column_family_handles[i] = c_handle; + } + rocksdb_t* result = new rocksdb_t; + result->rep = db; + return result; +} + +rocksdb_t* rocksdb_open_for_read_only_column_families( + const rocksdb_options_t* db_options, const char* name, + int num_column_families, const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, + unsigned char error_if_wal_file_exists, char** errptr) { + std::vector column_families; + for (int i = 0; i < num_column_families; i++) { + column_families.emplace_back( + std::string(column_family_names[i]), + ColumnFamilyOptions(column_family_options[i]->rep)); + } + + std::unique_ptr dbptr; + std::vector handles; + if (SaveError(errptr, DB::OpenForReadOnly(DBOptions(db_options->rep), + std::string(name), column_families, + &handles, &dbptr, + error_if_wal_file_exists))) { + return nullptr; + } + + for (size_t i = 0; i < handles.size(); i++) { + rocksdb_column_family_handle_t* c_handle = + new rocksdb_column_family_handle_t; + c_handle->rep = handles[i]; + c_handle->immortal = false; + column_family_handles[i] = c_handle; + } + rocksdb_t* result = new rocksdb_t; + result->rep = dbptr.release(); + return result; +} + +rocksdb_t* rocksdb_open_as_secondary_column_families( + const rocksdb_options_t* db_options, const char* name, + const char* secondary_path, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr) { + std::vector column_families; + for (int i = 0; i != num_column_families; ++i) { + column_families.emplace_back( + std::string(column_family_names[i]), + ColumnFamilyOptions(column_family_options[i]->rep)); + } + std::unique_ptr dbptr; + std::vector handles; + if (SaveError(errptr, DB::OpenAsSecondary( + DBOptions(db_options->rep), std::string(name), + std::string(secondary_path), column_families, + &handles, &dbptr))) { + return nullptr; + } + for (size_t i = 0; i != handles.size(); ++i) { + rocksdb_column_family_handle_t* c_handle = + new rocksdb_column_family_handle_t; + c_handle->rep = handles[i]; + c_handle->immortal = false; + column_family_handles[i] = c_handle; + } + rocksdb_t* result = new rocksdb_t; + result->rep = dbptr.release(); + return result; +} + +char** rocksdb_list_column_families(const rocksdb_options_t* options, + const char* name, size_t* lencfs, + char** errptr) { + std::vector fams; + SaveError(errptr, DB::ListColumnFamilies(DBOptions(options->rep), + std::string(name), &fams)); + + *lencfs = fams.size(); + char** column_families = + static_cast(malloc(sizeof(char*) * fams.size())); + for (size_t i = 0; i < fams.size(); i++) { + column_families[i] = strdup(fams[i].c_str()); + } + return column_families; +} + +void rocksdb_list_column_families_destroy(char** list, size_t len) { + for (size_t i = 0; i < len; ++i) { + free(list[i]); + } + free(list); +} + +rocksdb_column_family_handle_t* rocksdb_create_column_family( + rocksdb_t* db, const rocksdb_options_t* column_family_options, + const char* column_family_name, char** errptr) { + rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t; + handle->rep = nullptr; + if (SaveError(errptr, db->rep->CreateColumnFamily( + ColumnFamilyOptions(column_family_options->rep), + std::string(column_family_name), &(handle->rep)))) { + delete handle; + return nullptr; + } + handle->immortal = false; + return handle; +} + +rocksdb_column_family_handle_t** rocksdb_create_column_families( + rocksdb_t* db, const rocksdb_options_t* column_family_options, + int num_column_families, const char* const* column_family_names, + size_t* lencfs, char** errptr) { + std::vector handles; + std::vector names; + for (int i = 0; i != num_column_families; ++i) { + names.emplace_back(column_family_names[i]); + } + SaveError(errptr, db->rep->CreateColumnFamilies( + ColumnFamilyOptions(column_family_options->rep), names, + &handles)); + + *lencfs = handles.size(); + rocksdb_column_family_handle_t** c_handles = + static_cast( + malloc(sizeof(rocksdb_column_family_handle_t*) * handles.size())); + for (size_t i = 0; i != handles.size(); ++i) { + c_handles[i] = new rocksdb_column_family_handle_t; + c_handles[i]->rep = handles[i]; + c_handles[i]->immortal = false; + } + + return c_handles; +} + +rocksdb_column_family_handle_t* rocksdb_create_column_family_with_import( + rocksdb_t* db, rocksdb_options_t* column_family_options, + const char* column_family_name, + rocksdb_import_column_family_options_t* import_options, + rocksdb_export_import_files_metadata_t* export_import_files_metadata, + char** errptr) { + rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t; + handle->rep = nullptr; + if (SaveError(errptr, + db->rep->CreateColumnFamilyWithImport( + ColumnFamilyOptions(column_family_options->rep), + std::string(column_family_name), import_options->rep, + *(export_import_files_metadata->rep), &(handle->rep)))) { + delete handle; + return nullptr; + } + handle->immortal = false; + return handle; +} + +void rocksdb_create_column_families_destroy( + rocksdb_column_family_handle_t** list) { + free(list); +} + +rocksdb_column_family_handle_t* rocksdb_create_column_family_with_ttl( + rocksdb_t* db, const rocksdb_options_t* column_family_options, + const char* column_family_name, int ttl, char** errptr) { + ROCKSDB_NAMESPACE::DBWithTTL* db_with_ttl = + static_cast(db->rep); + rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t; + SaveError(errptr, db_with_ttl->CreateColumnFamilyWithTtl( + ColumnFamilyOptions(column_family_options->rep), + std::string(column_family_name), &(handle->rep), ttl)); + handle->immortal = false; + return handle; +} + +void rocksdb_drop_column_family(rocksdb_t* db, + rocksdb_column_family_handle_t* handle, + char** errptr) { + SaveError(errptr, db->rep->DropColumnFamily(handle->rep)); +} + +uint32_t rocksdb_column_family_handle_get_id( + rocksdb_column_family_handle_t* handle) { + return handle->rep->GetID(); +} + +char* rocksdb_column_family_handle_get_name( + rocksdb_column_family_handle_t* handle, size_t* name_len) { + auto name = handle->rep->GetName(); + *name_len = name.size(); + return CopyString(name); +} + +rocksdb_column_family_handle_t* rocksdb_get_default_column_family_handle( + rocksdb_t* db) { + rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t; + handle->rep = db->rep->DefaultColumnFamily(); + handle->immortal = true; + return handle; +} + +void rocksdb_column_family_handle_destroy( + rocksdb_column_family_handle_t* handle) { + if (!handle->immortal) { + delete handle->rep; + } + delete handle; +} + +#include "c_api_gen/c_generated_db_simple_subset.cc.inc" + +void rocksdb_verify_checksum_with_options(rocksdb_t* db, + const rocksdb_readoptions_t* options, + char** errptr) { + ReadOptions default_options; + const ReadOptions& read_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, db->rep->VerifyChecksum(read_options)); +} + +void rocksdb_verify_file_checksums_with_options( + rocksdb_t* db, const rocksdb_readoptions_t* options, char** errptr) { + ReadOptions default_options; + const ReadOptions& read_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, db->rep->VerifyFileChecksums(read_options)); +} + +void rocksdb_increase_full_history_ts_low( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const char* ts_low, size_t ts_lowlen, char** errptr) { + std::string ts(ts_low, ts_lowlen); + SaveError(errptr, db->rep->IncreaseFullHistoryTsLow(column_family->rep, ts)); +} + +char* rocksdb_get_full_history_ts_low( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + size_t* ts_len, char** errptr) { + char* result = nullptr; + std::string tmp; + Status s = db->rep->GetFullHistoryTsLow(column_family->rep, &tmp); + if (s.ok()) { + *ts_len = tmp.size(); + result = CopyString(tmp); + } else { + *ts_len = 0; + SaveError(errptr, s); + } + return result; +} + +char* rocksdb_get(rocksdb_t* db, const rocksdb_readoptions_t* options, + const char* key, size_t keylen, size_t* vallen, + char** errptr) { + char* result = nullptr; + // Use PinnableSlice to avoid unnecessary copy + PinnableSlice pinnable_val; + Status s = db->rep->Get(options->rep, db->rep->DefaultColumnFamily(), + Slice(key, keylen), &pinnable_val); + if (s.ok()) { + *vallen = pinnable_val.size(); + // Only one copy: from PinnableSlice to malloc'd buffer + result = CopyString(pinnable_val); + } else { + *vallen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +char* rocksdb_get_cf(rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, size_t* vallen, + char** errptr) { + char* result = nullptr; + // Use PinnableSlice to avoid unnecessary copy + PinnableSlice pinnable_val; + Status s = db->rep->Get(options->rep, column_family->rep, Slice(key, keylen), + &pinnable_val); + if (s.ok()) { + *vallen = pinnable_val.size(); + // Only one copy: from PinnableSlice to malloc'd buffer + result = CopyString(pinnable_val); + } else { + *vallen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +char* rocksdb_get_with_ts(rocksdb_t* db, const rocksdb_readoptions_t* options, + const char* key, size_t keylen, size_t* vallen, + char** ts, size_t* tslen, char** errptr) { + char* result = nullptr; + std::string tmp_val; + std::string tmp_ts; + Status s = db->rep->Get(options->rep, Slice(key, keylen), &tmp_val, &tmp_ts); + if (s.ok()) { + *vallen = tmp_val.size(); + result = CopyString(tmp_val); + *tslen = tmp_ts.size(); + *ts = CopyString(tmp_ts); + } else { + *vallen = 0; + *tslen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +char* rocksdb_get_cf_with_ts(rocksdb_t* db, + const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t keylen, size_t* vallen, + char** ts, size_t* tslen, char** errptr) { + char* result = nullptr; + std::string tmp; + std::string tmp_ts; + Status s = db->rep->Get(options->rep, column_family->rep, Slice(key, keylen), + &tmp, &tmp_ts); + if (s.ok()) { + *vallen = tmp.size(); + result = CopyString(tmp); + *tslen = tmp_ts.size(); + *ts = CopyString(tmp_ts); + } else { + *vallen = 0; + *tslen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +char* rocksdb_get_db_identity(rocksdb_t* db, size_t* id_len) { + std::string identity_tmp; + Status s = db->rep->GetDbIdentity(identity_tmp); + if (!s.ok()) { + *id_len = 0; + return nullptr; + } + + *id_len = identity_tmp.size(); + return CopyString(identity_tmp); +} + +void rocksdb_multi_get(rocksdb_t* db, const rocksdb_readoptions_t* options, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs) { + // Use unique_ptr for efficiency (avoids vector overhead for fixed-size array) + std::unique_ptr keys(new Slice[num_keys]); + for (size_t i = 0; i < num_keys; i++) { + keys[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + // Use PinnableSlice to avoid unnecessary allocations + auto cfh = db->rep->DefaultColumnFamily(); + std::vector values(num_keys); + std::vector statuses(num_keys); + db->rep->MultiGet(options->rep, cfh, num_keys, keys.get(), values.data(), + statuses.data()); + for (size_t i = 0; i < num_keys; i++) { + if (statuses[i].ok()) { + values_list[i] = CopyString(values[i]); + values_list_sizes[i] = values[i].size(); + errs[i] = nullptr; + } else { + values_list[i] = nullptr; + values_list_sizes[i] = 0; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } +} + +void rocksdb_multi_get_with_ts(rocksdb_t* db, + const rocksdb_readoptions_t* options, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, + char** values_list, size_t* values_list_sizes, + char** timestamp_list, + size_t* timestamp_list_sizes, char** errs) { + // Use unique_ptr for efficiency + std::unique_ptr keys_arr(new Slice[num_keys]); + for (size_t i = 0; i < num_keys; i++) { + keys_arr[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + // Note: MultiGet with timestamps only has vector-based API + std::vector keys(keys_arr.get(), keys_arr.get() + num_keys); + std::vector values(num_keys); + std::vector timestamps(num_keys); + std::vector statuses = + db->rep->MultiGet(options->rep, keys, &values, ×tamps); + for (size_t i = 0; i < num_keys; i++) { + if (statuses[i].ok()) { + values_list[i] = CopyString(values[i]); + values_list_sizes[i] = values[i].size(); + timestamp_list[i] = CopyString(timestamps[i]); + timestamp_list_sizes[i] = timestamps[i].size(); + errs[i] = nullptr; + } else { + values_list[i] = nullptr; + values_list_sizes[i] = 0; + timestamp_list[i] = nullptr; + timestamp_list_sizes[i] = 0; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } +} + +void rocksdb_multi_get_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + const rocksdb_column_family_handle_t* const* column_families, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs) { + // Use unique_ptr for efficiency (avoids vector overhead for fixed-size + // arrays) + std::unique_ptr keys(new Slice[num_keys]); + std::unique_ptr cfs(new ColumnFamilyHandle*[num_keys]); + for (size_t i = 0; i < num_keys; i++) { + keys[i] = Slice(keys_list[i], keys_list_sizes[i]); + cfs[i] = column_families[i]->rep; + } + // Use PinnableSlice to avoid unnecessary allocations + std::vector values(num_keys); + std::vector statuses(num_keys); + db->rep->MultiGet(options->rep, num_keys, cfs.get(), keys.get(), + values.data(), statuses.data()); + for (size_t i = 0; i < num_keys; i++) { + if (statuses[i].ok()) { + values_list[i] = CopyString(values[i]); + values_list_sizes[i] = values[i].size(); + errs[i] = nullptr; + } else { + values_list[i] = nullptr; + values_list_sizes[i] = 0; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } +} + +void rocksdb_multi_get_cf_with_ts( + rocksdb_t* db, const rocksdb_readoptions_t* options, + const rocksdb_column_family_handle_t* const* column_families, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** timestamps_list, + size_t* timestamps_list_sizes, char** errs) { + // Use unique_ptr for efficiency (avoids vector overhead for fixed-size + // arrays) + std::unique_ptr keys(new Slice[num_keys]); + std::unique_ptr cfs(new ColumnFamilyHandle*[num_keys]); + for (size_t i = 0; i < num_keys; i++) { + keys[i] = Slice(keys_list[i], keys_list_sizes[i]); + cfs[i] = column_families[i]->rep; + } + // Use PinnableSlice to avoid unnecessary allocations + std::vector values(num_keys); + std::vector timestamps(num_keys); + std::vector statuses(num_keys); + db->rep->MultiGet(options->rep, num_keys, cfs.get(), keys.get(), + values.data(), timestamps.data(), statuses.data()); + for (size_t i = 0; i < num_keys; i++) { + if (statuses[i].ok()) { + values_list[i] = CopyString(values[i]); + values_list_sizes[i] = values[i].size(); + timestamps_list[i] = CopyString(timestamps[i]); + timestamps_list_sizes[i] = timestamps[i].size(); + errs[i] = nullptr; + } else { + values_list[i] = nullptr; + values_list_sizes[i] = 0; + timestamps_list[i] = nullptr; + timestamps_list_sizes[i] = 0; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } +} + +void rocksdb_batched_multi_get_cf(rocksdb_t* db, + const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, + rocksdb_pinnableslice_t** values, char** errs, + const bool sorted_input) { + Slice* key_slices = new Slice[num_keys]; + PinnableSlice* value_slices = new PinnableSlice[num_keys]; + Status* statuses = new Status[num_keys]; + for (size_t i = 0; i < num_keys; ++i) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + + db->rep->MultiGet(options->rep, column_family->rep, num_keys, key_slices, + value_slices, statuses, sorted_input); + + for (size_t i = 0; i < num_keys; ++i) { + if (statuses[i].ok()) { + values[i] = new (rocksdb_pinnableslice_t); + values[i]->rep = std::move(value_slices[i]); + errs[i] = nullptr; + } else { + values[i] = nullptr; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } + + delete[] key_slices; + delete[] value_slices; + delete[] statuses; +} + +// Batched MultiGet that takes pre-built Slice array, avoiding key conversion +// overhead +void rocksdb_batched_multi_get_cf_slice( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, size_t num_keys, + const rocksdb_slice_t* keys_list, rocksdb_pinnableslice_t** values, + char** errs, const bool sorted_input) { + PinnableSlice* value_slices = new PinnableSlice[num_keys]; + Status* statuses = new Status[num_keys]; + + // Cast rocksdb_slice_t* to Slice* - they have identical memory layout + const Slice* key_slices = reinterpret_cast(keys_list); + + db->rep->MultiGet(options->rep, column_family->rep, num_keys, key_slices, + value_slices, statuses, sorted_input); + + for (size_t i = 0; i < num_keys; ++i) { + if (statuses[i].ok()) { + values[i] = new (rocksdb_pinnableslice_t); + values[i]->rep = std::move(value_slices[i]); + errs[i] = nullptr; + } else { + values[i] = nullptr; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } + + delete[] value_slices; + delete[] statuses; +} + +unsigned char rocksdb_key_may_exist(rocksdb_t* db, + const rocksdb_readoptions_t* options, + const char* key, size_t key_len, + char** value, size_t* val_len, + const char* timestamp, size_t timestamp_len, + unsigned char* value_found) { + std::string tmp; + std::string time; + if (timestamp) { + time.assign(timestamp, timestamp_len); + } + bool found = false; + const bool result = db->rep->KeyMayExist(options->rep, Slice(key, key_len), + &tmp, timestamp ? &time : nullptr, + value_found ? &found : nullptr); + if (value_found) { + *value_found = found; + if (found) { + *val_len = tmp.size(); + *value = CopyString(tmp); + } + } + return result; +} + +unsigned char rocksdb_key_may_exist_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t key_len, char** value, size_t* val_len, const char* timestamp, + size_t timestamp_len, unsigned char* value_found) { + std::string tmp; + std::string time; + if (timestamp) { + time.assign(timestamp, timestamp_len); + } + bool found = false; + const bool result = db->rep->KeyMayExist( + options->rep, column_family->rep, Slice(key, key_len), &tmp, + timestamp ? &time : nullptr, value_found ? &found : nullptr); + if (value_found) { + *value_found = found; + if (found) { + *val_len = tmp.size(); + *value = CopyString(tmp); + } + } + return result; +} + +rocksdb_iterator_t* rocksdb_create_iterator( + rocksdb_t* db, const rocksdb_readoptions_t* options) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; + result->rep = db->rep->NewIterator(options->rep); + return result; +} + +rocksdb_wal_iterator_t* rocksdb_get_updates_since( + rocksdb_t* db, uint64_t seq_number, + const rocksdb_wal_readoptions_t* options, char** errptr) { + std::unique_ptr iter; + TransactionLogIterator::ReadOptions ro; + if (options != nullptr) { + ro = options->rep; + } + if (SaveError(errptr, db->rep->GetUpdatesSince(seq_number, &iter, ro))) { + return nullptr; + } + rocksdb_wal_iterator_t* result = new rocksdb_wal_iterator_t; + result->rep = iter.release(); + return result; +} + +rocksdb_wal_files_t* rocksdb_get_sorted_wal_files(rocksdb_t* db, + char** errptr) { + auto* result = new rocksdb_wal_files_t; + VectorWalPtr wal_files; + if (SaveError(errptr, db->rep->GetSortedWalFiles(wal_files))) { + delete result; + return nullptr; + } + result->rep.reserve(wal_files.size()); + for (const auto& wal_file : wal_files) { + result->rep.push_back(CaptureWalFile(*wal_file)); + } + return result; +} + +rocksdb_wal_file_t* rocksdb_get_current_wal_file(rocksdb_t* db, char** errptr) { + std::unique_ptr wal_file; + if (SaveError(errptr, db->rep->GetCurrentWalFile(&wal_file))) { + return nullptr; + } + auto* result = new rocksdb_wal_file_t; + *result = CaptureWalFile(*wal_file); + return result; +} + +void rocksdb_wal_iter_next(rocksdb_wal_iterator_t* iter) { iter->rep->Next(); } + +unsigned char rocksdb_wal_iter_valid(const rocksdb_wal_iterator_t* iter) { + return iter->rep->Valid(); +} + +void rocksdb_wal_iter_status(const rocksdb_wal_iterator_t* iter, + char** errptr) { + SaveError(errptr, iter->rep->status()); +} + +void rocksdb_wal_iter_destroy(const rocksdb_wal_iterator_t* iter) { + delete iter->rep; + delete iter; +} + +rocksdb_wal_readoptions_t* rocksdb_wal_readoptions_create() { + return new rocksdb_wal_readoptions_t; +} + +void rocksdb_wal_readoptions_destroy(rocksdb_wal_readoptions_t* options) { + delete options; +} + +void rocksdb_wal_readoptions_set_verify_checksums( + rocksdb_wal_readoptions_t* options, unsigned char verify_checksums) { + options->rep.verify_checksums_ = verify_checksums != 0; +} + +unsigned char rocksdb_wal_readoptions_get_verify_checksums( + rocksdb_wal_readoptions_t* options) { + return options->rep.verify_checksums_; +} + +const char* rocksdb_wal_file_path_name(const rocksdb_wal_file_t* file) { + return file->path_name.c_str(); +} + +uint64_t rocksdb_wal_file_log_number(const rocksdb_wal_file_t* file) { + return file->log_number; +} + +int rocksdb_wal_file_type(const rocksdb_wal_file_t* file) { return file->type; } + +uint64_t rocksdb_wal_file_start_sequence(const rocksdb_wal_file_t* file) { + return file->start_sequence; +} + +uint64_t rocksdb_wal_file_size_file_bytes(const rocksdb_wal_file_t* file) { + return file->size_file_bytes; +} + +void rocksdb_wal_file_destroy(rocksdb_wal_file_t* file) { delete file; } + +size_t rocksdb_wal_files_count(const rocksdb_wal_files_t* files) { + return files->rep.size(); +} + +const rocksdb_wal_file_t* rocksdb_wal_files_get_wal_file( + const rocksdb_wal_files_t* files, size_t index) { + if (index >= files->rep.size()) { + return nullptr; + } + return &files->rep[index]; +} + +void rocksdb_wal_files_destroy(rocksdb_wal_files_t* files) { delete files; } + +rocksdb_writebatch_t* rocksdb_wal_iter_get_batch( + const rocksdb_wal_iterator_t* iter, uint64_t* seq) { + rocksdb_writebatch_t* result = rocksdb_writebatch_create(); + BatchResult wal_batch = iter->rep->GetBatch(); + result->rep = std::move(*wal_batch.writeBatchPtr); + if (seq != nullptr) { + *seq = wal_batch.sequence; + } + return result; +} + +uint64_t rocksdb_get_latest_sequence_number(rocksdb_t* db) { + return db->rep->GetLatestSequenceNumber(); +} + +rocksdb_iterator_t* rocksdb_create_iterator_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; + result->rep = db->rep->NewIterator(options->rep, column_family->rep); + return result; +} + +void rocksdb_create_iterators(rocksdb_t* db, rocksdb_readoptions_t* opts, + rocksdb_column_family_handle_t** column_families, + rocksdb_iterator_t** iterators, size_t size, + char** errptr) { + std::vector column_families_vec; + for (size_t i = 0; i < size; i++) { + column_families_vec.push_back(column_families[i]->rep); + } + + std::vector res; + Status status = db->rep->NewIterators(opts->rep, column_families_vec, &res); + assert(res.size() == size); + if (SaveError(errptr, status)) { + return; + } + + for (size_t i = 0; i < size; i++) { + iterators[i] = new rocksdb_iterator_t; + iterators[i]->rep = res[i]; + } +} + +const rocksdb_snapshot_t* rocksdb_create_snapshot(rocksdb_t* db) { + rocksdb_snapshot_t* result = new rocksdb_snapshot_t; + result->rep = db->rep->GetSnapshot(); + return result; +} + +void rocksdb_release_snapshot(rocksdb_t* db, + const rocksdb_snapshot_t* snapshot) { + db->rep->ReleaseSnapshot(snapshot->rep); + delete snapshot; +} + +uint64_t rocksdb_snapshot_get_sequence_number( + const rocksdb_snapshot_t* snapshot) { + return snapshot->rep->GetSequenceNumber(); +} + +char* rocksdb_property_value(rocksdb_t* db, const char* propname) { + std::string tmp; + if (db->rep->GetProperty(Slice(propname), &tmp)) { + // We use strdup() since we expect human readable output. + return strdup(tmp.c_str()); + } else { + return nullptr; + } +} + +int rocksdb_property_int(rocksdb_t* db, const char* propname, + uint64_t* out_val) { + if (db->rep->GetIntProperty(Slice(propname), out_val)) { + return 0; + } else { + return -1; + } +} + +int rocksdb_property_int_cf(rocksdb_t* db, + rocksdb_column_family_handle_t* column_family, + const char* propname, uint64_t* out_val) { + if (db->rep->GetIntProperty(column_family->rep, Slice(propname), out_val)) { + return 0; + } else { + return -1; + } +} + +char* rocksdb_property_value_cf(rocksdb_t* db, + rocksdb_column_family_handle_t* column_family, + const char* propname) { + std::string tmp; + if (db->rep->GetProperty(column_family->rep, Slice(propname), &tmp)) { + // We use strdup() since we expect human readable output. + return strdup(tmp.c_str()); + } else { + return nullptr; + } +} + +void rocksdb_approximate_sizes(rocksdb_t* db, int num_ranges, + const char* const* range_start_key, + const size_t* range_start_key_len, + const char* const* range_limit_key, + const size_t* range_limit_key_len, + uint64_t* sizes, char** errptr) { + auto ranges = BuildRanges(num_ranges, range_start_key, range_start_key_len, + range_limit_key, range_limit_key_len); + Status s = db->rep->GetApproximateSizes(ranges.get(), num_ranges, sizes); + if (!s.ok()) { + SaveError(errptr, s); + } +} + +void rocksdb_approximate_sizes_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + int num_ranges, const char* const* range_start_key, + const size_t* range_start_key_len, const char* const* range_limit_key, + const size_t* range_limit_key_len, uint64_t* sizes, char** errptr) { + auto ranges = BuildRanges(num_ranges, range_start_key, range_start_key_len, + range_limit_key, range_limit_key_len); + Status s = db->rep->GetApproximateSizes(column_family->rep, ranges.get(), + num_ranges, sizes); + if (!s.ok()) { + SaveError(errptr, s); + } +} + +extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_cf_with_flags( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + int num_ranges, const char* const* range_start_key, + const size_t* range_start_key_len, const char* const* range_limit_key, + const size_t* range_limit_key_len, uint8_t include_flags, uint64_t* sizes, + char** errptr) { + auto ranges = BuildRanges(num_ranges, range_start_key, range_start_key_len, + range_limit_key, range_limit_key_len); + Status s = db->rep->GetApproximateSizes( + column_family->rep, ranges.get(), num_ranges, sizes, + static_cast(include_flags)); + if (!s.ok()) { + SaveError(errptr, s); + } +} + +rocksdb_size_approximation_options_t* +rocksdb_size_approximation_options_create() { + return new rocksdb_size_approximation_options_t; +} + +void rocksdb_size_approximation_options_destroy( + rocksdb_size_approximation_options_t* options) { + delete options; +} + +void rocksdb_approximate_sizes_with_options( + rocksdb_t* db, const rocksdb_size_approximation_options_t* options, + int num_ranges, const char* const* range_start_key, + const size_t* range_start_key_len, const char* const* range_limit_key, + const size_t* range_limit_key_len, uint64_t* sizes, char** errptr) { + auto ranges = BuildRanges(num_ranges, range_start_key, range_start_key_len, + range_limit_key, range_limit_key_len); + SizeApproximationOptions default_options; + const SizeApproximationOptions& size_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, db->rep->GetApproximateSizes( + size_options, db->rep->DefaultColumnFamily(), + ranges.get(), num_ranges, sizes)); +} + +void rocksdb_approximate_sizes_cf_with_options( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const rocksdb_size_approximation_options_t* options, int num_ranges, + const char* const* range_start_key, const size_t* range_start_key_len, + const char* const* range_limit_key, const size_t* range_limit_key_len, + uint64_t* sizes, char** errptr) { + auto ranges = BuildRanges(num_ranges, range_start_key, range_start_key_len, + range_limit_key, range_limit_key_len); + SizeApproximationOptions default_options; + const SizeApproximationOptions& size_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, + db->rep->GetApproximateSizes(size_options, column_family->rep, + ranges.get(), num_ranges, sizes)); +} + +const rocksdb_livefiles_t* rocksdb_livefiles(rocksdb_t* db) { + rocksdb_livefiles_t* result = new rocksdb_livefiles_t; + db->rep->GetLiveFilesMetaData(&result->rep); + return result; +} + +void rocksdb_compact_range(rocksdb_t* db, const char* start_key, + size_t start_key_len, const char* limit_key, + size_t limit_key_len) { + Slice a; + Slice b; + db->rep->CompactRange( + CompactRangeOptions(), + // Pass nullptr Slice if corresponding "const char*" is nullptr + (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), + (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)); +} + +void rocksdb_compact_range_cf(rocksdb_t* db, + rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, + const char* limit_key, size_t limit_key_len) { + Slice a; + Slice b; + db->rep->CompactRange( + CompactRangeOptions(), column_family->rep, + // Pass nullptr Slice if corresponding "const char*" is nullptr + (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), + (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)); +} + +void rocksdb_suggest_compact_range(rocksdb_t* db, const char* start_key, + size_t start_key_len, const char* limit_key, + size_t limit_key_len, char** errptr) { + Slice a; + Slice b; + Status s = ROCKSDB_NAMESPACE::experimental::SuggestCompactRange( + db->rep, + (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), + (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)); + SaveError(errptr, s); +} + +void rocksdb_suggest_compact_range_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, const char* limit_key, + size_t limit_key_len, char** errptr) { + Slice a; + Slice b; + Status s = db->rep->SuggestCompactRange( + column_family->rep, + (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), + (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)); + SaveError(errptr, s); +} + +void rocksdb_compact_range_opt(rocksdb_t* db, rocksdb_compactoptions_t* opt, + const char* start_key, size_t start_key_len, + const char* limit_key, size_t limit_key_len) { + Slice a; + Slice b; + db->rep->CompactRange( + opt->rep, + // Pass nullptr Slice if corresponding "const char*" is nullptr + (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), + (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)); +} + +void rocksdb_compact_range_cf_opt(rocksdb_t* db, + rocksdb_column_family_handle_t* column_family, + rocksdb_compactoptions_t* opt, + const char* start_key, size_t start_key_len, + const char* limit_key, size_t limit_key_len) { + Slice a; + Slice b; + db->rep->CompactRange( + opt->rep, column_family->rep, + // Pass nullptr Slice if corresponding "const char*" is nullptr + (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), + (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)); +} + +void rocksdb_compact_files_output_file_names_destroy( + char** output_file_names, size_t num_output_file_names) { + rocksdb_list_column_families_destroy(output_file_names, + num_output_file_names); +} + +void rocksdb_compact_files(rocksdb_t* db, + const rocksdb_compaction_options_t* options, + const char* const* input_file_names, + size_t num_input_file_names, int output_level, + int output_path_id, char*** output_file_names, + size_t* num_output_file_names, + rocksdb_compactionjobinfo_t* compaction_job_info, + char** errptr) { + rocksdb_compact_files_cf(db, nullptr, options, input_file_names, + num_input_file_names, output_level, output_path_id, + output_file_names, num_output_file_names, + compaction_job_info, errptr); +} + +void rocksdb_compact_files_cf(rocksdb_t* db, + rocksdb_column_family_handle_t* column_family, + const rocksdb_compaction_options_t* options, + const char* const* input_file_names, + size_t num_input_file_names, int output_level, + int output_path_id, char*** output_file_names, + size_t* num_output_file_names, + rocksdb_compactionjobinfo_t* compaction_job_info, + char** errptr) { + std::vector input_files; + input_files.reserve(num_input_file_names); + for (size_t i = 0; i < num_input_file_names; ++i) { + input_files.emplace_back(input_file_names[i]); + } + + std::vector output_files; + std::vector* output_files_ptr = + output_file_names != nullptr ? &output_files : nullptr; + CompactionOptions default_options; + const CompactionOptions* compaction_options = + options != nullptr ? &options->rep : &default_options; + ColumnFamilyHandle* cf_handle = column_family != nullptr + ? column_family->rep + : db->rep->DefaultColumnFamily(); + CompactionJobInfo* job_info = + compaction_job_info != nullptr ? &compaction_job_info->rep : nullptr; + + Status s = db->rep->CompactFiles(*compaction_options, cf_handle, input_files, + output_level, output_path_id, + output_files_ptr, job_info); + if (SaveError(errptr, s)) { + return; + } + + if (num_output_file_names != nullptr) { + *num_output_file_names = output_files.size(); + } + if (output_file_names != nullptr) { + *output_file_names = CopyStringVector(output_files); + } +} + +void rocksdb_flush_cfs(rocksdb_t* db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t** column_families, + int num_column_families, char** errptr) { + std::vector column_family_handles; + column_family_handles.reserve(num_column_families); + for (int i = 0; i < num_column_families; i++) { + column_family_handles.push_back(column_families[i]->rep); + } + + SaveError(errptr, db->rep->Flush(options->rep, column_family_handles)); +} + +void rocksdb_iter_destroy(rocksdb_iterator_t* iter) { + delete iter->rep; + delete iter; +} + +unsigned char rocksdb_iter_valid(const rocksdb_iterator_t* iter) { + return iter->rep->Valid(); +} + +void rocksdb_iter_seek_to_first(rocksdb_iterator_t* iter) { + iter->rep->SeekToFirst(); +} + +void rocksdb_iter_seek_to_last(rocksdb_iterator_t* iter) { + iter->rep->SeekToLast(); +} + +void rocksdb_iter_seek(rocksdb_iterator_t* iter, const char* k, size_t klen) { + iter->rep->Seek(Slice(k, klen)); +} + +void rocksdb_iter_seek_for_prev(rocksdb_iterator_t* iter, const char* k, + size_t klen) { + iter->rep->SeekForPrev(Slice(k, klen)); +} + +void rocksdb_iter_next(rocksdb_iterator_t* iter) { iter->rep->Next(); } + +void rocksdb_iter_prev(rocksdb_iterator_t* iter) { iter->rep->Prev(); } + +const char* rocksdb_iter_key(const rocksdb_iterator_t* iter, size_t* klen) { + Slice s = iter->rep->key(); + *klen = s.size(); + return s.data(); +} + +const char* rocksdb_iter_value(const rocksdb_iterator_t* iter, size_t* vlen) { + Slice s = iter->rep->value(); + *vlen = s.size(); + return s.data(); +} + +const char* rocksdb_iter_timestamp(const rocksdb_iterator_t* iter, + size_t* tslen) { + Slice s = iter->rep->timestamp(); + *tslen = s.size(); + return s.data(); +} + +void rocksdb_iter_get_error(const rocksdb_iterator_t* iter, char** errptr) { + SaveError(errptr, iter->rep->status()); +} + +// Iterator functions that return rocksdb_slice_t directly for better +// performance +rocksdb_slice_t rocksdb_iter_key_slice(const rocksdb_iterator_t* iter) { + Slice s = iter->rep->key(); + rocksdb_slice_t result; + result.data = s.data(); + result.size = s.size(); + return result; +} + +rocksdb_slice_t rocksdb_iter_value_slice(const rocksdb_iterator_t* iter) { + Slice s = iter->rep->value(); + rocksdb_slice_t result; + result.data = s.data(); + result.size = s.size(); + return result; +} + +rocksdb_slice_t rocksdb_iter_timestamp_slice(const rocksdb_iterator_t* iter) { + Slice s = iter->rep->timestamp(); + rocksdb_slice_t result; + result.data = s.data(); + result.size = s.size(); + return result; +} + +void rocksdb_iter_refresh(const rocksdb_iterator_t* iter, char** errptr) { + SaveError(errptr, iter->rep->Refresh()); +} + +rocksdb_writebatch_t* rocksdb_writebatch_create() { + return new rocksdb_writebatch_t; +} + +rocksdb_writebatch_t* rocksdb_writebatch_create_from(const char* rep, + size_t size) { + rocksdb_writebatch_t* b = new rocksdb_writebatch_t; + b->rep = WriteBatch(std::string(rep, size)); + return b; +} + +rocksdb_writebatch_t* rocksdb_writebatch_create_with_params( + size_t reserved_bytes, size_t max_bytes, size_t protection_bytes_per_key, + size_t default_cf_ts_sz) { + rocksdb_writebatch_t* b = new rocksdb_writebatch_t; + b->rep = WriteBatch(reserved_bytes, max_bytes, protection_bytes_per_key, + default_cf_ts_sz); + return b; +} + +void rocksdb_writebatch_destroy(rocksdb_writebatch_t* b) { delete b; } + +int rocksdb_writebatch_count(rocksdb_writebatch_t* b) { return b->rep.Count(); } + +#include "c_api_gen/c_generated_writebatch_subset.cc.inc" + +void rocksdb_writebatch_put_cf_with_ts( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* ts, size_t tslen, const char* val, + size_t vlen) { + b->rep.Put(column_family->rep, Slice(key, klen), Slice(ts, tslen), + Slice(val, vlen)); +} + +void rocksdb_writebatch_putv(rocksdb_writebatch_t* b, int num_keys, + const char* const* keys_list, + const size_t* keys_list_sizes, int num_values, + const char* const* values_list, + const size_t* values_list_sizes) { + // Use unique_ptr instead of vector to avoid overhead + // Safe because WriteBatch::Put immediately copies the data + std::unique_ptr key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + std::unique_ptr value_slices(new Slice[num_values]); + for (int i = 0; i < num_values; i++) { + value_slices[i] = Slice(values_list[i], values_list_sizes[i]); + } + b->rep.Put(SliceParts(key_slices.get(), num_keys), + SliceParts(value_slices.get(), num_values)); +} + +void rocksdb_writebatch_putv_cf(rocksdb_writebatch_t* b, + rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, int num_values, + const char* const* values_list, + const size_t* values_list_sizes) { + // Use unique_ptr instead of vector to avoid overhead + // Safe because WriteBatch::Put immediately copies the data + std::unique_ptr key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + std::unique_ptr value_slices(new Slice[num_values]); + for (int i = 0; i < num_values; i++) { + value_slices[i] = Slice(values_list[i], values_list_sizes[i]); + } + b->rep.Put(column_family->rep, SliceParts(key_slices.get(), num_keys), + SliceParts(value_slices.get(), num_values)); +} + +void rocksdb_writebatch_merge(rocksdb_writebatch_t* b, const char* key, + size_t klen, const char* val, size_t vlen) { + b->rep.Merge(Slice(key, klen), Slice(val, vlen)); +} + +void rocksdb_writebatch_merge_cf(rocksdb_writebatch_t* b, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, + size_t vlen) { + b->rep.Merge(column_family->rep, Slice(key, klen), Slice(val, vlen)); +} + +void rocksdb_writebatch_mergev(rocksdb_writebatch_t* b, int num_keys, + const char* const* keys_list, + const size_t* keys_list_sizes, int num_values, + const char* const* values_list, + const size_t* values_list_sizes) { + // Use unique_ptr instead of vector to avoid overhead + // Safe because WriteBatch::Merge immediately copies the data + std::unique_ptr key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + std::unique_ptr value_slices(new Slice[num_values]); + for (int i = 0; i < num_values; i++) { + value_slices[i] = Slice(values_list[i], values_list_sizes[i]); + } + b->rep.Merge(SliceParts(key_slices.get(), num_keys), + SliceParts(value_slices.get(), num_values)); +} + +void rocksdb_writebatch_mergev_cf(rocksdb_writebatch_t* b, + rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, int num_values, + const char* const* values_list, + const size_t* values_list_sizes) { + // Use unique_ptr instead of vector to avoid overhead + // Safe because WriteBatch::Merge immediately copies the data + std::unique_ptr key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + std::unique_ptr value_slices(new Slice[num_values]); + for (int i = 0; i < num_values; i++) { + value_slices[i] = Slice(values_list[i], values_list_sizes[i]); + } + b->rep.Merge(column_family->rep, SliceParts(key_slices.get(), num_keys), + SliceParts(value_slices.get(), num_values)); +} + +void rocksdb_writebatch_singledelete(rocksdb_writebatch_t* b, const char* key, + size_t klen) { + b->rep.SingleDelete(Slice(key, klen)); +} + +void rocksdb_writebatch_delete_cf(rocksdb_writebatch_t* b, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen) { + b->rep.Delete(column_family->rep, Slice(key, klen)); +} + +void rocksdb_writebatch_delete_cf_with_ts( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* ts, size_t tslen) { + b->rep.Delete(column_family->rep, Slice(key, klen), Slice(ts, tslen)); +} + +void rocksdb_writebatch_singledelete_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen) { + b->rep.SingleDelete(column_family->rep, Slice(key, klen)); +} + +void rocksdb_writebatch_singledelete_cf_with_ts( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* ts, size_t tslen) { + b->rep.SingleDelete(column_family->rep, Slice(key, klen), Slice(ts, tslen)); +} + +void rocksdb_writebatch_deletev(rocksdb_writebatch_t* b, int num_keys, + const char* const* keys_list, + const size_t* keys_list_sizes) { + // Use unique_ptr instead of vector to avoid overhead + // Safe because WriteBatch::Delete immediately copies the data + std::unique_ptr key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + b->rep.Delete(SliceParts(key_slices.get(), num_keys)); +} + +void rocksdb_writebatch_deletev_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, const size_t* keys_list_sizes) { + // Use unique_ptr instead of vector to avoid overhead + // Safe because WriteBatch::Delete immediately copies the data + std::unique_ptr key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + b->rep.Delete(column_family->rep, SliceParts(key_slices.get(), num_keys)); +} + +void rocksdb_writebatch_delete_range(rocksdb_writebatch_t* b, + const char* start_key, + size_t start_key_len, const char* end_key, + size_t end_key_len) { + b->rep.DeleteRange(Slice(start_key, start_key_len), + Slice(end_key, end_key_len)); +} + +void rocksdb_writebatch_delete_range_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, const char* end_key, + size_t end_key_len) { + b->rep.DeleteRange(column_family->rep, Slice(start_key, start_key_len), + Slice(end_key, end_key_len)); +} + +void rocksdb_writebatch_delete_rangev(rocksdb_writebatch_t* b, int num_keys, + const char* const* start_keys_list, + const size_t* start_keys_list_sizes, + const char* const* end_keys_list, + const size_t* end_keys_list_sizes) { + // Use unique_ptr instead of vector to avoid overhead + // Safe because WriteBatch::DeleteRange immediately copies the data + std::unique_ptr start_key_slices(new Slice[num_keys]); + std::unique_ptr end_key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]); + end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]); + } + b->rep.DeleteRange(SliceParts(start_key_slices.get(), num_keys), + SliceParts(end_key_slices.get(), num_keys)); +} + +void rocksdb_writebatch_delete_rangev_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* start_keys_list, + const size_t* start_keys_list_sizes, const char* const* end_keys_list, + const size_t* end_keys_list_sizes) { + // Use unique_ptr instead of vector to avoid overhead + // Safe because WriteBatch::DeleteRange immediately copies the data + std::unique_ptr start_key_slices(new Slice[num_keys]); + std::unique_ptr end_key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]); + end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]); + } + b->rep.DeleteRange(column_family->rep, + SliceParts(start_key_slices.get(), num_keys), + SliceParts(end_key_slices.get(), num_keys)); +} + +class H : public WriteBatch::Handler { + public: + void* state_; + void (*put_)(void*, const char* k, size_t klen, const char* v, size_t vlen); + void (*deleted_)(void*, const char* k, size_t klen); + void (*log_data_)(void*, const char* blob, size_t blob_len); + + void Put(const Slice& key, const Slice& value) override { + (*put_)(state_, key.data(), key.size(), value.data(), value.size()); + } + void Delete(const Slice& key) override { + (*deleted_)(state_, key.data(), key.size()); + } + void LogData(const Slice& blob) override { + if (log_data_) { + (*log_data_)(state_, blob.data(), blob.size()); + } + } + Status MarkNoop(bool /* empty_batch */) override { return Status::OK(); } +}; + +class HCF : public WriteBatch::Handler { + public: + void* state_; + void (*put_cf_)(void*, uint32_t cfid, const char* k, size_t klen, + const char* v, size_t vlen); + void (*deleted_cf_)(void*, uint32_t cfid, const char* k, size_t klen); + void (*merge_cf_)(void*, uint32_t cfid, const char* k, size_t klen, + const char* v, size_t vlen); + void (*log_data_)(void*, const char* blob, size_t blob_len); + + Status PutCF(uint32_t column_family_id, const Slice& key, + const Slice& value) override { + (*put_cf_)(state_, column_family_id, key.data(), key.size(), value.data(), + value.size()); + return Status::OK(); + } + Status DeleteCF(uint32_t column_family_id, const Slice& key) override { + (*deleted_cf_)(state_, column_family_id, key.data(), key.size()); + return Status::OK(); + } + Status MergeCF(uint32_t column_family_id, const Slice& key, + const Slice& value) override { + (*merge_cf_)(state_, column_family_id, key.data(), key.size(), value.data(), + value.size()); + return Status::OK(); + } + void LogData(const Slice& blob) override { + if (log_data_) { + (*log_data_)(state_, blob.data(), blob.size()); + } + } + Status MarkNoop(bool /* empty_batch */) override { return Status::OK(); } +}; + +void rocksdb_writebatch_iterate(rocksdb_writebatch_t* b, void* state, + void (*put)(void*, const char* k, size_t klen, + const char* v, size_t vlen), + void (*deleted)(void*, const char* k, + size_t klen)) { + H handler; + handler.state_ = state; + handler.put_ = put; + handler.deleted_ = deleted; + handler.log_data_ = nullptr; + b->rep.Iterate(&handler); +} + +void rocksdb_writebatch_iterate_ld( + rocksdb_writebatch_t* b, void* state, + void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen), + void (*deleted)(void*, const char* k, size_t klen), + void (*log_data)(void*, const char* blob, size_t blob_len)) { + H handler; + handler.state_ = state; + handler.put_ = put; + handler.deleted_ = deleted; + handler.log_data_ = log_data; + b->rep.Iterate(&handler); +} + +void rocksdb_writebatch_iterate_cf( + rocksdb_writebatch_t* b, void* state, + void (*put_cf)(void*, uint32_t cfid, const char* k, size_t klen, + const char* v, size_t vlen), + void (*deleted_cf)(void*, uint32_t cfid, const char* k, size_t klen), + void (*merge_cf)(void*, uint32_t cfid, const char* k, size_t klen, + const char* v, size_t vlen)) { + HCF handler; + handler.state_ = state; + handler.put_cf_ = put_cf; + handler.deleted_cf_ = deleted_cf; + handler.merge_cf_ = merge_cf; + handler.log_data_ = nullptr; + b->rep.Iterate(&handler); +} + +void rocksdb_writebatch_iterate_cf_ld( + rocksdb_writebatch_t* b, void* state, + void (*put_cf)(void*, uint32_t cfid, const char* k, size_t klen, + const char* v, size_t vlen), + void (*deleted_cf)(void*, uint32_t cfid, const char* k, size_t klen), + void (*merge_cf)(void*, uint32_t cfid, const char* k, size_t klen, + const char* v, size_t vlen), + void (*log_data)(void*, const char* blob, size_t blob_len)) { + HCF handler; + handler.state_ = state; + handler.put_cf_ = put_cf; + handler.deleted_cf_ = deleted_cf; + handler.merge_cf_ = merge_cf; + handler.log_data_ = log_data; + b->rep.Iterate(&handler); +} + +const char* rocksdb_writebatch_data(rocksdb_writebatch_t* b, size_t* size) { + *size = b->rep.GetDataSize(); + return b->rep.Data().c_str(); +} + +rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create( + size_t reserved_bytes, unsigned char overwrite_key) { + rocksdb_writebatch_wi_t* b = new rocksdb_writebatch_wi_t; + b->rep = new WriteBatchWithIndex(BytewiseComparator(), reserved_bytes, + overwrite_key); + return b; +} + +rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create_with_params( + rocksdb_comparator_t* backup_index_comparator, size_t reserved_bytes, + unsigned char overwrite_key, size_t max_bytes, + size_t protection_bytes_per_key) { + rocksdb_writebatch_wi_t* b = new rocksdb_writebatch_wi_t; + b->rep = new WriteBatchWithIndex(backup_index_comparator, reserved_bytes, + overwrite_key, max_bytes, + protection_bytes_per_key); + return b; +} + +void rocksdb_writebatch_update_timestamps( + rocksdb_writebatch_t* wb, const char* ts, size_t tslen, void* state, + size_t (*get_ts_size)(void*, uint32_t), char** errptr) { + SaveError(errptr, wb->rep.UpdateTimestamps( + Slice(ts, tslen), [&get_ts_size, &state](uint32_t cf) { + return (*get_ts_size)(state, cf); + })); +} + +void rocksdb_writebatch_wi_update_timestamps( + rocksdb_writebatch_wi_t* wb, const char* ts, size_t tslen, void* state, + size_t (*get_ts_size)(void*, uint32_t), char** errptr) { + SaveError(errptr, wb->rep->GetWriteBatch()->UpdateTimestamps( + Slice(ts, tslen), [&get_ts_size, &state](uint32_t cf) { + return (*get_ts_size)(state, cf); + })); +} + +void rocksdb_writebatch_wi_destroy(rocksdb_writebatch_wi_t* b) { + if (b->rep) { + delete b->rep; + } + delete b; +} + +void rocksdb_writebatch_wi_clear(rocksdb_writebatch_wi_t* b) { + b->rep->Clear(); +} + +int rocksdb_writebatch_wi_count(rocksdb_writebatch_wi_t* b) { + return b->rep->GetWriteBatch()->Count(); +} + +void rocksdb_writebatch_wi_put(rocksdb_writebatch_wi_t* b, const char* key, + size_t klen, const char* val, size_t vlen) { + b->rep->Put(Slice(key, klen), Slice(val, vlen)); +} + +void rocksdb_writebatch_wi_put_cf(rocksdb_writebatch_wi_t* b, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, + size_t vlen) { + b->rep->Put(column_family->rep, Slice(key, klen), Slice(val, vlen)); +} + +void rocksdb_writebatch_wi_putv(rocksdb_writebatch_wi_t* b, int num_keys, + const char* const* keys_list, + const size_t* keys_list_sizes, int num_values, + const char* const* values_list, + const size_t* values_list_sizes) { + // Use unique_ptr for better performance (avoids vector overhead) + std::unique_ptr key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + std::unique_ptr value_slices(new Slice[num_values]); + for (int i = 0; i < num_values; i++) { + value_slices[i] = Slice(values_list[i], values_list_sizes[i]); + } + b->rep->Put(SliceParts(key_slices.get(), num_keys), + SliceParts(value_slices.get(), num_values)); +} + +void rocksdb_writebatch_wi_putv_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, const size_t* keys_list_sizes, + int num_values, const char* const* values_list, + const size_t* values_list_sizes) { + std::vector key_slices(num_keys); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + std::vector value_slices(num_values); + for (int i = 0; i < num_values; i++) { + value_slices[i] = Slice(values_list[i], values_list_sizes[i]); + } + b->rep->Put(column_family->rep, SliceParts(key_slices.data(), num_keys), + SliceParts(value_slices.data(), num_values)); +} + +void rocksdb_writebatch_wi_merge(rocksdb_writebatch_wi_t* b, const char* key, + size_t klen, const char* val, size_t vlen) { + b->rep->Merge(Slice(key, klen), Slice(val, vlen)); +} + +void rocksdb_writebatch_wi_merge_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen) { + b->rep->Merge(column_family->rep, Slice(key, klen), Slice(val, vlen)); +} + +void rocksdb_writebatch_wi_mergev(rocksdb_writebatch_wi_t* b, int num_keys, + const char* const* keys_list, + const size_t* keys_list_sizes, int num_values, + const char* const* values_list, + const size_t* values_list_sizes) { + // Use unique_ptr for better performance (avoids vector overhead) + std::unique_ptr key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + std::unique_ptr value_slices(new Slice[num_values]); + for (int i = 0; i < num_values; i++) { + value_slices[i] = Slice(values_list[i], values_list_sizes[i]); + } + b->rep->Merge(SliceParts(key_slices.get(), num_keys), + SliceParts(value_slices.get(), num_values)); +} + +void rocksdb_writebatch_wi_mergev_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, const size_t* keys_list_sizes, + int num_values, const char* const* values_list, + const size_t* values_list_sizes) { + // Use unique_ptr for better performance (avoids vector overhead) + std::unique_ptr key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + std::unique_ptr value_slices(new Slice[num_values]); + for (int i = 0; i < num_values; i++) { + value_slices[i] = Slice(values_list[i], values_list_sizes[i]); + } + b->rep->Merge(column_family->rep, SliceParts(key_slices.get(), num_keys), + SliceParts(value_slices.get(), num_values)); +} + +void rocksdb_writebatch_wi_delete(rocksdb_writebatch_wi_t* b, const char* key, + size_t klen) { + b->rep->Delete(Slice(key, klen)); +} + +void rocksdb_writebatch_wi_singledelete(rocksdb_writebatch_wi_t* b, + const char* key, size_t klen) { + b->rep->SingleDelete(Slice(key, klen)); +} + +void rocksdb_writebatch_wi_delete_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen) { + b->rep->Delete(column_family->rep, Slice(key, klen)); +} + +void rocksdb_writebatch_wi_singledelete_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen) { + b->rep->SingleDelete(column_family->rep, Slice(key, klen)); +} + +void rocksdb_writebatch_wi_deletev(rocksdb_writebatch_wi_t* b, int num_keys, + const char* const* keys_list, + const size_t* keys_list_sizes) { + std::vector key_slices(num_keys); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + b->rep->Delete(SliceParts(key_slices.data(), num_keys)); +} + +void rocksdb_writebatch_wi_deletev_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, const size_t* keys_list_sizes) { + // Use unique_ptr for better performance (avoids vector overhead) + std::unique_ptr key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + b->rep->Delete(column_family->rep, SliceParts(key_slices.get(), num_keys)); +} + +void rocksdb_writebatch_wi_delete_range(rocksdb_writebatch_wi_t* b, + const char* start_key, + size_t start_key_len, + const char* end_key, + size_t end_key_len) { + b->rep->DeleteRange(Slice(start_key, start_key_len), + Slice(end_key, end_key_len)); +} + +void rocksdb_writebatch_wi_delete_range_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, const char* end_key, + size_t end_key_len) { + b->rep->DeleteRange(column_family->rep, Slice(start_key, start_key_len), + Slice(end_key, end_key_len)); +} + +void rocksdb_writebatch_wi_delete_rangev(rocksdb_writebatch_wi_t* b, + int num_keys, + const char* const* start_keys_list, + const size_t* start_keys_list_sizes, + const char* const* end_keys_list, + const size_t* end_keys_list_sizes) { + // Use unique_ptr for better performance (avoids vector overhead) + std::unique_ptr start_key_slices(new Slice[num_keys]); + std::unique_ptr end_key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]); + end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]); + } + b->rep->DeleteRange(SliceParts(start_key_slices.get(), num_keys), + SliceParts(end_key_slices.get(), num_keys)); +} + +void rocksdb_writebatch_wi_delete_rangev_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* start_keys_list, + const size_t* start_keys_list_sizes, const char* const* end_keys_list, + const size_t* end_keys_list_sizes) { + // Use unique_ptr for better performance (avoids vector overhead) + std::unique_ptr start_key_slices(new Slice[num_keys]); + std::unique_ptr end_key_slices(new Slice[num_keys]); + for (int i = 0; i < num_keys; i++) { + start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]); + end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]); + } + b->rep->DeleteRange(column_family->rep, + SliceParts(start_key_slices.get(), num_keys), + SliceParts(end_key_slices.get(), num_keys)); +} + +void rocksdb_writebatch_wi_put_log_data(rocksdb_writebatch_wi_t* b, + const char* blob, size_t len) { + b->rep->PutLogData(Slice(blob, len)); +} + +void rocksdb_writebatch_wi_iterate( + rocksdb_writebatch_wi_t* b, void* state, + void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen), + void (*deleted)(void*, const char* k, size_t klen)) { + H handler; + handler.state_ = state; + handler.put_ = put; + handler.deleted_ = deleted; + b->rep->GetWriteBatch()->Iterate(&handler); +} + +const char* rocksdb_writebatch_wi_data(rocksdb_writebatch_wi_t* b, + size_t* size) { + WriteBatch* wb = b->rep->GetWriteBatch(); + *size = wb->GetDataSize(); + return wb->Data().c_str(); +} + +void rocksdb_writebatch_wi_set_save_point(rocksdb_writebatch_wi_t* b) { + b->rep->SetSavePoint(); +} + +void rocksdb_writebatch_wi_rollback_to_save_point(rocksdb_writebatch_wi_t* b, + char** errptr) { + SaveError(errptr, b->rep->RollbackToSavePoint()); +} + +rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base( + rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; + result->rep = wbwi->rep->NewIteratorWithBase(base_iterator->rep); + delete base_iterator; + return result; +} + +rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_readopts( + rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator, + const rocksdb_readoptions_t* options) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; + result->rep = + wbwi->rep->NewIteratorWithBase(base_iterator->rep, &options->rep); + delete base_iterator; + return result; +} + +rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_cf( + rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator, + rocksdb_column_family_handle_t* column_family) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; + result->rep = + wbwi->rep->NewIteratorWithBase(column_family->rep, base_iterator->rep); + delete base_iterator; + return result; +} + +rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_cf_readopts( + rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator, + rocksdb_column_family_handle_t* column_family, + const rocksdb_readoptions_t* options) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; + result->rep = wbwi->rep->NewIteratorWithBase( + column_family->rep, base_iterator->rep, &options->rep); + delete base_iterator; + return result; +} + +char* rocksdb_writebatch_wi_get_from_batch(rocksdb_writebatch_wi_t* wbwi, + const rocksdb_options_t* options, + const char* key, size_t keylen, + size_t* vallen, char** errptr) { + char* result = nullptr; + std::string tmp; + Status s = wbwi->rep->GetFromBatch(options->rep, Slice(key, keylen), &tmp); + if (s.ok()) { + *vallen = tmp.size(); + result = CopyString(tmp); + } else { + *vallen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +char* rocksdb_writebatch_wi_get_from_batch_cf( + rocksdb_writebatch_wi_t* wbwi, const rocksdb_options_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, size_t* vallen, char** errptr) { + char* result = nullptr; + std::string tmp; + Status s = wbwi->rep->GetFromBatch(column_family->rep, options->rep, + Slice(key, keylen), &tmp); + if (s.ok()) { + *vallen = tmp.size(); + result = CopyString(tmp); + } else { + *vallen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +char* rocksdb_writebatch_wi_get_from_batch_and_db( + rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db, + const rocksdb_readoptions_t* options, const char* key, size_t keylen, + size_t* vallen, char** errptr) { + char* result = nullptr; + // Use PinnableSlice to avoid unnecessary allocations + PinnableSlice pinnable_val; + Status s = wbwi->rep->GetFromBatchAndDB(db->rep, options->rep, + Slice(key, keylen), &pinnable_val); + if (s.ok()) { + *vallen = pinnable_val.size(); + result = CopyString(pinnable_val); + } else { + *vallen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +rocksdb_pinnableslice_t* rocksdb_writebatch_wi_get_pinned_from_batch_and_db( + rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db, + const rocksdb_readoptions_t* options, const char* key, size_t keylen, + char** errptr) { + rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t); + Status s = wbwi->rep->GetFromBatchAndDB(db->rep, options->rep, + Slice(key, keylen), &v->rep); + if (!s.ok()) { + delete (v); + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return v; +} + +char* rocksdb_writebatch_wi_get_from_batch_and_db_cf( + rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db, + const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, size_t* vallen, char** errptr) { + char* result = nullptr; + // Use PinnableSlice to avoid unnecessary allocations + PinnableSlice pinnable_val; + Status s = + wbwi->rep->GetFromBatchAndDB(db->rep, options->rep, column_family->rep, + Slice(key, keylen), &pinnable_val); + if (s.ok()) { + *vallen = pinnable_val.size(); + result = CopyString(pinnable_val); + } else { + *vallen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +rocksdb_pinnableslice_t* rocksdb_writebatch_wi_get_pinned_from_batch_and_db_cf( + rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db, + const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr) { + rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t); + Status s = wbwi->rep->GetFromBatchAndDB( + db->rep, options->rep, column_family->rep, Slice(key, keylen), &v->rep); + if (!s.ok()) { + delete (v); + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return v; +} + +void rocksdb_write_writebatch_wi(rocksdb_t* db, + const rocksdb_writeoptions_t* options, + rocksdb_writebatch_wi_t* wbwi, char** errptr) { + WriteBatch* wb = wbwi->rep->GetWriteBatch(); + SaveError(errptr, db->rep->Write(options->rep, wb)); +} + +void rocksdb_load_latest_options( + const char* db_path, rocksdb_env_t* env, bool ignore_unknown_options, + rocksdb_cache_t* cache, rocksdb_options_t** db_options, + size_t* num_column_families, char*** list_column_family_names, + rocksdb_options_t*** list_column_family_options, char** errptr) { + DBOptions db_opt; + std::vector cf_descs; + ConfigOptions config_opts; + config_opts.ignore_unknown_options = ignore_unknown_options; + config_opts.input_strings_escaped = true; + config_opts.env = env->rep; + Status s = LoadLatestOptions(config_opts, std::string(db_path), &db_opt, + &cf_descs, &cache->rep); + if (s.ok()) { + char** cf_names = (char**)malloc(cf_descs.size() * sizeof(char*)); + rocksdb_options_t** cf_options = (rocksdb_options_t**)malloc( + cf_descs.size() * sizeof(rocksdb_options_t*)); + for (size_t i = 0; i < cf_descs.size(); ++i) { + cf_names[i] = strdup(cf_descs[i].name.c_str()); + cf_options[i] = new rocksdb_options_t{ + Options(DBOptions(), std::move(cf_descs[i].options))}; + } + *num_column_families = cf_descs.size(); + *db_options = new rocksdb_options_t{ + Options(std::move(db_opt), ColumnFamilyOptions())}; + *list_column_family_names = cf_names; + *list_column_family_options = cf_options; + } else { + *num_column_families = 0; + *db_options = nullptr; + *list_column_family_names = nullptr; + *list_column_family_options = nullptr; + SaveError(errptr, s); + } +} + +void rocksdb_load_latest_options_destroy( + rocksdb_options_t* db_options, char** list_column_family_names, + rocksdb_options_t** list_column_family_options, size_t len) { + rocksdb_options_destroy(db_options); + if (list_column_family_names) { + for (size_t i = 0; i < len; ++i) { + free(list_column_family_names[i]); + } + free(list_column_family_names); + } + if (list_column_family_options) { + for (size_t i = 0; i < len; ++i) { + rocksdb_options_destroy(list_column_family_options[i]); + } + free(list_column_family_options); + } +} + +rocksdb_block_based_table_options_t* rocksdb_block_based_options_create() { + return new rocksdb_block_based_table_options_t; +} + +void rocksdb_block_based_options_destroy( + rocksdb_block_based_table_options_t* options) { + delete options; +} + +#include "c_api_gen/c_generated_block_based_options_subset.cc.inc" + +void rocksdb_block_based_options_set_filter_policy( + rocksdb_block_based_table_options_t* options, + rocksdb_filterpolicy_t* filter_policy) { + options->rep.filter_policy.reset(filter_policy); +} + +void rocksdb_block_based_options_set_block_cache( + rocksdb_block_based_table_options_t* options, + rocksdb_cache_t* block_cache) { + if (block_cache) { + options->rep.block_cache = block_cache->rep; + } +} + +void rocksdb_block_based_options_set_user_defined_index_factory_from_string( + rocksdb_block_based_table_options_t* options, const char* value, + size_t value_len, char** errptr) { + options->user_defined_index_factory.reset(); + options->rep.user_defined_index_factory.reset(); + if (value == nullptr) { + return; + } + + std::shared_ptr factory; + Status s = LoadUserDefinedIndexFactoryFromString(value, value_len, &factory); + if (SaveError(errptr, s)) { + return; + } + options->user_defined_index_factory = std::move(factory); + options->rep.user_defined_index_factory = options->user_defined_index_factory; +} + +void rocksdb_block_based_options_clear_user_defined_index_factory( + rocksdb_block_based_table_options_t* options) { + options->user_defined_index_factory.reset(); + options->rep.user_defined_index_factory.reset(); +} + +const char* rocksdb_block_based_options_get_user_defined_index_factory_name( + const rocksdb_block_based_table_options_t* options, size_t* name_len) { + if (options->user_defined_index_factory == nullptr) { + if (name_len != nullptr) { + *name_len = 0; + } + return nullptr; + } + const char* name = options->user_defined_index_factory->Name(); + if (name_len != nullptr) { + *name_len = strlen(name); + } + return name; +} + +void rocksdb_options_set_block_based_table_factory( + rocksdb_options_t* opt, + rocksdb_block_based_table_options_t* table_options) { + if (table_options) { + opt->rep.table_factory.reset( + ROCKSDB_NAMESPACE::NewBlockBasedTableFactory(table_options->rep)); + } +} + +/* FlushJobInfo */ + +#include "c_api_gen/c_generated_jobinfo_auto.cc.inc" +#include "c_api_gen/c_generated_jobinfo_metadata_subset.cc.inc" +#include "c_api_gen/c_generated_metadata_structs_auto.cc.inc" + +rocksdb_compactionjobinfo_t* rocksdb_compactionjobinfo_create() { + return new rocksdb_compactionjobinfo_t; +} + +void rocksdb_compactionjobinfo_destroy(rocksdb_compactionjobinfo_t* info) { + delete info; +} + +void rocksdb_reset_status(rocksdb_status_ptr_t* status_ptr) { + auto ptr = status_ptr->rep; + *ptr = Status::OK(); +} + +unsigned char rocksdb_table_properties_has_key_largest_seqno( + const rocksdb_table_properties_t* props) { + return props->rep.HasKeyLargestSeqno(); +} + +unsigned char rocksdb_table_properties_has_key_smallest_seqno( + const rocksdb_table_properties_t* props) { + return props->rep.HasKeySmallestSeqno(); +} + +size_t rocksdb_table_properties_user_collected_properties_count( + const rocksdb_table_properties_t* props) { + return props->rep.user_collected_properties.size(); +} + +const char* rocksdb_table_properties_user_collected_properties_key_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* key_len) { + const auto it = GetMapEntryAt(props->rep.user_collected_properties, pos); + if (it == props->rep.user_collected_properties.cend()) { + if (key_len != nullptr) { + *key_len = 0; + } + return nullptr; + } + if (key_len != nullptr) { + *key_len = it->first.size(); + } + return it->first.data(); +} + +const char* rocksdb_table_properties_user_collected_properties_value_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* value_len) { + const auto it = GetMapEntryAt(props->rep.user_collected_properties, pos); + if (it == props->rep.user_collected_properties.cend()) { + if (value_len != nullptr) { + *value_len = 0; + } + return nullptr; + } + if (value_len != nullptr) { + *value_len = it->second.size(); + } + return it->second.data(); +} + +size_t rocksdb_table_properties_readable_properties_count( + const rocksdb_table_properties_t* props) { + return props->rep.readable_properties.size(); +} + +const char* rocksdb_table_properties_readable_properties_key_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* key_len) { + const auto it = GetMapEntryAt(props->rep.readable_properties, pos); + if (it == props->rep.readable_properties.cend()) { + if (key_len != nullptr) { + *key_len = 0; + } + return nullptr; + } + if (key_len != nullptr) { + *key_len = it->first.size(); + } + return it->first.data(); +} + +const char* rocksdb_table_properties_readable_properties_value_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* value_len) { + const auto it = GetMapEntryAt(props->rep.readable_properties, pos); + if (it == props->rep.readable_properties.cend()) { + if (value_len != nullptr) { + *value_len = 0; + } + return nullptr; + } + if (value_len != nullptr) { + *value_len = it->second.size(); + } + return it->second.data(); +} + +const rocksdb_table_properties_t* rocksdb_flushjobinfo_table_properties( + const rocksdb_flushjobinfo_t* info) { + return reinterpret_cast( + &info->rep.table_properties); +} + +size_t rocksdb_flushjobinfo_blob_file_addition_infos_count( + const rocksdb_flushjobinfo_t* info) { + return info->rep.blob_file_addition_infos.size(); +} + +const rocksdb_blob_file_addition_info_t* +rocksdb_flushjobinfo_blob_file_addition_info_at( + const rocksdb_flushjobinfo_t* info, size_t pos) { + assert(pos < info->rep.blob_file_addition_infos.size()); + return reinterpret_cast( + &info->rep.blob_file_addition_infos[pos]); +} + +/* CompactionJobInfo */ + +const char* rocksdb_compactionjobinfo_input_file_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size) { + assert(info != nullptr); + assert(pos < info->rep.input_files.size()); + + const std::string& path = info->rep.input_files[pos]; + *size = path.size(); + return path.data(); +} + +const char* rocksdb_compactionjobinfo_output_file_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size) { + assert(info != nullptr); + assert(pos < info->rep.output_files.size()); + + const std::string& path = info->rep.output_files[pos]; + *size = path.size(); + return path.data(); +} + +const rocksdb_compaction_job_stats_t* rocksdb_compactionjobinfo_stats( + const rocksdb_compactionjobinfo_t* info) { + return reinterpret_cast( + &info->rep.stats); +} + +size_t rocksdb_compactionjobinfo_input_file_infos_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.input_file_infos.size(); +} + +const rocksdb_compaction_file_info_t* +rocksdb_compactionjobinfo_input_file_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos) { + assert(pos < info->rep.input_file_infos.size()); + return reinterpret_cast( + &info->rep.input_file_infos[pos]); +} + +size_t rocksdb_compactionjobinfo_output_file_infos_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.output_file_infos.size(); +} + +const rocksdb_compaction_file_info_t* +rocksdb_compactionjobinfo_output_file_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos) { + assert(pos < info->rep.output_file_infos.size()); + return reinterpret_cast( + &info->rep.output_file_infos[pos]); +} + +size_t rocksdb_compactionjobinfo_table_properties_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.table_properties.size(); +} + +const char* rocksdb_compactionjobinfo_table_properties_key_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* key_len) { + const auto it = GetMapEntryAt(info->rep.table_properties, pos); + if (it == info->rep.table_properties.cend()) { + if (key_len != nullptr) { + *key_len = 0; + } + return nullptr; + } + if (key_len != nullptr) { + *key_len = it->first.size(); + } + return it->first.data(); +} + +const rocksdb_table_properties_t* +rocksdb_compactionjobinfo_table_properties_value_at( + const rocksdb_compactionjobinfo_t* info, size_t pos) { + const auto it = GetMapEntryAt(info->rep.table_properties, pos); + if (it == info->rep.table_properties.cend()) { + return nullptr; + } + return reinterpret_cast(it->second.get()); +} + +const rocksdb_table_properties_t* +rocksdb_compactionjobinfo_table_properties_for_file( + const rocksdb_compactionjobinfo_t* info, const char* file_name, + size_t file_name_len) { + const auto it = + info->rep.table_properties.find(std::string(file_name, file_name_len)); + if (it == info->rep.table_properties.end()) { + return nullptr; + } + return reinterpret_cast(it->second.get()); +} + +size_t rocksdb_compactionjobinfo_blob_file_addition_infos_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.blob_file_addition_infos.size(); +} + +const rocksdb_blob_file_addition_info_t* +rocksdb_compactionjobinfo_blob_file_addition_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos) { + assert(pos < info->rep.blob_file_addition_infos.size()); + return reinterpret_cast( + &info->rep.blob_file_addition_infos[pos]); +} + +size_t rocksdb_compactionjobinfo_blob_file_garbage_infos_count( + const rocksdb_compactionjobinfo_t* info) { + return info->rep.blob_file_garbage_infos.size(); +} + +const rocksdb_blob_file_garbage_info_t* +rocksdb_compactionjobinfo_blob_file_garbage_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos) { + assert(pos < info->rep.blob_file_garbage_infos.size()); + return reinterpret_cast( + &info->rep.blob_file_garbage_infos[pos]); +} + +/* SubcompactionJobInfo */ + +const rocksdb_compaction_job_stats_t* rocksdb_subcompactionjobinfo_stats( + const rocksdb_subcompactionjobinfo_t* info) { + return reinterpret_cast( + &info->rep.stats); +} + +/* ExternalFileIngestionInfo */ + +const rocksdb_table_properties_t* +rocksdb_externalfileingestioninfo_table_properties( + const rocksdb_externalfileingestioninfo_t* info) { + return reinterpret_cast( + &info->rep.table_properties); +} + +/* event listener */ + +struct rocksdb_eventlistener_t : public EventListener { + void* state_{}; + void (*destructor_)(void*){}; + void (*on_flush_begin)(void*, rocksdb_t*, const rocksdb_flushjobinfo_t*){}; + void (*on_flush_completed)(void*, rocksdb_t*, + const rocksdb_flushjobinfo_t*){}; + void (*on_compaction_begin)(void*, rocksdb_t*, + const rocksdb_compactionjobinfo_t*){}; + void (*on_compaction_completed)(void*, rocksdb_t*, + const rocksdb_compactionjobinfo_t*){}; + void (*on_subcompaction_begin)(void*, + const rocksdb_subcompactionjobinfo_t*){}; + void (*on_subcompaction_completed)(void*, + const rocksdb_subcompactionjobinfo_t*){}; + void (*on_external_file_ingested)( + void*, rocksdb_t*, const rocksdb_externalfileingestioninfo_t*){}; + void (*on_background_error)(void*, uint32_t, rocksdb_status_ptr_t*){}; + void (*on_stall_conditions_changed)(void*, const rocksdb_writestallinfo_t*){}; + void (*on_memtable_sealed)(void*, const rocksdb_memtableinfo_t*){}; + + rocksdb_eventlistener_t() = default; + + rocksdb_eventlistener_t(const rocksdb_eventlistener_t&) = delete; + rocksdb_eventlistener_t& operator=(const rocksdb_eventlistener_t&) = delete; + rocksdb_eventlistener_t(rocksdb_eventlistener_t&&) = delete; + rocksdb_eventlistener_t& operator=(rocksdb_eventlistener_t&&) = delete; + + void OnFlushBegin(DB* db, const FlushJobInfo& info) override { + rocksdb_t c_db = {db}; + on_flush_begin(state_, &c_db, + reinterpret_cast(&info)); + } + + void OnFlushCompleted(DB* db, const FlushJobInfo& info) override { + rocksdb_t c_db = {db}; + on_flush_completed(state_, &c_db, + reinterpret_cast(&info)); + } + + void OnCompactionBegin(DB* db, const CompactionJobInfo& info) override { + rocksdb_t c_db = {db}; + on_compaction_begin( + state_, &c_db, + reinterpret_cast(&info)); + } + + void OnCompactionCompleted(DB* db, const CompactionJobInfo& info) override { + rocksdb_t c_db = {db}; + on_compaction_completed( + state_, &c_db, + reinterpret_cast(&info)); + } + + void OnSubcompactionBegin(const SubcompactionJobInfo& info) override { + on_subcompaction_begin( + state_, reinterpret_cast(&info)); + } + + void OnSubcompactionCompleted(const SubcompactionJobInfo& info) override { + on_subcompaction_completed( + state_, reinterpret_cast(&info)); + } + + void OnExternalFileIngested(DB* db, + const ExternalFileIngestionInfo& info) override { + rocksdb_t c_db = {db}; + on_external_file_ingested( + state_, &c_db, + reinterpret_cast(&info)); + } + + void OnBackgroundError(BackgroundErrorReason reason, + Status* status) override { + rocksdb_status_ptr_t* s = new rocksdb_status_ptr_t; + s->rep = status; + on_background_error(state_, static_cast(reason), s); + delete s; + } + + void OnStallConditionsChanged(const WriteStallInfo& info) override { + on_stall_conditions_changed( + state_, reinterpret_cast(&info)); + } + + void OnMemTableSealed(const MemTableInfo& info) override { + on_memtable_sealed(state_, + reinterpret_cast(&info)); + } + + ~rocksdb_eventlistener_t() override { destructor_(state_); } +}; + +rocksdb_eventlistener_t* rocksdb_eventlistener_create( + void* state_, void (*destructor_)(void*), on_flush_begin_cb on_flush_begin, + on_flush_completed_cb on_flush_completed, + on_compaction_begin_cb on_compaction_begin, + on_compaction_completed_cb on_compaction_completed, + on_subcompaction_begin_cb on_subcompaction_begin, + on_subcompaction_completed_cb on_subcompaction_completed, + on_external_file_ingested_cb on_external_file_ingested, + on_background_error_cb on_background_error, + on_stall_conditions_changed_cb on_stall_conditions_changed, + on_memtable_sealed_cb on_memtable_sealed) { + rocksdb_eventlistener_t* et = new rocksdb_eventlistener_t; + et->state_ = state_; + et->destructor_ = destructor_; + et->on_flush_begin = on_flush_begin; + et->on_flush_completed = on_flush_completed; + et->on_compaction_begin = on_compaction_begin; + et->on_compaction_completed = on_compaction_completed; + et->on_subcompaction_begin = on_subcompaction_begin; + et->on_subcompaction_completed = on_subcompaction_completed; + et->on_external_file_ingested = on_external_file_ingested; + et->on_background_error = on_background_error; + et->on_stall_conditions_changed = on_stall_conditions_changed; + et->on_memtable_sealed = on_memtable_sealed; + return et; +} + +void rocksdb_eventlistener_destroy(rocksdb_eventlistener_t* t) { delete t; } + +void rocksdb_options_add_eventlistener(rocksdb_options_t* opt, + rocksdb_eventlistener_t* t) { + opt->rep.listeners.emplace_back(std::shared_ptr(t)); +} + +void rocksdb_compaction_service_options_override_add_event_listener( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_eventlistener_t* event_listener) { + if (override_options && event_listener) { + override_options->rep.listeners.emplace_back( + std::shared_ptr(event_listener)); + } +} + +rocksdb_cuckoo_table_options_t* rocksdb_cuckoo_options_create() { + return new rocksdb_cuckoo_table_options_t; +} + +void rocksdb_cuckoo_options_destroy(rocksdb_cuckoo_table_options_t* options) { + delete options; +} + +#include "c_api_gen/c_generated_cuckoo_options_subset.cc.inc" + +void rocksdb_options_set_cuckoo_table_factory( + rocksdb_options_t* opt, rocksdb_cuckoo_table_options_t* table_options) { + if (table_options) { + opt->rep.table_factory.reset( + ROCKSDB_NAMESPACE::NewCuckooTableFactory(table_options->rep)); + } +} + +void rocksdb_set_options(rocksdb_t* db, int count, const char* const keys[], + const char* const values[], char** errptr) { + std::unordered_map options_map; + for (int i = 0; i < count; i++) { + options_map[keys[i]] = values[i]; + } + SaveError(errptr, db->rep->SetOptions(options_map)); +} + +void rocksdb_set_db_options(rocksdb_t* db, int count, const char* const keys[], + const char* const values[], char** errptr) { + std::unordered_map options_map; + for (int i = 0; i < count; i++) { + options_map[keys[i]] = values[i]; + } + SaveError(errptr, db->rep->SetDBOptions(options_map)); +} + +void rocksdb_set_options_cf(rocksdb_t* db, + rocksdb_column_family_handle_t* handle, int count, + const char* const keys[], + const char* const values[], char** errptr) { + std::unordered_map options_map; + for (int i = 0; i < count; i++) { + options_map[keys[i]] = values[i]; + } + SaveError(errptr, db->rep->SetOptions(handle->rep, options_map)); +} + +rocksdb_options_t* rocksdb_options_create() { return new rocksdb_options_t; } + +void rocksdb_options_destroy(rocksdb_options_t* options) { delete options; } + +rocksdb_options_t* rocksdb_options_create_copy(rocksdb_options_t* options) { + return new rocksdb_options_t(*options); +} + +void rocksdb_options_increase_parallelism(rocksdb_options_t* opt, + int total_threads) { + opt->rep.IncreaseParallelism(total_threads); +} + +void rocksdb_options_optimize_for_point_lookup(rocksdb_options_t* opt, + uint64_t block_cache_size_mb) { + opt->rep.OptimizeForPointLookup(block_cache_size_mb); +} + +void rocksdb_options_optimize_level_style_compaction( + rocksdb_options_t* opt, uint64_t memtable_memory_budget) { + opt->rep.OptimizeLevelStyleCompaction(memtable_memory_budget); +} + +void rocksdb_options_optimize_universal_style_compaction( + rocksdb_options_t* opt, uint64_t memtable_memory_budget) { + opt->rep.OptimizeUniversalStyleCompaction(memtable_memory_budget); +} + +void rocksdb_options_set_compaction_filter(rocksdb_options_t* opt, + rocksdb_compactionfilter_t* filter) { + opt->rep.compaction_filter = filter; +} + +void rocksdb_options_set_compaction_filter_factory( + rocksdb_options_t* opt, rocksdb_compactionfilterfactory_t* factory) { + opt->rep.compaction_filter_factory = + std::shared_ptr(factory); +} + +void rocksdb_options_set_comparator(rocksdb_options_t* opt, + rocksdb_comparator_t* cmp) { + opt->rep.comparator = cmp; +} + +void rocksdb_options_set_merge_operator( + rocksdb_options_t* opt, rocksdb_mergeoperator_t* merge_operator) { + opt->rep.merge_operator = std::shared_ptr(merge_operator); +} + +void rocksdb_options_set_wal_filter(rocksdb_options_t* opt, + rocksdb_walfilter_t* filter) { + opt->rep.wal_filter = filter; +} + +void rocksdb_options_clear_wal_filter(rocksdb_options_t* opt) { + opt->rep.wal_filter = nullptr; +} + +#include "c_api_gen/c_generated_options_subset.cc.inc" + +void rocksdb_options_set_compression_per_level(rocksdb_options_t* opt, + const int* level_values, + size_t num_levels) { + opt->rep.compression_per_level.resize(num_levels); + for (size_t i = 0; i < num_levels; ++i) { + opt->rep.compression_per_level[i] = + static_cast(level_values[i]); + } +} + +void rocksdb_options_set_compression_options(rocksdb_options_t* opt, int w_bits, + int level, int strategy, + int max_dict_bytes) { + opt->rep.compression_opts.window_bits = w_bits; + opt->rep.compression_opts.level = level; + opt->rep.compression_opts.strategy = strategy; + opt->rep.compression_opts.max_dict_bytes = max_dict_bytes; +} + +// The bottommost_compression_opts setters below each write multiple fields of +// the nested CompressionOptions struct (and flip `enabled`), so they cannot be +// auto-generated as simple scalar field wrappers and are kept hand-written. +void rocksdb_options_set_bottommost_compression_options(rocksdb_options_t* opt, + int w_bits, int level, + int strategy, + int max_dict_bytes, + unsigned char enabled) { + opt->rep.bottommost_compression_opts.window_bits = w_bits; + opt->rep.bottommost_compression_opts.level = level; + opt->rep.bottommost_compression_opts.strategy = strategy; + opt->rep.bottommost_compression_opts.max_dict_bytes = max_dict_bytes; + opt->rep.bottommost_compression_opts.enabled = enabled; +} + +void rocksdb_options_set_bottommost_compression_options_zstd_max_train_bytes( + rocksdb_options_t* opt, int zstd_max_train_bytes, unsigned char enabled) { + opt->rep.bottommost_compression_opts.zstd_max_train_bytes = + zstd_max_train_bytes; + opt->rep.bottommost_compression_opts.enabled = enabled; +} + +void rocksdb_options_set_bottommost_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer, + unsigned char enabled) { + opt->rep.bottommost_compression_opts.use_zstd_dict_trainer = + use_zstd_dict_trainer; + opt->rep.bottommost_compression_opts.enabled = enabled; +} + +void rocksdb_options_set_bottommost_compression_options_max_dict_buffer_bytes( + rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes, + unsigned char enabled) { + opt->rep.bottommost_compression_opts.max_dict_buffer_bytes = + max_dict_buffer_bytes; + opt->rep.bottommost_compression_opts.enabled = enabled; +} + +// Takes a caller-owned array of per-level values, so it is hand-written rather +// than auto-generated. +void rocksdb_options_set_max_bytes_for_level_multiplier_additional( + rocksdb_options_t* opt, int* level_values, size_t num_levels) { + opt->rep.max_bytes_for_level_multiplier_additional.resize(num_levels); + for (size_t i = 0; i < num_levels; ++i) { + opt->rep.max_bytes_for_level_multiplier_additional[i] = level_values[i]; + } +} + +void rocksdb_options_set_db_paths(rocksdb_options_t* opt, + const rocksdb_dbpath_t** dbpath_values, + size_t num_paths) { + std::vector db_paths(num_paths); + for (size_t i = 0; i < num_paths; ++i) { + db_paths[i] = dbpath_values[i]->rep; + } + opt->rep.db_paths = db_paths; +} + +void rocksdb_options_set_cf_paths(rocksdb_options_t* opt, + const rocksdb_dbpath_t** dbpath_values, + size_t num_paths) { + std::vector cf_paths(num_paths); + for (size_t i = 0; i < num_paths; ++i) { + cf_paths[i] = dbpath_values[i]->rep; + } + opt->rep.cf_paths = cf_paths; +} + +rocksdb_logger_t* rocksdb_logger_create_stderr_logger(int log_level, + const char* prefix) { + rocksdb_logger_t* logger = new rocksdb_logger_t; + + if (prefix) { + logger->rep = std::make_shared( + static_cast(log_level), prefix); + } else { + logger->rep = + std::make_shared(static_cast(log_level)); + } + + return logger; +} + +rocksdb_logger_t* rocksdb_logger_create_callback_logger( + int log_level, void (*callback)(void*, unsigned, char*, size_t), + void* priv) { + rocksdb_logger_t* logger = new rocksdb_logger_t; + logger->rep = std::make_shared( + static_cast(log_level), callback, priv); + return logger; +} + +void rocksdb_logger_destroy(rocksdb_logger_t* logger) { delete logger; } + +/* File Checksum Gen Factory */ + +rocksdb_file_checksum_gen_factory_t* +rocksdb_file_checksum_gen_crc32c_factory_create() { + rocksdb_file_checksum_gen_factory_t* factory = + new rocksdb_file_checksum_gen_factory_t; + factory->rep = GetFileChecksumGenCrc32cFactory(); + return factory; +} + +void rocksdb_file_checksum_gen_factory_destroy( + rocksdb_file_checksum_gen_factory_t* factory) { + delete factory; +} + +void rocksdb_options_set_file_checksum_gen_factory( + rocksdb_options_t* opt, rocksdb_file_checksum_gen_factory_t* factory) { + if (opt && factory) { + opt->rep.file_checksum_gen_factory = factory->rep; + } +} + +void rocksdb_options_checksum_handoff_file_types_clear(rocksdb_options_t* opt) { + opt->rep.checksum_handoff_file_types = {}; +} + +void rocksdb_options_checksum_handoff_file_types_add(rocksdb_options_t* opt, + int file_type) { + opt->rep.checksum_handoff_file_types.Add(static_cast(file_type)); +} + +void rocksdb_options_checksum_handoff_file_types_remove(rocksdb_options_t* opt, + int file_type) { + opt->rep.checksum_handoff_file_types.Remove(static_cast(file_type)); +} + +unsigned char rocksdb_options_checksum_handoff_file_types_contains( + rocksdb_options_t* opt, int file_type) { + return opt->rep.checksum_handoff_file_types.Contains( + static_cast(file_type)); +} + +size_t rocksdb_options_checksum_handoff_file_types_count( + rocksdb_options_t* opt) { + return opt->rep.checksum_handoff_file_types.count(); +} + +void rocksdb_options_calculate_sst_write_lifetime_hint_set_clear( + rocksdb_options_t* opt) { + opt->rep.calculate_sst_write_lifetime_hint_set = {}; +} + +void rocksdb_options_calculate_sst_write_lifetime_hint_set_add( + rocksdb_options_t* opt, int compaction_style) { + opt->rep.calculate_sst_write_lifetime_hint_set.Add( + static_cast(compaction_style)); +} + +void rocksdb_options_calculate_sst_write_lifetime_hint_set_remove( + rocksdb_options_t* opt, int compaction_style) { + opt->rep.calculate_sst_write_lifetime_hint_set.Remove( + static_cast(compaction_style)); +} + +unsigned char rocksdb_options_calculate_sst_write_lifetime_hint_set_contains( + rocksdb_options_t* opt, int compaction_style) { + return opt->rep.calculate_sst_write_lifetime_hint_set.Contains( + static_cast(compaction_style)); +} + +size_t rocksdb_options_calculate_sst_write_lifetime_hint_set_count( + rocksdb_options_t* opt) { + return opt->rep.calculate_sst_write_lifetime_hint_set.count(); +} + +/* SST Partitioner Factory */ + +rocksdb_sst_partitioner_factory_t* +rocksdb_sst_partitioner_fixed_prefix_factory_create(size_t prefix_len) { + rocksdb_sst_partitioner_factory_t* factory = + new rocksdb_sst_partitioner_factory_t; + factory->rep = NewSstPartitionerFixedPrefixFactory(prefix_len); + return factory; +} + +void rocksdb_sst_partitioner_factory_destroy( + rocksdb_sst_partitioner_factory_t* factory) { + delete factory; +} + +void rocksdb_options_set_sst_partitioner_factory( + rocksdb_options_t* opt, rocksdb_sst_partitioner_factory_t* factory) { + if (opt && factory) { + opt->rep.sst_partitioner_factory = factory->rep; + } +} + +/* Table Properties Collector Factory */ + +void rocksdb_table_properties_collector_factory_destroy( + rocksdb_table_properties_collector_factory_t* factory) { + delete factory; +} + +void rocksdb_options_add_table_properties_collector_factory( + rocksdb_options_t* opt, + rocksdb_table_properties_collector_factory_t* factory) { + if (opt && factory) { + opt->rep.table_properties_collector_factories.push_back(factory->rep); + } +} + +void rocksdb_options_set_env(rocksdb_options_t* opt, rocksdb_env_t* env) { + opt->rep.env = (env ? env->rep : nullptr); +} + +void rocksdb_options_set_info_log(rocksdb_options_t* opt, rocksdb_logger_t* l) { + if (l) { + opt->rep.info_log = l->rep; + } +} + +rocksdb_logger_t* rocksdb_options_get_info_log(rocksdb_options_t* opt) { + rocksdb_logger_t* info_log = new rocksdb_logger_t; + info_log->rep = opt->rep.info_log; + return info_log; +} + +void rocksdb_options_set_write_buffer_manager( + rocksdb_options_t* opt, rocksdb_write_buffer_manager_t* wbm) { + opt->rep.write_buffer_manager = wbm->rep; +} + +void rocksdb_options_set_sst_file_manager(rocksdb_options_t* opt, + rocksdb_sst_file_manager_t* sfm) { + opt->rep.sst_file_manager = sfm->rep; +} + +void rocksdb_options_enable_statistics(rocksdb_options_t* opt) { + opt->rep.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics(); +} + +void rocksdb_options_set_statistics_level(rocksdb_options_t* opt, int level) { + if (!opt->rep.statistics) { + return; + } + + if (level < rocksdb_statistics_level_disable_all) { + level = rocksdb_statistics_level_disable_all; + } + if (level > rocksdb_statistics_level_all) { + level = rocksdb_statistics_level_all; + } + opt->rep.statistics->set_stats_level( + static_cast(level)); +} + +int rocksdb_options_get_statistics_level(rocksdb_options_t* opt) { + if (!opt->rep.statistics) { + return ROCKSDB_NAMESPACE::StatsLevel::kDisableAll; + } + + return static_cast(opt->rep.statistics->get_stats_level()); +} + +void rocksdb_options_set_blob_cache(rocksdb_options_t* opt, + rocksdb_cache_t* blob_cache) { + opt->rep.blob_cache = blob_cache->rep; +} + +void rocksdb_options_set_prefix_extractor( + rocksdb_options_t* opt, rocksdb_slicetransform_t* prefix_extractor) { + opt->rep.prefix_extractor.reset(prefix_extractor); +} + +void rocksdb_options_prepare_for_bulk_load(rocksdb_options_t* opt) { + opt->rep.PrepareForBulkLoad(); +} + +void rocksdb_options_set_memtable_vector_rep(rocksdb_options_t* opt) { + opt->rep.memtable_factory = + std::make_shared(); +} + +void rocksdb_options_set_hash_skip_list_rep(rocksdb_options_t* opt, + size_t bucket_count, + int32_t skiplist_height, + int32_t skiplist_branching_factor) { + ROCKSDB_NAMESPACE::MemTableRepFactory* factory = + ROCKSDB_NAMESPACE::NewHashSkipListRepFactory( + bucket_count, skiplist_height, skiplist_branching_factor); + opt->rep.memtable_factory.reset(factory); +} + +void rocksdb_options_set_hash_link_list_rep(rocksdb_options_t* opt, + size_t bucket_count) { + opt->rep.memtable_factory.reset( + ROCKSDB_NAMESPACE::NewHashLinkListRepFactory(bucket_count)); +} + +void rocksdb_options_set_plain_table_factory( + rocksdb_options_t* opt, uint32_t user_key_len, int bloom_bits_per_key, + double hash_table_ratio, size_t index_sparseness, size_t huge_page_tlb_size, + char encoding_type, unsigned char full_scan_mode, + unsigned char store_index_in_file) { + ROCKSDB_NAMESPACE::PlainTableOptions options; + options.user_key_len = user_key_len; + options.bloom_bits_per_key = bloom_bits_per_key; + options.hash_table_ratio = hash_table_ratio; + options.index_sparseness = index_sparseness; + options.huge_page_tlb_size = huge_page_tlb_size; + options.encoding_type = + static_cast(encoding_type); + options.full_scan_mode = full_scan_mode; + options.store_index_in_file = store_index_in_file; + + ROCKSDB_NAMESPACE::TableFactory* factory = + ROCKSDB_NAMESPACE::NewPlainTableFactory(options); + opt->rep.table_factory.reset(factory); +} + +void rocksdb_options_set_universal_compaction_options( + rocksdb_options_t* opt, rocksdb_universal_compaction_options_t* uco) { + opt->rep.compaction_options_universal = *(uco->rep); +} + +void rocksdb_options_set_fifo_compaction_options( + rocksdb_options_t* opt, rocksdb_fifo_compaction_options_t* fifo) { + opt->rep.compaction_options_fifo = fifo->rep; +} + +char* rocksdb_options_statistics_get_string(rocksdb_options_t* opt) { + ROCKSDB_NAMESPACE::Statistics* statistics = opt->rep.statistics.get(); + if (statistics) { + return strdup(statistics->ToString().c_str()); + } + return nullptr; +} + +uint64_t rocksdb_options_statistics_get_ticker_count(rocksdb_options_t* opt, + uint32_t ticker_type) { + ROCKSDB_NAMESPACE::Statistics* statistics = opt->rep.statistics.get(); + if (statistics) { + return statistics->getTickerCount(ticker_type); + } + return 0; +} + +void rocksdb_options_statistics_get_histogram_data( + rocksdb_options_t* opt, uint32_t type, + rocksdb_statistics_histogram_data_t* const data) { + ROCKSDB_NAMESPACE::Statistics* statistics = opt->rep.statistics.get(); + if (statistics) { + statistics->histogramData(type, &data->rep); + } else { + *data = rocksdb_statistics_histogram_data_t{}; + } +} + +void rocksdb_options_set_ratelimiter(rocksdb_options_t* opt, + rocksdb_ratelimiter_t* limiter) { + if (limiter) { + opt->rep.rate_limiter = limiter->rep; + } +} + +rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(int64_t rate_bytes_per_sec, + int64_t refill_period_us, + int32_t fairness) { + rocksdb_ratelimiter_t* rate_limiter = new rocksdb_ratelimiter_t; + rate_limiter->rep.reset( + NewGenericRateLimiter(rate_bytes_per_sec, refill_period_us, fairness)); + return rate_limiter; +} + +rocksdb_ratelimiter_t* rocksdb_ratelimiter_create_auto_tuned( + int64_t rate_bytes_per_sec, int64_t refill_period_us, int32_t fairness) { + rocksdb_ratelimiter_t* rate_limiter = new rocksdb_ratelimiter_t; + rate_limiter->rep.reset(NewGenericRateLimiter(rate_bytes_per_sec, + refill_period_us, fairness, + RateLimiter::Mode::kWritesOnly, + true)); // auto_tuned + return rate_limiter; +} + +rocksdb_ratelimiter_t* rocksdb_ratelimiter_create_with_mode( + int64_t rate_bytes_per_sec, int64_t refill_period_us, int32_t fairness, + int mode, bool auto_tuned) { + rocksdb_ratelimiter_t* rate_limiter = new rocksdb_ratelimiter_t; + rate_limiter->rep.reset( + NewGenericRateLimiter(rate_bytes_per_sec, refill_period_us, fairness, + static_cast(mode), auto_tuned)); + return rate_limiter; +} + +void rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t* limiter) { + delete limiter; +} + +void rocksdb_options_set_row_cache(rocksdb_options_t* opt, + rocksdb_cache_t* cache) { + if (cache) { + opt->rep.row_cache = cache->rep; + } +} + +void rocksdb_options_add_compact_on_deletion_collector_factory( + rocksdb_options_t* opt, size_t window_size, size_t num_dels_trigger) { + std::shared_ptr + compact_on_del = + NewCompactOnDeletionCollectorFactory(window_size, num_dels_trigger); + opt->rep.table_properties_collector_factories.emplace_back(compact_on_del); +} + +void rocksdb_options_add_compact_on_deletion_collector_factory_del_ratio( + rocksdb_options_t* opt, size_t window_size, size_t num_dels_trigger, + double deletion_ratio) { + std::shared_ptr + compact_on_del = NewCompactOnDeletionCollectorFactory( + window_size, num_dels_trigger, deletion_ratio); + opt->rep.table_properties_collector_factories.emplace_back(compact_on_del); +} + +void rocksdb_options_add_compact_on_deletion_collector_factory_min_file_size( + rocksdb_options_t* opt, size_t window_size, size_t num_dels_trigger, + double deletion_ratio, uint64_t min_file_size) { + std::shared_ptr + compact_on_del = NewCompactOnDeletionCollectorFactory( + window_size, num_dels_trigger, deletion_ratio, min_file_size); + opt->rep.table_properties_collector_factories.emplace_back(compact_on_del); +} + +void rocksdb_set_perf_level(int v) { + PerfLevel level = static_cast(v); + SetPerfLevel(level); +} + +rocksdb_perfcontext_t* rocksdb_perfcontext_create() { + rocksdb_perfcontext_t* context = new rocksdb_perfcontext_t; + context->rep = ROCKSDB_NAMESPACE::get_perf_context(); + return context; +} + +void rocksdb_perfcontext_reset(rocksdb_perfcontext_t* context) { + context->rep->Reset(); +} + +char* rocksdb_perfcontext_report(rocksdb_perfcontext_t* context, + unsigned char exclude_zero_counters) { + return strdup(context->rep->ToString(exclude_zero_counters).c_str()); +} + +uint64_t rocksdb_perfcontext_metric(rocksdb_perfcontext_t* context, + int metric) { + PerfContext* rep = context->rep; + switch (metric) { + case rocksdb_user_key_comparison_count: + return rep->user_key_comparison_count; + case rocksdb_block_cache_hit_count: + return rep->block_cache_hit_count; + case rocksdb_block_read_count: + return rep->block_read_count; + case rocksdb_block_read_byte: + return rep->block_read_byte; + case rocksdb_block_read_time: + return rep->block_read_time; + case rocksdb_block_checksum_time: + return rep->block_checksum_time; + case rocksdb_block_decompress_time: + return rep->block_decompress_time; + case rocksdb_get_read_bytes: + return rep->get_read_bytes; + case rocksdb_multiget_read_bytes: + return rep->multiget_read_bytes; + case rocksdb_iter_read_bytes: + return rep->iter_read_bytes; + case rocksdb_internal_key_skipped_count: + return rep->internal_key_skipped_count; + case rocksdb_internal_delete_skipped_count: + return rep->internal_delete_skipped_count; + case rocksdb_internal_recent_skipped_count: + return rep->internal_recent_skipped_count; + case rocksdb_internal_merge_count: + return rep->internal_merge_count; + case rocksdb_internal_merge_point_lookup_count: + return rep->internal_merge_point_lookup_count; + case rocksdb_get_snapshot_time: + return rep->get_snapshot_time; + case rocksdb_get_from_memtable_time: + return rep->get_from_memtable_time; + case rocksdb_get_from_memtable_count: + return rep->get_from_memtable_count; + case rocksdb_get_post_process_time: + return rep->get_post_process_time; + case rocksdb_get_from_output_files_time: + return rep->get_from_output_files_time; + case rocksdb_seek_on_memtable_time: + return rep->seek_on_memtable_time; + case rocksdb_seek_on_memtable_count: + return rep->seek_on_memtable_count; + case rocksdb_next_on_memtable_count: + return rep->next_on_memtable_count; + case rocksdb_prev_on_memtable_count: + return rep->prev_on_memtable_count; + case rocksdb_seek_child_seek_time: + return rep->seek_child_seek_time; + case rocksdb_seek_child_seek_count: + return rep->seek_child_seek_count; + case rocksdb_seek_min_heap_time: + return rep->seek_min_heap_time; + case rocksdb_seek_max_heap_time: + return rep->seek_max_heap_time; + case rocksdb_seek_internal_seek_time: + return rep->seek_internal_seek_time; + case rocksdb_find_next_user_entry_time: + return rep->find_next_user_entry_time; + case rocksdb_write_wal_time: + return rep->write_wal_time; + case rocksdb_write_memtable_time: + return rep->write_memtable_time; + case rocksdb_write_delay_time: + return rep->write_delay_time; + case rocksdb_write_pre_and_post_process_time: + return rep->write_pre_and_post_process_time; + case rocksdb_db_mutex_lock_nanos: + return rep->db_mutex_lock_nanos; + case rocksdb_db_condition_wait_nanos: + return rep->db_condition_wait_nanos; + case rocksdb_merge_operator_time_nanos: + return rep->merge_operator_time_nanos; + case rocksdb_read_index_block_nanos: + return rep->read_index_block_nanos; + case rocksdb_read_filter_block_nanos: + return rep->read_filter_block_nanos; + case rocksdb_new_table_block_iter_nanos: + return rep->new_table_block_iter_nanos; + case rocksdb_new_table_iterator_nanos: + return rep->new_table_iterator_nanos; + case rocksdb_block_seek_nanos: + return rep->block_seek_nanos; + case rocksdb_find_table_nanos: + return rep->find_table_nanos; + case rocksdb_bloom_memtable_hit_count: + return rep->bloom_memtable_hit_count; + case rocksdb_bloom_memtable_miss_count: + return rep->bloom_memtable_miss_count; + case rocksdb_bloom_sst_hit_count: + return rep->bloom_sst_hit_count; + case rocksdb_bloom_sst_miss_count: + return rep->bloom_sst_miss_count; + case rocksdb_key_lock_wait_time: + return rep->key_lock_wait_time; + case rocksdb_key_lock_wait_count: + return rep->key_lock_wait_count; + case rocksdb_env_new_sequential_file_nanos: + return rep->env_new_sequential_file_nanos; + case rocksdb_env_new_random_access_file_nanos: + return rep->env_new_random_access_file_nanos; + case rocksdb_env_new_writable_file_nanos: + return rep->env_new_writable_file_nanos; + case rocksdb_env_reuse_writable_file_nanos: + return rep->env_reuse_writable_file_nanos; + case rocksdb_env_new_random_rw_file_nanos: + return rep->env_new_random_rw_file_nanos; + case rocksdb_env_new_directory_nanos: + return rep->env_new_directory_nanos; + case rocksdb_env_file_exists_nanos: + return rep->env_file_exists_nanos; + case rocksdb_env_get_children_nanos: + return rep->env_get_children_nanos; + case rocksdb_env_get_children_file_attributes_nanos: + return rep->env_get_children_file_attributes_nanos; + case rocksdb_env_delete_file_nanos: + return rep->env_delete_file_nanos; + case rocksdb_env_create_dir_nanos: + return rep->env_create_dir_nanos; + case rocksdb_env_create_dir_if_missing_nanos: + return rep->env_create_dir_if_missing_nanos; + case rocksdb_env_delete_dir_nanos: + return rep->env_delete_dir_nanos; + case rocksdb_env_get_file_size_nanos: + return rep->env_get_file_size_nanos; + case rocksdb_env_get_file_modification_time_nanos: + return rep->env_get_file_modification_time_nanos; + case rocksdb_env_rename_file_nanos: + return rep->env_rename_file_nanos; + case rocksdb_env_link_file_nanos: + return rep->env_link_file_nanos; + case rocksdb_env_lock_file_nanos: + return rep->env_lock_file_nanos; + case rocksdb_env_unlock_file_nanos: + return rep->env_unlock_file_nanos; + case rocksdb_env_new_logger_nanos: + return rep->env_new_logger_nanos; + case rocksdb_number_async_seek: + return rep->number_async_seek; + case rocksdb_blob_cache_hit_count: + return rep->blob_cache_hit_count; + case rocksdb_blob_read_count: + return rep->blob_read_count; + case rocksdb_blob_read_byte: + return rep->blob_read_byte; + case rocksdb_blob_read_time: + return rep->blob_read_time; + case rocksdb_blob_checksum_time: + return rep->blob_checksum_time; + case rocksdb_blob_decompress_time: + return rep->blob_decompress_time; + case rocksdb_internal_range_del_reseek_count: + return rep->internal_range_del_reseek_count; + case rocksdb_block_read_cpu_time: + return rep->block_read_cpu_time; + case rocksdb_data_block_read_byte: + return rep->data_block_read_byte; + case rocksdb_index_block_read_byte: + return rep->index_block_read_byte; + case rocksdb_filter_block_read_byte: + return rep->filter_block_read_byte; + case rocksdb_compression_dict_block_read_byte: + return rep->compression_dict_block_read_byte; + case rocksdb_metadata_block_read_byte: + return rep->metadata_block_read_byte; + default: + break; + } + return 0; +} + +void rocksdb_perfcontext_destroy(rocksdb_perfcontext_t* context) { + delete context; +} + +/* +TODO: +DB::GetOptions +DB::GetSortedWalFiles +DB::RunManualCompaction +custom cache +table_properties_collectors +*/ + +rocksdb_compactionfilter_t* rocksdb_compactionfilter_create( + void* state, void (*destructor)(void*), + unsigned char (*filter)(void*, int level, const char* key, + size_t key_length, const char* existing_value, + size_t value_length, char** new_value, + size_t* new_value_length, + unsigned char* value_changed), + const char* (*name)(void*)) { + rocksdb_compactionfilter_t* result = new rocksdb_compactionfilter_t; + result->state_ = state; + result->destructor_ = destructor; + result->filter_ = filter; + result->ignore_snapshots_ = true; + result->name_ = name; + return result; +} + +void rocksdb_compactionfilter_set_ignore_snapshots( + rocksdb_compactionfilter_t* filter, unsigned char whether_ignore) { + filter->ignore_snapshots_ = whether_ignore; +} + +void rocksdb_compactionfilter_destroy(rocksdb_compactionfilter_t* filter) { + delete filter; +} + +rocksdb_walfilter_t* rocksdb_walfilter_create( + void* state, void (*destructor)(void*), + rocksdb_walfilter_column_family_log_number_map_cb + column_family_log_number_map, + rocksdb_walfilter_log_record_found_cb log_record_found, + const char* (*name)(void*)) { + rocksdb_walfilter_t* result = new rocksdb_walfilter_t; + result->state_ = state; + result->destructor_ = destructor; + result->column_family_log_number_map_ = column_family_log_number_map; + result->log_record_found_ = log_record_found; + result->name_ = name; + return result; +} + +void rocksdb_walfilter_destroy(rocksdb_walfilter_t* filter) { delete filter; } + +unsigned char rocksdb_compactionfiltercontext_is_full_compaction( + rocksdb_compactionfiltercontext_t* context) { + return context->rep.is_full_compaction; +} + +unsigned char rocksdb_compactionfiltercontext_is_manual_compaction( + rocksdb_compactionfiltercontext_t* context) { + return context->rep.is_manual_compaction; +} + +rocksdb_compactionfilterfactory_t* rocksdb_compactionfilterfactory_create( + void* state, void (*destructor)(void*), + rocksdb_compactionfilter_t* (*create_compaction_filter)( + void*, rocksdb_compactionfiltercontext_t* context), + const char* (*name)(void*)) { + rocksdb_compactionfilterfactory_t* result = + new rocksdb_compactionfilterfactory_t; + result->state_ = state; + result->destructor_ = destructor; + result->create_compaction_filter_ = create_compaction_filter; + result->name_ = name; + return result; +} + +void rocksdb_compactionfilterfactory_destroy( + rocksdb_compactionfilterfactory_t* factory) { + delete factory; +} + +rocksdb_comparator_t* rocksdb_comparator_create( + void* state, void (*destructor)(void*), + int (*compare)(void*, const char* a, size_t alen, const char* b, + size_t blen), + const char* (*name)(void*)) { + rocksdb_comparator_t* result = new rocksdb_comparator_t; + result->state_ = state; + result->destructor_ = destructor; + result->compare_ = compare; + result->name_ = name; + result->compare_ts_ = nullptr; + result->compare_without_ts_ = nullptr; + return result; +} + +void rocksdb_comparator_destroy(rocksdb_comparator_t* cmp) { delete cmp; } + +rocksdb_comparator_t* rocksdb_comparator_with_ts_create( + void* state, void (*destructor)(void*), + int (*compare)(void*, const char* a, size_t alen, const char* b, + size_t blen), + int (*compare_ts)(void*, const char* a_ts, size_t a_tslen, const char* b_ts, + size_t b_tslen), + int (*compare_without_ts)(void*, const char* a, size_t alen, + unsigned char a_has_ts, const char* b, + size_t blen, unsigned char b_has_ts), + const char* (*name)(void*), size_t timestamp_size) { + rocksdb_comparator_t* result = new rocksdb_comparator_t(timestamp_size); + result->state_ = state; + result->destructor_ = destructor; + result->compare_ = compare; + result->compare_ts_ = compare_ts; + result->compare_without_ts_ = compare_without_ts; + result->name_ = name; + return result; +} + +void rocksdb_filterpolicy_destroy(rocksdb_filterpolicy_t* filter) { + delete filter; +} + +rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_format( + double bits_per_key, bool original_format) { + // Make a rocksdb_filterpolicy_t, but override all of its methods so + // they delegate to a NewBloomFilterPolicy() instead of user + // supplied C functions. + struct Wrapper : public rocksdb_filterpolicy_t { + const FilterPolicy* rep_; + ~Wrapper() override { delete rep_; } + const char* Name() const override { return rep_->Name(); } + const char* CompatibilityName() const override { + return rep_->CompatibilityName(); + } + // No need to override GetFilterBitsBuilder if this one is overridden + ROCKSDB_NAMESPACE::FilterBitsBuilder* GetBuilderWithContext( + const ROCKSDB_NAMESPACE::FilterBuildingContext& context) + const override { + return rep_->GetBuilderWithContext(context); + } + ROCKSDB_NAMESPACE::FilterBitsReader* GetFilterBitsReader( + const Slice& contents) const override { + return rep_->GetFilterBitsReader(contents); + } + static void DoNothing(void*) {} + }; + Wrapper* wrapper = new Wrapper; + wrapper->rep_ = NewBloomFilterPolicy(bits_per_key, original_format); + wrapper->state_ = nullptr; + wrapper->destructor_ = &Wrapper::DoNothing; + return wrapper; +} + +rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_full( + double bits_per_key) { + return rocksdb_filterpolicy_create_bloom_format(bits_per_key, false); +} + +rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom(double bits_per_key) { + return rocksdb_filterpolicy_create_bloom_format(bits_per_key, true); +} + +rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_ribbon_format( + double bloom_equivalent_bits_per_key, int bloom_before_level) { + // Make a rocksdb_filterpolicy_t, but override all of its methods so + // they delegate to a NewRibbonFilterPolicy() instead of user + // supplied C functions. + struct Wrapper : public rocksdb_filterpolicy_t { + const FilterPolicy* rep_; + ~Wrapper() override { delete rep_; } + const char* Name() const override { return rep_->Name(); } + const char* CompatibilityName() const override { + return rep_->CompatibilityName(); + } + ROCKSDB_NAMESPACE::FilterBitsBuilder* GetBuilderWithContext( + const ROCKSDB_NAMESPACE::FilterBuildingContext& context) + const override { + return rep_->GetBuilderWithContext(context); + } + ROCKSDB_NAMESPACE::FilterBitsReader* GetFilterBitsReader( + const Slice& contents) const override { + return rep_->GetFilterBitsReader(contents); + } + static void DoNothing(void*) {} + }; + Wrapper* wrapper = new Wrapper; + wrapper->rep_ = + NewRibbonFilterPolicy(bloom_equivalent_bits_per_key, bloom_before_level); + wrapper->state_ = nullptr; + wrapper->destructor_ = &Wrapper::DoNothing; + return wrapper; +} + +rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_ribbon( + double bloom_equivalent_bits_per_key) { + return rocksdb_filterpolicy_create_ribbon_format( + bloom_equivalent_bits_per_key, /*bloom_before_level = disabled*/ -1); +} + +rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_ribbon_hybrid( + double bloom_equivalent_bits_per_key, int bloom_before_level) { + return rocksdb_filterpolicy_create_ribbon_format( + bloom_equivalent_bits_per_key, bloom_before_level); +} + +rocksdb_mergeoperator_t* rocksdb_mergeoperator_create( + void* state, void (*destructor)(void*), + char* (*full_merge)(void*, const char* key, size_t key_length, + const char* existing_value, + size_t existing_value_length, + const char* const* operands_list, + const size_t* operands_list_length, int num_operands, + unsigned char* success, size_t* new_value_length), + char* (*partial_merge)(void*, const char* key, size_t key_length, + const char* const* operands_list, + const size_t* operands_list_length, int num_operands, + unsigned char* success, size_t* new_value_length), + void (*delete_value)(void*, const char* value, size_t value_length), + const char* (*name)(void*)) { + rocksdb_mergeoperator_t* result = new rocksdb_mergeoperator_t; + result->state_ = state; + result->destructor_ = destructor; + result->full_merge_ = full_merge; + result->partial_merge_ = partial_merge; + result->delete_value_ = delete_value; + result->name_ = name; + return result; +} + +void rocksdb_mergeoperator_destroy(rocksdb_mergeoperator_t* merge_operator) { + delete merge_operator; +} + +rocksdb_readoptions_t* rocksdb_readoptions_create() { + return new rocksdb_readoptions_t; +} + +void rocksdb_readoptions_destroy(rocksdb_readoptions_t* opt) { delete opt; } + +#include "c_api_gen/c_generated_readoptions_auto.cc.inc" + +void rocksdb_readoptions_set_snapshot(rocksdb_readoptions_t* opt, + const rocksdb_snapshot_t* snap) { + opt->rep.snapshot = (snap ? snap->rep : nullptr); +} + +void rocksdb_readoptions_set_iterate_upper_bound(rocksdb_readoptions_t* opt, + const char* key, + size_t keylen) { + if (key == nullptr) { + opt->upper_bound = Slice(); + opt->rep.iterate_upper_bound = nullptr; + + } else { + opt->upper_bound = Slice(key, keylen); + opt->rep.iterate_upper_bound = &opt->upper_bound; + } +} + +void rocksdb_readoptions_set_iterate_lower_bound(rocksdb_readoptions_t* opt, + const char* key, + size_t keylen) { + if (key == nullptr) { + opt->lower_bound = Slice(); + opt->rep.iterate_lower_bound = nullptr; + } else { + opt->lower_bound = Slice(key, keylen); + opt->rep.iterate_lower_bound = &opt->lower_bound; + } +} + +void rocksdb_readoptions_set_timestamp(rocksdb_readoptions_t* opt, + const char* ts, size_t tslen) { + if (ts == nullptr) { + opt->timestamp = Slice(); + opt->rep.timestamp = nullptr; + } else { + opt->timestamp = Slice(ts, tslen); + opt->rep.timestamp = &opt->timestamp; + } +} + +void rocksdb_readoptions_set_iter_start_ts(rocksdb_readoptions_t* opt, + const char* ts, size_t tslen) { + if (ts == nullptr) { + opt->iter_start_ts = Slice(); + opt->rep.iter_start_ts = nullptr; + } else { + opt->iter_start_ts = Slice(ts, tslen); + opt->rep.iter_start_ts = &opt->iter_start_ts; + } +} + +void rocksdb_readoptions_set_merge_operand_count_threshold( + rocksdb_readoptions_t* opt, size_t threshold) { + opt->rep.merge_operand_count_threshold = threshold; +} + +void rocksdb_readoptions_clear_merge_operand_count_threshold( + rocksdb_readoptions_t* opt) { + opt->rep.merge_operand_count_threshold.reset(); +} + +unsigned char rocksdb_readoptions_has_merge_operand_count_threshold( + rocksdb_readoptions_t* opt) { + return opt->rep.merge_operand_count_threshold.has_value(); +} + +size_t rocksdb_readoptions_get_merge_operand_count_threshold( + rocksdb_readoptions_t* opt) { + return opt->rep.merge_operand_count_threshold.value_or(0); +} + +void rocksdb_readoptions_set_request_id(rocksdb_readoptions_t* opt, + const char* request_id, + size_t request_id_len) { + if (request_id == nullptr) { + opt->request_id.reset(); + opt->rep.request_id = nullptr; + return; + } + if (!opt->request_id) { + opt->request_id = std::make_unique(); + } + opt->request_id->assign(request_id, request_id_len); + opt->rep.request_id = opt->request_id.get(); +} + +void rocksdb_readoptions_clear_request_id(rocksdb_readoptions_t* opt) { + opt->request_id.reset(); + opt->rep.request_id = nullptr; +} + +const char* rocksdb_readoptions_get_request_id(rocksdb_readoptions_t* opt, + size_t* request_id_len) { + if (opt->rep.request_id == nullptr) { + if (request_id_len != nullptr) { + *request_id_len = 0; + } + return nullptr; + } + if (request_id_len != nullptr) { + *request_id_len = opt->rep.request_id->size(); + } + return opt->rep.request_id->data(); +} + +void rocksdb_readoptions_set_table_filter( + rocksdb_readoptions_t* opt, void* state, void (*destructor)(void*), + rocksdb_readoptions_table_filter_cb table_filter) { + opt->SetTableFilter(state, destructor, table_filter); +} + +void rocksdb_readoptions_clear_table_filter(rocksdb_readoptions_t* opt) { + opt->ClearTableFilter(); +} + +unsigned char rocksdb_readoptions_has_table_filter( + const rocksdb_readoptions_t* opt) { + return opt->table_filter_callback != nullptr; +} + +void rocksdb_readoptions_set_table_index_factory_from_string( + rocksdb_readoptions_t* opt, const char* value, size_t value_len, + char** errptr) { + opt->table_index_factory.reset(); + opt->rep.table_index_factory = nullptr; + if (value == nullptr) { + return; + } + + std::shared_ptr factory; + Status s = LoadUserDefinedIndexFactoryFromString(value, value_len, &factory); + if (SaveError(errptr, s)) { + return; + } + opt->table_index_factory = std::move(factory); + opt->rep.table_index_factory = opt->table_index_factory.get(); +} + +void rocksdb_readoptions_clear_table_index_factory(rocksdb_readoptions_t* opt) { + opt->table_index_factory.reset(); + opt->rep.table_index_factory = nullptr; +} + +const char* rocksdb_readoptions_get_table_index_factory_name( + const rocksdb_readoptions_t* opt, size_t* name_len) { + if (opt->table_index_factory == nullptr) { + if (name_len != nullptr) { + *name_len = 0; + } + return nullptr; + } + const char* name = opt->table_index_factory->Name(); + if (name_len != nullptr) { + *name_len = strlen(name); + } + return name; +} + +rocksdb_writeoptions_t* rocksdb_writeoptions_create() { + return new rocksdb_writeoptions_t; +} + +void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t* opt) { delete opt; } + +rocksdb_compaction_options_t* rocksdb_compaction_options_create() { + return new rocksdb_compaction_options_t; +} + +void rocksdb_compaction_options_destroy(rocksdb_compaction_options_t* opt) { + delete opt; +} + +unsigned char* rocksdb_compaction_options_canceled_create() { + return reinterpret_cast(new std::atomic(false)); +} + +void rocksdb_compaction_options_canceled_destroy(unsigned char* canceled) { + if (canceled != nullptr) { + delete reinterpret_cast*>(canceled); + } +} + +void rocksdb_compaction_options_canceled_set(unsigned char* canceled, + unsigned char value) { + if (canceled != nullptr) { + reinterpret_cast*>(canceled)->store(value != 0); + } +} + +void rocksdb_compaction_options_set_canceled( + rocksdb_compaction_options_t* options, unsigned char* canceled) { + options->rep.canceled = canceled != nullptr + ? reinterpret_cast*>(canceled) + : nullptr; +} + +rocksdb_compactoptions_t* rocksdb_compactoptions_create() { + return new rocksdb_compactoptions_t; +} + +void rocksdb_compactoptions_destroy(rocksdb_compactoptions_t* opt) { + delete opt; +} + +void rocksdb_compactoptions_set_bottommost_level_compaction( + rocksdb_compactoptions_t* opt, unsigned char v) { + opt->rep.bottommost_level_compaction = + static_cast(v); +} + +unsigned char rocksdb_compactoptions_get_bottommost_level_compaction( + rocksdb_compactoptions_t* opt) { + return static_cast(opt->rep.bottommost_level_compaction); +} + +void rocksdb_compactoptions_set_exclusive_manual_compaction( + rocksdb_compactoptions_t* opt, unsigned char v) { + opt->rep.exclusive_manual_compaction = v; +} + +unsigned char rocksdb_compactoptions_get_exclusive_manual_compaction( + rocksdb_compactoptions_t* opt) { + return opt->rep.exclusive_manual_compaction; +} + +void rocksdb_compactoptions_set_change_level(rocksdb_compactoptions_t* opt, + unsigned char v) { + opt->rep.change_level = v; +} + +unsigned char rocksdb_compactoptions_get_change_level( + rocksdb_compactoptions_t* opt) { + return opt->rep.change_level; +} + +void rocksdb_compactoptions_set_target_level(rocksdb_compactoptions_t* opt, + int n) { + opt->rep.target_level = n; +} + +int rocksdb_compactoptions_get_target_level(rocksdb_compactoptions_t* opt) { + return opt->rep.target_level; +} + +void rocksdb_compactoptions_set_target_path_id(rocksdb_compactoptions_t* opt, + int n) { + opt->rep.target_path_id = n; +} + +int rocksdb_compactoptions_get_target_path_id(rocksdb_compactoptions_t* opt) { + return opt->rep.target_path_id; +} + +void rocksdb_compactoptions_set_allow_write_stall(rocksdb_compactoptions_t* opt, + unsigned char v) { + opt->rep.allow_write_stall = v; +} + +unsigned char rocksdb_compactoptions_get_allow_write_stall( + rocksdb_compactoptions_t* opt) { + return opt->rep.allow_write_stall; +} + +void rocksdb_compactoptions_set_max_subcompactions( + rocksdb_compactoptions_t* opt, int n) { + opt->rep.max_subcompactions = n; +} + +int rocksdb_compactoptions_get_max_subcompactions( + rocksdb_compactoptions_t* opt) { + return opt->rep.max_subcompactions; +} + +void rocksdb_compactoptions_set_full_history_ts_low( + rocksdb_compactoptions_t* opt, char* ts, size_t tslen) { + if (ts == nullptr) { + opt->full_history_ts_low = Slice(); + opt->rep.full_history_ts_low = nullptr; + } else { + opt->full_history_ts_low = Slice(ts, tslen); + opt->rep.full_history_ts_low = &opt->full_history_ts_low; + } +} + +rocksdb_flushoptions_t* rocksdb_flushoptions_create() { + return new rocksdb_flushoptions_t; +} + +void rocksdb_flushoptions_destroy(rocksdb_flushoptions_t* opt) { delete opt; } + +rocksdb_flushwaloptions_t* rocksdb_flushwaloptions_create() { + return new rocksdb_flushwaloptions_t; +} + +void rocksdb_flushwaloptions_destroy(rocksdb_flushwaloptions_t* opt) { + delete opt; +} + +void rocksdb_flush_wal_with_options(rocksdb_t* db, + const rocksdb_flushwaloptions_t* options, + char** errptr) { + FlushWALOptions default_options; + SaveError(errptr, + db->rep->FlushWAL(GetFlushWALOptions(options, &default_options))); +} + +rocksdb_memory_allocator_t* rocksdb_jemalloc_nodump_allocator_create( + char** errptr) { + rocksdb_memory_allocator_t* allocator = new rocksdb_memory_allocator_t; + ROCKSDB_NAMESPACE::JemallocAllocatorOptions options; + SaveError(errptr, ROCKSDB_NAMESPACE::NewJemallocNodumpAllocator( + options, &allocator->rep)); + return allocator; +} + +void rocksdb_memory_allocator_destroy(rocksdb_memory_allocator_t* allocator) { + delete allocator; +} + +rocksdb_lru_cache_options_t* rocksdb_lru_cache_options_create() { + return new rocksdb_lru_cache_options_t; +} + +void rocksdb_lru_cache_options_destroy(rocksdb_lru_cache_options_t* opt) { + delete opt; +} + +void rocksdb_lru_cache_options_set_capacity(rocksdb_lru_cache_options_t* opt, + size_t capacity) { + opt->rep.capacity = capacity; +} + +void rocksdb_lru_cache_options_set_num_shard_bits( + rocksdb_lru_cache_options_t* opt, int num_shard_bits) { + opt->rep.num_shard_bits = num_shard_bits; +} + +void rocksdb_lru_cache_options_set_memory_allocator( + rocksdb_lru_cache_options_t* opt, rocksdb_memory_allocator_t* allocator) { + opt->rep.memory_allocator = allocator->rep; +} + +rocksdb_cache_t* rocksdb_cache_create_lru(size_t capacity) { + rocksdb_cache_t* c = new rocksdb_cache_t; + c->rep = NewLRUCache(capacity); + return c; +} + +rocksdb_cache_t* rocksdb_cache_create_lru_with_strict_capacity_limit( + size_t capacity) { + rocksdb_cache_t* c = new rocksdb_cache_t; + c->rep = NewLRUCache(capacity); + c->rep->SetStrictCapacityLimit(true); + return c; +} + +rocksdb_cache_t* rocksdb_cache_create_lru_opts( + const rocksdb_lru_cache_options_t* opt) { + rocksdb_cache_t* c = new rocksdb_cache_t; + c->rep = NewLRUCache(opt->rep); + return c; +} + +rocksdb_hyper_clock_cache_options_t* rocksdb_hyper_clock_cache_options_create( + size_t capacity, size_t estimated_entry_charge) { + return new rocksdb_hyper_clock_cache_options_t{ + HyperClockCacheOptions(capacity, estimated_entry_charge)}; +} + +void rocksdb_hyper_clock_cache_options_destroy( + rocksdb_hyper_clock_cache_options_t* opt) { + delete opt; +} + +void rocksdb_hyper_clock_cache_options_set_capacity( + rocksdb_hyper_clock_cache_options_t* opts, size_t capacity) { + opts->rep.capacity = capacity; +} + +void rocksdb_hyper_clock_cache_options_set_estimated_entry_charge( + rocksdb_hyper_clock_cache_options_t* opts, size_t estimated_entry_charge) { + opts->rep.estimated_entry_charge = estimated_entry_charge; +} + +void rocksdb_hyper_clock_cache_options_set_num_shard_bits( + rocksdb_hyper_clock_cache_options_t* opts, int num_shard_bits) { + opts->rep.num_shard_bits = num_shard_bits; +} + +void rocksdb_hyper_clock_cache_options_set_memory_allocator( + rocksdb_hyper_clock_cache_options_t* opts, + rocksdb_memory_allocator_t* memory_allocator) { + opts->rep.memory_allocator = memory_allocator->rep; +} + +rocksdb_cache_t* rocksdb_cache_create_hyper_clock( + size_t capacity, size_t estimated_entry_charge) { + HyperClockCacheOptions opts(capacity, estimated_entry_charge); + rocksdb_cache_t* c = new rocksdb_cache_t; + c->rep = opts.MakeSharedCache(); + return c; +} + +rocksdb_cache_t* rocksdb_cache_create_hyper_clock_opts( + const rocksdb_hyper_clock_cache_options_t* opts) { + rocksdb_cache_t* c = new rocksdb_cache_t; + c->rep = opts->rep.MakeSharedCache(); + return c; +} + +void rocksdb_cache_destroy(rocksdb_cache_t* cache) { delete cache; } + +void rocksdb_cache_disown_data(rocksdb_cache_t* cache) { + cache->rep->DisownData(); +} + +void rocksdb_cache_set_capacity(rocksdb_cache_t* cache, size_t capacity) { + cache->rep->SetCapacity(capacity); +} + +size_t rocksdb_cache_get_capacity(const rocksdb_cache_t* cache) { + return cache->rep->GetCapacity(); +} + +size_t rocksdb_cache_get_usage(const rocksdb_cache_t* cache) { + return cache->rep->GetUsage(); +} + +size_t rocksdb_cache_get_pinned_usage(const rocksdb_cache_t* cache) { + return cache->rep->GetPinnedUsage(); +} + +size_t rocksdb_cache_get_table_address_count(const rocksdb_cache_t* cache) { + return cache->rep->GetTableAddressCount(); +} + +size_t rocksdb_cache_get_occupancy_count(const rocksdb_cache_t* cache) { + return cache->rep->GetOccupancyCount(); +} + +rocksdb_write_buffer_manager_t* rocksdb_write_buffer_manager_create( + size_t buffer_size, bool allow_stall) { + rocksdb_write_buffer_manager_t* wbm = new rocksdb_write_buffer_manager_t; + wbm->rep = std::make_shared( + buffer_size, std::shared_ptr{}, allow_stall); + return wbm; +} + +rocksdb_write_buffer_manager_t* rocksdb_write_buffer_manager_create_with_cache( + size_t buffer_size, const rocksdb_cache_t* cache, bool allow_stall) { + rocksdb_write_buffer_manager_t* wbm = new rocksdb_write_buffer_manager_t; + wbm->rep = std::make_shared(buffer_size, cache->rep, + allow_stall); + return wbm; +} + +void rocksdb_write_buffer_manager_destroy(rocksdb_write_buffer_manager_t* wbm) { + delete wbm; +} + +bool rocksdb_write_buffer_manager_enabled(rocksdb_write_buffer_manager_t* wbm) { + return wbm->rep->enabled(); +} + +bool rocksdb_write_buffer_manager_cost_to_cache( + rocksdb_write_buffer_manager_t* wbm) { + return wbm->rep->cost_to_cache(); +} + +size_t rocksdb_write_buffer_manager_memory_usage( + rocksdb_write_buffer_manager_t* wbm) { + return wbm->rep->memory_usage(); +} + +size_t rocksdb_write_buffer_manager_mutable_memtable_memory_usage( + rocksdb_write_buffer_manager_t* wbm) { + return wbm->rep->mutable_memtable_memory_usage(); +} + +size_t rocksdb_write_buffer_manager_dummy_entries_in_cache_usage( + rocksdb_write_buffer_manager_t* wbm) { + return wbm->rep->dummy_entries_in_cache_usage(); +} +size_t rocksdb_write_buffer_manager_buffer_size( + rocksdb_write_buffer_manager_t* wbm) { + return wbm->rep->buffer_size(); +} +void rocksdb_write_buffer_manager_set_buffer_size( + rocksdb_write_buffer_manager_t* wbm, size_t new_size) { + wbm->rep->SetBufferSize(new_size); +} +ROCKSDB_LIBRARY_API void rocksdb_write_buffer_manager_set_allow_stall( + rocksdb_write_buffer_manager_t* wbm, bool new_allow_stall) { + wbm->rep->SetAllowStall(new_allow_stall); +} + +rocksdb_sst_file_manager_t* rocksdb_sst_file_manager_create( + rocksdb_env_t* env) { + rocksdb_sst_file_manager_t* sfm = new rocksdb_sst_file_manager_t; + sfm->rep.reset(ROCKSDB_NAMESPACE::NewSstFileManager(env->rep)); + return sfm; +} + +void rocksdb_sst_file_manager_destroy(rocksdb_sst_file_manager_t* sfm) { + delete sfm; +} + +void rocksdb_sst_file_manager_set_max_allowed_space_usage( + rocksdb_sst_file_manager_t* sfm, uint64_t max_allowed_space) { + sfm->rep->SetMaxAllowedSpaceUsage(max_allowed_space); +} + +void rocksdb_sst_file_manager_set_compaction_buffer_size( + rocksdb_sst_file_manager_t* sfm, uint64_t compaction_buffer_size) { + sfm->rep->SetCompactionBufferSize(compaction_buffer_size); +} + +bool rocksdb_sst_file_manager_is_max_allowed_space_reached( + rocksdb_sst_file_manager_t* sfm) { + return sfm->rep->IsMaxAllowedSpaceReached(); +} + +bool rocksdb_sst_file_manager_is_max_allowed_space_reached_including_compactions( + rocksdb_sst_file_manager_t* sfm) { + return sfm->rep->IsMaxAllowedSpaceReachedIncludingCompactions(); +} + +uint64_t rocksdb_sst_file_manager_get_total_size( + rocksdb_sst_file_manager_t* sfm) { + return sfm->rep->GetTotalSize(); +} + +int64_t rocksdb_sst_file_manager_get_delete_rate_bytes_per_second( + rocksdb_sst_file_manager_t* sfm) { + return sfm->rep->GetDeleteRateBytesPerSecond(); +} + +void rocksdb_sst_file_manager_set_delete_rate_bytes_per_second( + rocksdb_sst_file_manager_t* sfm, int64_t delete_rate) { + return sfm->rep->SetDeleteRateBytesPerSecond(delete_rate); +} + +double rocksdb_sst_file_manager_get_max_trash_db_ratio( + rocksdb_sst_file_manager_t* sfm) { + return sfm->rep->GetMaxTrashDBRatio(); +} + +void rocksdb_sst_file_manager_set_max_trash_db_ratio( + rocksdb_sst_file_manager_t* sfm, double ratio) { + return sfm->rep->SetMaxTrashDBRatio(ratio); +} + +uint64_t rocksdb_sst_file_manager_get_total_trash_size( + rocksdb_sst_file_manager_t* sfm) { + return sfm->rep->GetTotalTrashSize(); +} + +rocksdb_dbpath_t* rocksdb_dbpath_create(const char* path, + uint64_t target_size) { + rocksdb_dbpath_t* result = new rocksdb_dbpath_t; + result->rep.path = std::string(path); + result->rep.target_size = target_size; + return result; +} + +void rocksdb_dbpath_destroy(rocksdb_dbpath_t* dbpath) { delete dbpath; } + +rocksdb_env_t* rocksdb_create_default_env() { + rocksdb_env_t* result = new rocksdb_env_t; + result->rep = Env::Default(); + result->is_default = true; + return result; +} + +rocksdb_env_t* rocksdb_create_mem_env() { + rocksdb_env_t* result = new rocksdb_env_t; + result->rep = ROCKSDB_NAMESPACE::NewMemEnv(Env::Default()); + result->is_default = false; + return result; +} + +void rocksdb_env_set_background_threads(rocksdb_env_t* env, int n) { + env->rep->SetBackgroundThreads(n); +} + +int rocksdb_env_get_background_threads(rocksdb_env_t* env) { + return env->rep->GetBackgroundThreads(); +} + +void rocksdb_env_set_bottom_priority_background_threads(rocksdb_env_t* env, + int n) { + env->rep->SetBackgroundThreads(n, Env::BOTTOM); +} + +int rocksdb_env_get_bottom_priority_background_threads(rocksdb_env_t* env) { + return env->rep->GetBackgroundThreads(Env::BOTTOM); +} + +void rocksdb_env_set_high_priority_background_threads(rocksdb_env_t* env, + int n) { + env->rep->SetBackgroundThreads(n, Env::HIGH); +} + +int rocksdb_env_get_high_priority_background_threads(rocksdb_env_t* env) { + return env->rep->GetBackgroundThreads(Env::HIGH); +} + +void rocksdb_env_set_low_priority_background_threads(rocksdb_env_t* env, + int n) { + env->rep->SetBackgroundThreads(n, Env::LOW); +} + +int rocksdb_env_get_low_priority_background_threads(rocksdb_env_t* env) { + return env->rep->GetBackgroundThreads(Env::LOW); +} + +void rocksdb_env_join_all_threads(rocksdb_env_t* env) { + env->rep->WaitForJoin(); +} + +void rocksdb_env_lower_thread_pool_io_priority(rocksdb_env_t* env) { + env->rep->LowerThreadPoolIOPriority(); +} + +void rocksdb_env_lower_high_priority_thread_pool_io_priority( + rocksdb_env_t* env) { + env->rep->LowerThreadPoolIOPriority(Env::HIGH); +} + +void rocksdb_env_lower_thread_pool_cpu_priority(rocksdb_env_t* env) { + env->rep->LowerThreadPoolCPUPriority(); +} + +void rocksdb_env_lower_high_priority_thread_pool_cpu_priority( + rocksdb_env_t* env) { + env->rep->LowerThreadPoolCPUPriority(Env::HIGH); +} + +void rocksdb_env_destroy(rocksdb_env_t* env) { + if (!env->is_default) { + delete env->rep; + } + delete env; +} + +rocksdb_envoptions_t* rocksdb_envoptions_create() { + rocksdb_envoptions_t* opt = new rocksdb_envoptions_t; + return opt; +} + +void rocksdb_envoptions_destroy(rocksdb_envoptions_t* opt) { delete opt; } + +void rocksdb_envoptions_set_rate_limiter(rocksdb_envoptions_t* opt, + rocksdb_ratelimiter_t* rate_limiter) { + opt->rate_limiter = rate_limiter != nullptr ? rate_limiter->rep : nullptr; + opt->rep.rate_limiter = opt->rate_limiter.get(); +} + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4190) // C-linkage function returning C++ type +#endif +static Status CreateFileTraceWriter( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const char* trace_path, + std::unique_ptr* trace_writer, + Env** trace_env_out) { + Env* trace_env = env != nullptr ? env->rep : db->rep->GetEnv(); + EnvOptions default_env_options; + const EnvOptions& resolved_env_options = + env_options != nullptr ? env_options->rep : default_env_options; + *trace_env_out = trace_env; + return NewFileTraceWriter(trace_env, resolved_env_options, + std::string(trace_path), trace_writer); +} + +static Status CreateFileTraceReader( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const char* trace_path, std::unique_ptr* trace_reader) { + Env* trace_env = env != nullptr ? env->rep : db->rep->GetEnv(); + EnvOptions default_env_options; + const EnvOptions& resolved_env_options = + env_options != nullptr ? env_options->rep : default_env_options; + return NewFileTraceReader(trace_env, resolved_env_options, + std::string(trace_path), trace_reader); +} +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +rocksdb_trace_options_t* rocksdb_trace_options_create() { + return new rocksdb_trace_options_t; +} + +void rocksdb_trace_options_destroy(rocksdb_trace_options_t* options) { + delete options; +} + +rocksdb_trace_reader_t* rocksdb_trace_reader_create( + rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const char* trace_path, char** errptr) { + if (env == nullptr) { + SaveError(errptr, Status::InvalidArgument("env must not be null")); + return nullptr; + } + auto* result = new rocksdb_trace_reader_t; + EnvOptions default_env_options; + const EnvOptions& resolved_env_options = + env_options != nullptr ? env_options->rep : default_env_options; + if (SaveError(errptr, + NewFileTraceReader(env->rep, resolved_env_options, + std::string(trace_path), &result->rep))) { + delete result; + return nullptr; + } + return result; +} + +char* rocksdb_trace_reader_read(rocksdb_trace_reader_t* reader, size_t* size, + char** errptr) { + std::string data; + Status s = reader->rep->Read(&data); + if (s.IsIncomplete()) { + *size = 0; + return nullptr; + } + if (SaveError(errptr, s)) { + *size = 0; + return nullptr; + } + *size = data.size(); + return CopyString(Slice(data)); +} + +void rocksdb_trace_reader_reset(rocksdb_trace_reader_t* reader, char** errptr) { + SaveError(errptr, reader->rep->Reset()); +} + +void rocksdb_trace_reader_close(rocksdb_trace_reader_t* reader, char** errptr) { + SaveError(errptr, reader->rep->Close()); +} + +void rocksdb_trace_reader_destroy(rocksdb_trace_reader_t* reader) { + delete reader; +} + +rocksdb_replay_options_t* rocksdb_replay_options_create() { + return new rocksdb_replay_options_t; +} + +void rocksdb_replay_options_destroy(rocksdb_replay_options_t* options) { + delete options; +} + +void rocksdb_replay_options_set_num_threads(rocksdb_replay_options_t* options, + uint32_t num_threads) { + options->rep.num_threads = num_threads; +} + +uint32_t rocksdb_replay_options_get_num_threads( + rocksdb_replay_options_t* options) { + return options->rep.num_threads; +} + +void rocksdb_replay_options_set_fast_forward(rocksdb_replay_options_t* options, + double fast_forward) { + options->rep.fast_forward = fast_forward; +} + +double rocksdb_replay_options_get_fast_forward( + rocksdb_replay_options_t* options) { + return options->rep.fast_forward; +} + +rocksdb_replayer_t* rocksdb_new_default_replayer( + rocksdb_t* db, rocksdb_column_family_handle_t** column_families, + size_t num_column_families, rocksdb_env_t* env, + const rocksdb_envoptions_t* env_options, const char* trace_path, + char** errptr) { + if (column_families == nullptr && num_column_families > 0) { + SaveError(errptr, Status::InvalidArgument( + "column_families must not be null when count > 0")); + return nullptr; + } + + auto* result = new rocksdb_replayer_t; + std::vector handles; + if (num_column_families == 0) { + handles.push_back(db->rep->DefaultColumnFamily()); + } else { + handles.reserve(num_column_families); + for (size_t i = 0; i < num_column_families; ++i) { + handles.push_back(column_families[i]->rep); + } + } + + std::unique_ptr trace_reader; + if (SaveError(errptr, CreateFileTraceReader(db, env, env_options, trace_path, + &trace_reader))) { + delete result; + return nullptr; + } + if (SaveError(errptr, db->rep->NewDefaultReplayer( + handles, std::move(trace_reader), &result->rep))) { + delete result; + return nullptr; + } + return result; +} + +void rocksdb_replayer_prepare(rocksdb_replayer_t* replayer, char** errptr) { + SaveError(errptr, replayer->rep->Prepare()); +} + +uint64_t rocksdb_replayer_get_header_timestamp( + const rocksdb_replayer_t* replayer) { + return replayer->rep->GetHeaderTimestamp(); +} + +void rocksdb_replayer_replay(rocksdb_replayer_t* replayer, + const rocksdb_replay_options_t* options, + char** errptr) { + ReplayOptions default_options; + const ReplayOptions& replay_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, replayer->rep->Replay(replay_options, nullptr)); +} + +void rocksdb_replayer_destroy(rocksdb_replayer_t* replayer) { delete replayer; } + +rocksdb_block_cache_trace_options_t* +rocksdb_block_cache_trace_options_create() { + return new rocksdb_block_cache_trace_options_t; +} + +void rocksdb_block_cache_trace_options_destroy( + rocksdb_block_cache_trace_options_t* options) { + delete options; +} + +rocksdb_block_cache_trace_writer_options_t* +rocksdb_block_cache_trace_writer_options_create() { + return new rocksdb_block_cache_trace_writer_options_t; +} + +void rocksdb_block_cache_trace_writer_options_destroy( + rocksdb_block_cache_trace_writer_options_t* options) { + delete options; +} + +void rocksdb_start_trace(rocksdb_t* db, rocksdb_env_t* env, + const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, + const char* trace_path, char** errptr) { + std::unique_ptr trace_writer; + Env* trace_env = nullptr; + Status s = CreateFileTraceWriter(db, env, env_options, trace_path, + &trace_writer, &trace_env); + if (SaveError(errptr, s)) { + return; + } + (void)trace_env; + + TraceOptions default_options; + const TraceOptions& trace_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, + db->rep->StartTrace(trace_options, std::move(trace_writer))); +} + +void rocksdb_end_trace(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->EndTrace()); +} + +void rocksdb_start_io_trace(rocksdb_t* db, rocksdb_env_t* env, + const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, + const char* trace_path, char** errptr) { + std::unique_ptr trace_writer; + Env* trace_env = nullptr; + Status s = CreateFileTraceWriter(db, env, env_options, trace_path, + &trace_writer, &trace_env); + if (SaveError(errptr, s)) { + return; + } + (void)trace_env; + + TraceOptions default_options; + const TraceOptions& trace_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, + db->rep->StartIOTrace(trace_options, std::move(trace_writer))); +} + +void rocksdb_end_io_trace(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->EndIOTrace()); +} + +void rocksdb_start_block_cache_trace(rocksdb_t* db, rocksdb_env_t* env, + const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, + const char* trace_path, char** errptr) { + std::unique_ptr trace_writer; + Env* trace_env = nullptr; + Status s = CreateFileTraceWriter(db, env, env_options, trace_path, + &trace_writer, &trace_env); + if (SaveError(errptr, s)) { + return; + } + (void)trace_env; + + TraceOptions default_options; + const TraceOptions& trace_options = + options != nullptr ? options->rep : default_options; + SaveError(errptr, db->rep->StartBlockCacheTrace(trace_options, + std::move(trace_writer))); +} + +void rocksdb_start_block_cache_trace_with_options( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const rocksdb_block_cache_trace_options_t* options, + const rocksdb_block_cache_trace_writer_options_t* writer_options, + const char* trace_path, char** errptr) { + std::unique_ptr trace_writer; + Env* trace_env = nullptr; + Status s = CreateFileTraceWriter(db, env, env_options, trace_path, + &trace_writer, &trace_env); + if (SaveError(errptr, s)) { + return; + } + + BlockCacheTraceOptions default_options; + const BlockCacheTraceOptions& block_cache_trace_options = + options != nullptr ? options->rep : default_options; + BlockCacheTraceWriterOptions default_writer_options; + const BlockCacheTraceWriterOptions& block_cache_trace_writer_options = + writer_options != nullptr ? writer_options->rep : default_writer_options; + auto block_trace_writer = NewBlockCacheTraceWriter( + trace_env->GetSystemClock().get(), block_cache_trace_writer_options, + std::move(trace_writer)); + SaveError(errptr, + db->rep->StartBlockCacheTrace(block_cache_trace_options, + std::move(block_trace_writer))); +} + +void rocksdb_end_block_cache_trace(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->EndBlockCacheTrace()); +} + +rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create( + const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options) { + rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t; + writer->rep = new SstFileWriter(env->rep, io_options->rep); + return writer; +} + +void rocksdb_create_dir_if_missing(rocksdb_env_t* env, const char* path, + char** errptr) { + SaveError(errptr, env->rep->CreateDirIfMissing(std::string(path))); +} + +rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create_with_comparator( + const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options, + const rocksdb_comparator_t* /*comparator*/) { + rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t; + writer->rep = new SstFileWriter(env->rep, io_options->rep); + return writer; +} + +void rocksdb_sstfilewriter_open(rocksdb_sstfilewriter_t* writer, + const char* name, char** errptr) { + SaveError(errptr, writer->rep->Open(std::string(name))); +} + +void rocksdb_sstfilewriter_add(rocksdb_sstfilewriter_t* writer, const char* key, + size_t keylen, const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, writer->rep->Put(Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_sstfilewriter_put(rocksdb_sstfilewriter_t* writer, const char* key, + size_t keylen, const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, writer->rep->Put(Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_sstfilewriter_put_with_ts(rocksdb_sstfilewriter_t* writer, + const char* key, size_t keylen, + const char* ts, size_t tslen, + const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, writer->rep->Put(Slice(key, keylen), Slice(ts, tslen), + Slice(val, vallen))); +} + +void rocksdb_sstfilewriter_merge(rocksdb_sstfilewriter_t* writer, + const char* key, size_t keylen, + const char* val, size_t vallen, + char** errptr) { + SaveError(errptr, writer->rep->Merge(Slice(key, keylen), Slice(val, vallen))); +} + +void rocksdb_sstfilewriter_delete(rocksdb_sstfilewriter_t* writer, + const char* key, size_t keylen, + char** errptr) { + SaveError(errptr, writer->rep->Delete(Slice(key, keylen))); +} + +void rocksdb_sstfilewriter_delete_with_ts(rocksdb_sstfilewriter_t* writer, + const char* key, size_t keylen, + const char* ts, size_t tslen, + char** errptr) { + SaveError(errptr, writer->rep->Delete(Slice(key, keylen), Slice(ts, tslen))); +} + +void rocksdb_sstfilewriter_delete_range(rocksdb_sstfilewriter_t* writer, + const char* begin_key, + size_t begin_keylen, + const char* end_key, size_t end_keylen, + char** errptr) { + SaveError(errptr, writer->rep->DeleteRange(Slice(begin_key, begin_keylen), + Slice(end_key, end_keylen))); +} + +void rocksdb_sstfilewriter_finish(rocksdb_sstfilewriter_t* writer, + char** errptr) { + SaveError(errptr, writer->rep->Finish(nullptr)); +} + +void rocksdb_sstfilewriter_file_size(rocksdb_sstfilewriter_t* writer, + uint64_t* file_size) { + *file_size = writer->rep->FileSize(); +} + +void rocksdb_sstfilewriter_destroy(rocksdb_sstfilewriter_t* writer) { + delete writer->rep; + delete writer; +} + +rocksdb_ingestexternalfileoptions_t* +rocksdb_ingestexternalfileoptions_create() { + rocksdb_ingestexternalfileoptions_t* opt = + new rocksdb_ingestexternalfileoptions_t; + return opt; +} + +void rocksdb_ingestexternalfileoptions_set_move_files( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char move_files) { + opt->rep.move_files = move_files; +} + +void rocksdb_ingestexternalfileoptions_set_snapshot_consistency( + rocksdb_ingestexternalfileoptions_t* opt, + unsigned char snapshot_consistency) { + opt->rep.snapshot_consistency = snapshot_consistency; +} + +void rocksdb_ingestexternalfileoptions_set_allow_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt, + unsigned char allow_global_seqno) { + opt->rep.allow_global_seqno = allow_global_seqno; +} + +void rocksdb_ingestexternalfileoptions_set_allow_blocking_flush( + rocksdb_ingestexternalfileoptions_t* opt, + unsigned char allow_blocking_flush) { + opt->rep.allow_blocking_flush = allow_blocking_flush; +} + +void rocksdb_ingestexternalfileoptions_set_ingest_behind( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char ingest_behind) { + opt->rep.ingest_behind = ingest_behind; +} + +void rocksdb_ingestexternalfileoptions_set_fail_if_not_bottommost_level( + rocksdb_ingestexternalfileoptions_t* opt, + unsigned char fail_if_not_bottommost_level) { + opt->rep.fail_if_not_bottommost_level = fail_if_not_bottommost_level; +} + +void rocksdb_ingestexternalfileoptions_destroy( + rocksdb_ingestexternalfileoptions_t* opt) { + delete opt; +} + +void rocksdb_ingest_external_file( + rocksdb_t* db, const char* const* file_list, const size_t list_len, + const rocksdb_ingestexternalfileoptions_t* opt, char** errptr) { + std::vector files(list_len); + for (size_t i = 0; i < list_len; ++i) { + files[i] = std::string(file_list[i]); + } + SaveError(errptr, db->rep->IngestExternalFile(files, opt->rep)); +} + +void rocksdb_ingest_external_file_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* handle, + const char* const* file_list, const size_t list_len, + const rocksdb_ingestexternalfileoptions_t* opt, char** errptr) { + std::vector files(list_len); + for (size_t i = 0; i < list_len; ++i) { + files[i] = std::string(file_list[i]); + } + SaveError(errptr, db->rep->IngestExternalFile(handle->rep, files, opt->rep)); +} + +void rocksdb_try_catch_up_with_primary(rocksdb_t* db, char** errptr) { + SaveError(errptr, db->rep->TryCatchUpWithPrimary()); +} + +rocksdb_slicetransform_t* rocksdb_slicetransform_create( + void* state, void (*destructor)(void*), + char* (*transform)(void*, const char* key, size_t length, + size_t* dst_length), + unsigned char (*in_domain)(void*, const char* key, size_t length), + const char* (*name)(void*)) { + rocksdb_slicetransform_t* result = new rocksdb_slicetransform_t; + result->state_ = state; + result->destructor_ = destructor; + result->transform_ = transform; + result->in_domain_ = in_domain; + result->name_ = name; + return result; +} + +void rocksdb_slicetransform_destroy(rocksdb_slicetransform_t* st) { delete st; } + +struct SliceTransformWrapper : public rocksdb_slicetransform_t { + const SliceTransform* rep_ = nullptr; + SliceTransformWrapper() = default; + ~SliceTransformWrapper() override { delete rep_; } + // Owns rep_ (deleted in the destructor); not copyable or movable. + SliceTransformWrapper(const SliceTransformWrapper&) = delete; + SliceTransformWrapper& operator=(const SliceTransformWrapper&) = delete; + SliceTransformWrapper(SliceTransformWrapper&&) = delete; + SliceTransformWrapper& operator=(SliceTransformWrapper&&) = delete; + const char* Name() const override { return rep_->Name(); } + std::string GetId() const override { return rep_->GetId(); } + Slice Transform(const Slice& src) const override { + return rep_->Transform(src); + } + bool InDomain(const Slice& src) const override { return rep_->InDomain(src); } + static void DoNothing(void*) {} +}; + +rocksdb_slicetransform_t* rocksdb_slicetransform_create_fixed_prefix( + size_t prefixLen) { + SliceTransformWrapper* wrapper = new SliceTransformWrapper; + wrapper->rep_ = ROCKSDB_NAMESPACE::NewFixedPrefixTransform(prefixLen); + wrapper->state_ = nullptr; + wrapper->destructor_ = &SliceTransformWrapper::DoNothing; + return wrapper; +} + +rocksdb_slicetransform_t* rocksdb_slicetransform_create_noop() { + SliceTransformWrapper* wrapper = new SliceTransformWrapper; + wrapper->rep_ = ROCKSDB_NAMESPACE::NewNoopTransform(); + wrapper->state_ = nullptr; + wrapper->destructor_ = &SliceTransformWrapper::DoNothing; + return wrapper; +} + +rocksdb_universal_compaction_options_t* +rocksdb_universal_compaction_options_create() { + rocksdb_universal_compaction_options_t* result = + new rocksdb_universal_compaction_options_t; + result->rep = new ROCKSDB_NAMESPACE::CompactionOptionsUniversal; + return result; +} + +void rocksdb_universal_compaction_options_set_size_ratio( + rocksdb_universal_compaction_options_t* uco, int ratio) { + uco->rep->size_ratio = ratio; +} + +int rocksdb_universal_compaction_options_get_size_ratio( + rocksdb_universal_compaction_options_t* uco) { + return uco->rep->size_ratio; +} + +void rocksdb_universal_compaction_options_set_min_merge_width( + rocksdb_universal_compaction_options_t* uco, int w) { + uco->rep->min_merge_width = w; +} + +int rocksdb_universal_compaction_options_get_min_merge_width( + rocksdb_universal_compaction_options_t* uco) { + return uco->rep->min_merge_width; +} + +void rocksdb_universal_compaction_options_set_max_merge_width( + rocksdb_universal_compaction_options_t* uco, int w) { + uco->rep->max_merge_width = w; +} + +int rocksdb_universal_compaction_options_get_max_merge_width( + rocksdb_universal_compaction_options_t* uco) { + return uco->rep->max_merge_width; +} + +void rocksdb_universal_compaction_options_set_max_size_amplification_percent( + rocksdb_universal_compaction_options_t* uco, int p) { + uco->rep->max_size_amplification_percent = p; +} + +int rocksdb_universal_compaction_options_get_max_size_amplification_percent( + rocksdb_universal_compaction_options_t* uco) { + return uco->rep->max_size_amplification_percent; +} + +void rocksdb_universal_compaction_options_set_compression_size_percent( + rocksdb_universal_compaction_options_t* uco, int p) { + uco->rep->compression_size_percent = p; +} + +int rocksdb_universal_compaction_options_get_compression_size_percent( + rocksdb_universal_compaction_options_t* uco) { + return uco->rep->compression_size_percent; +} + +void rocksdb_universal_compaction_options_set_stop_style( + rocksdb_universal_compaction_options_t* uco, int style) { + uco->rep->stop_style = + static_cast(style); +} + +int rocksdb_universal_compaction_options_get_stop_style( + rocksdb_universal_compaction_options_t* uco) { + return static_cast(uco->rep->stop_style); +} + +void rocksdb_universal_compaction_options_destroy( + rocksdb_universal_compaction_options_t* uco) { + delete uco->rep; + delete uco; +} + +rocksdb_fifo_compaction_options_t* rocksdb_fifo_compaction_options_create() { + rocksdb_fifo_compaction_options_t* result = + new rocksdb_fifo_compaction_options_t; + result->rep = CompactionOptionsFIFO(); + return result; +} + +void rocksdb_fifo_compaction_options_set_allow_compaction( + rocksdb_fifo_compaction_options_t* fifo_opts, + unsigned char allow_compaction) { + fifo_opts->rep.allow_compaction = allow_compaction; +} + +unsigned char rocksdb_fifo_compaction_options_get_allow_compaction( + rocksdb_fifo_compaction_options_t* fifo_opts) { + return fifo_opts->rep.allow_compaction; +} + +void rocksdb_fifo_compaction_options_set_max_table_files_size( + rocksdb_fifo_compaction_options_t* fifo_opts, uint64_t size) { + fifo_opts->rep.max_table_files_size = size; +} + +uint64_t rocksdb_fifo_compaction_options_get_max_table_files_size( + rocksdb_fifo_compaction_options_t* fifo_opts) { + return fifo_opts->rep.max_table_files_size; +} + +void rocksdb_fifo_compaction_options_set_max_data_files_size( + rocksdb_fifo_compaction_options_t* fifo_opts, uint64_t size) { + fifo_opts->rep.max_data_files_size = size; +} + +uint64_t rocksdb_fifo_compaction_options_get_max_data_files_size( + rocksdb_fifo_compaction_options_t* fifo_opts) { + return fifo_opts->rep.max_data_files_size; +} + +void rocksdb_fifo_compaction_options_set_use_kv_ratio_compaction( + rocksdb_fifo_compaction_options_t* fifo_opts, + unsigned char use_kv_ratio_compaction) { + fifo_opts->rep.use_kv_ratio_compaction = use_kv_ratio_compaction; +} + +unsigned char rocksdb_fifo_compaction_options_get_use_kv_ratio_compaction( + rocksdb_fifo_compaction_options_t* fifo_opts) { + return fifo_opts->rep.use_kv_ratio_compaction; +} + +void rocksdb_fifo_compaction_options_destroy( + rocksdb_fifo_compaction_options_t* fifo_opts) { + delete fifo_opts; +} + +void rocksdb_options_set_min_level_to_compress(rocksdb_options_t* opt, + int level) { + if (level >= 0) { + assert(level <= opt->rep.num_levels); + opt->rep.compression_per_level.resize(opt->rep.num_levels); + for (int i = 0; i < level; i++) { + opt->rep.compression_per_level[i] = ROCKSDB_NAMESPACE::kNoCompression; + } + for (int i = level; i < opt->rep.num_levels; i++) { + opt->rep.compression_per_level[i] = opt->rep.compression; + } + } +} + +rocksdb_livefiles_t* rocksdb_livefiles_create() { + return new rocksdb_livefiles_t; +} + +int rocksdb_livefiles_count(const rocksdb_livefiles_t* lf) { + return static_cast(lf->rep.size()); +} + +const char* rocksdb_livefiles_column_family_name(const rocksdb_livefiles_t* lf, + int index) { + return lf->rep[index].column_family_name.c_str(); +} + +const char* rocksdb_livefiles_name(const rocksdb_livefiles_t* lf, int index) { + return lf->rep[index].name.c_str(); +} + +const char* rocksdb_livefiles_directory(const rocksdb_livefiles_t* lf, + int index) { + if (lf->rep[index].directory.empty()) { + // db_path is deprecated but still returned by some code paths + return lf->rep[index].db_path.c_str(); + } else { + return lf->rep[index].directory.c_str(); + } +} + +int rocksdb_livefiles_level(const rocksdb_livefiles_t* lf, int index) { + return lf->rep[index].level; +} + +size_t rocksdb_livefiles_size(const rocksdb_livefiles_t* lf, int index) { + return lf->rep[index].size; +} + +const char* rocksdb_livefiles_smallestkey(const rocksdb_livefiles_t* lf, + int index, size_t* size) { + *size = lf->rep[index].smallestkey.size(); + return lf->rep[index].smallestkey.data(); +} + +const char* rocksdb_livefiles_largestkey(const rocksdb_livefiles_t* lf, + int index, size_t* size) { + *size = lf->rep[index].largestkey.size(); + return lf->rep[index].largestkey.data(); +} + +uint64_t rocksdb_livefiles_smallest_seqno(const rocksdb_livefiles_t* lf, + int index) { + return lf->rep[index].smallest_seqno; +} + +uint64_t rocksdb_livefiles_largest_seqno(const rocksdb_livefiles_t* lf, + int index) { + return lf->rep[index].largest_seqno; +} + +uint64_t rocksdb_livefiles_entries(const rocksdb_livefiles_t* lf, int index) { + return lf->rep[index].num_entries; +} + +uint64_t rocksdb_livefiles_deletions(const rocksdb_livefiles_t* lf, int index) { + return lf->rep[index].num_deletions; +} + +void rocksdb_livefiles_destroy(const rocksdb_livefiles_t* lf) { delete lf; } + +rocksdb_livefiles_storage_info_options_t* +rocksdb_livefiles_storage_info_options_create() { + return new rocksdb_livefiles_storage_info_options_t; +} + +void rocksdb_livefiles_storage_info_options_destroy( + rocksdb_livefiles_storage_info_options_t* options) { + delete options; +} + +rocksdb_livefiles_storage_info_t* rocksdb_get_livefiles_storage_info( + rocksdb_t* db, const rocksdb_livefiles_storage_info_options_t* options, + char** errptr) { + auto* result = new rocksdb_livefiles_storage_info_t; + LiveFilesStorageInfoOptions default_options; + const LiveFilesStorageInfoOptions& storage_options = + options != nullptr ? options->rep : default_options; + if (SaveError(errptr, db->rep->GetLiveFilesStorageInfo(storage_options, + &result->rep))) { + delete result; + return nullptr; + } + return result; +} + +size_t rocksdb_livefiles_storage_info_count( + const rocksdb_livefiles_storage_info_t* info) { + return info->rep.size(); +} + +const char* rocksdb_livefiles_storage_info_relative_filename( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].relative_filename.c_str(); +} + +const char* rocksdb_livefiles_storage_info_directory( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].directory.c_str(); +} + +uint64_t rocksdb_livefiles_storage_info_file_number( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].file_number; +} + +int rocksdb_livefiles_storage_info_file_type( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return static_cast(info->rep[index].file_type); +} + +uint64_t rocksdb_livefiles_storage_info_size( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].size; +} + +int rocksdb_livefiles_storage_info_temperature( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return static_cast(info->rep[index].temperature); +} + +const char* rocksdb_livefiles_storage_info_file_checksum( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].file_checksum.c_str(); +} + +const char* rocksdb_livefiles_storage_info_file_checksum_func_name( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].file_checksum_func_name.c_str(); +} + +const char* rocksdb_livefiles_storage_info_replacement_contents( + const rocksdb_livefiles_storage_info_t* info, size_t index, size_t* size) { + *size = info->rep[index].replacement_contents.size(); + return info->rep[index].replacement_contents.data(); +} + +unsigned char rocksdb_livefiles_storage_info_trim_to_size( + const rocksdb_livefiles_storage_info_t* info, size_t index) { + return info->rep[index].trim_to_size; +} + +void rocksdb_livefiles_storage_info_destroy( + rocksdb_livefiles_storage_info_t* info) { + delete info; +} + +rocksdb_livefile_t* rocksdb_livefile_create() { return new rocksdb_livefile_t; } + +void rocksdb_livefile_set_column_family_name(rocksdb_livefile_t* lf, + const char* column_family_name) { + lf->rep.column_family_name = std::string(column_family_name); +} + +void rocksdb_livefile_set_level(rocksdb_livefile_t* lf, int level) { + lf->rep.level = level; +} + +void rocksdb_livefile_set_name(rocksdb_livefile_t* lf, const char* name) { + lf->rep.name = std::string(name); +} + +void rocksdb_livefile_set_directory(rocksdb_livefile_t* lf, + const char* directory) { + lf->rep.directory = std::string(directory); + lf->rep.db_path = std::string(directory); // deprecated but still needed +} + +void rocksdb_livefile_set_size(rocksdb_livefile_t* lf, size_t size) { + lf->rep.size = size; +} + +void rocksdb_livefile_set_smallest_key(rocksdb_livefile_t* lf, + const char* smallest_key, + size_t smallest_key_len) { + lf->rep.smallestkey = std::string(smallest_key, smallest_key_len); +} + +void rocksdb_livefile_set_largest_key(rocksdb_livefile_t* lf, + const char* largest_key, + size_t largest_key_len) { + lf->rep.largestkey = std::string(largest_key, largest_key_len); +} + +void rocksdb_livefile_set_smallest_seqno(rocksdb_livefile_t* lf, + uint64_t smallest_seqno) { + lf->rep.smallest_seqno = smallest_seqno; +} + +void rocksdb_livefile_set_largest_seqno(rocksdb_livefile_t* lf, + uint64_t largest_seqno) { + lf->rep.largest_seqno = largest_seqno; +} + +void rocksdb_livefile_set_num_entries(rocksdb_livefile_t* lf, + uint64_t num_entries) { + lf->rep.num_entries = num_entries; +} + +void rocksdb_livefile_set_num_deletions(rocksdb_livefile_t* lf, + uint64_t num_deletions) { + lf->rep.num_deletions = num_deletions; +} + +void rocksdb_livefile_destroy(rocksdb_livefile_t* lf) { delete lf; } + +void rocksdb_livefiles_add(rocksdb_livefiles_t* lf, + rocksdb_livefile_t* livefile) { + lf->rep.push_back(std::move(livefile->rep)); + delete livefile; +} + +void rocksdb_get_options_from_string(const rocksdb_options_t* base_options, + const char* opts_str, + rocksdb_options_t* new_options, + char** errptr) { + SaveError(errptr, + GetOptionsFromString(base_options->rep, std::string(opts_str), + &new_options->rep)); +} + +void rocksdb_delete_file_in_range(rocksdb_t* db, const char* start_key, + size_t start_key_len, const char* limit_key, + size_t limit_key_len, char** errptr) { + Slice a; + Slice b; + SaveError( + errptr, + DeleteFilesInRange( + db->rep, db->rep->DefaultColumnFamily(), + (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), + (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr))); +} + +void rocksdb_delete_file_in_range_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, const char* limit_key, + size_t limit_key_len, char** errptr) { + Slice a; + Slice b; + SaveError( + errptr, + DeleteFilesInRange( + db->rep, column_family->rep, + (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), + (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr))); +} + +/* MetaData */ + +rocksdb_column_family_metadata_t* rocksdb_get_column_family_metadata( + rocksdb_t* db) { + rocksdb_column_family_metadata_t* meta = new rocksdb_column_family_metadata_t; + db->rep->GetColumnFamilyMetaData(&meta->rep); + return meta; +} + +rocksdb_column_family_metadata_t* +rocksdb_get_column_family_metadata_with_options( + rocksdb_t* db, const rocksdb_column_family_metadata_options_t* options) { + rocksdb_column_family_metadata_t* meta = new rocksdb_column_family_metadata_t; + GetColumnFamilyMetaDataOptions default_options; + const GetColumnFamilyMetaDataOptions& metadata_options = + options != nullptr ? options->rep : default_options; + db->rep->GetColumnFamilyMetaData(metadata_options, &meta->rep); + return meta; +} + +rocksdb_column_family_metadata_options_t* +rocksdb_column_family_metadata_options_create() { + auto* options = new rocksdb_column_family_metadata_options_t; + SyncColumnFamilyMetadataOptionsRange(options); + return options; +} + +void rocksdb_column_family_metadata_options_destroy( + rocksdb_column_family_metadata_options_t* options) { + delete options; +} + +void rocksdb_column_family_metadata_options_set_start_key( + rocksdb_column_family_metadata_options_t* options, const char* key, + size_t key_len) { + if (key == nullptr) { + options->start_key.clear(); + options->has_start_key = false; + } else { + options->start_key.assign(key, key_len); + options->has_start_key = true; + } + SyncColumnFamilyMetadataOptionsRange(options); +} + +const char* rocksdb_column_family_metadata_options_get_start_key( + const rocksdb_column_family_metadata_options_t* options, size_t* key_len) { + if (!options->has_start_key) { + if (key_len != nullptr) { + *key_len = 0; + } + return nullptr; + } + if (key_len != nullptr) { + *key_len = options->start_key.size(); + } + return options->start_key.data(); +} + +void rocksdb_column_family_metadata_options_set_end_key( + rocksdb_column_family_metadata_options_t* options, const char* key, + size_t key_len) { + if (key == nullptr) { + options->end_key.clear(); + options->has_end_key = false; + } else { + options->end_key.assign(key, key_len); + options->has_end_key = true; + } + SyncColumnFamilyMetadataOptionsRange(options); +} + +const char* rocksdb_column_family_metadata_options_get_end_key( + const rocksdb_column_family_metadata_options_t* options, size_t* key_len) { + if (!options->has_end_key) { + if (key_len != nullptr) { + *key_len = 0; + } + return nullptr; + } + if (key_len != nullptr) { + *key_len = options->end_key.size(); + } + return options->end_key.data(); +} + +rocksdb_column_family_metadata_t* rocksdb_get_column_family_metadata_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family) { + rocksdb_column_family_metadata_t* meta = new rocksdb_column_family_metadata_t; + db->rep->GetColumnFamilyMetaData(column_family->rep, &meta->rep); + return meta; +} + +rocksdb_column_family_metadata_t* +rocksdb_get_column_family_metadata_cf_with_options( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const rocksdb_column_family_metadata_options_t* options) { + rocksdb_column_family_metadata_t* meta = new rocksdb_column_family_metadata_t; + GetColumnFamilyMetaDataOptions default_options; + const GetColumnFamilyMetaDataOptions& metadata_options = + options != nullptr ? options->rep : default_options; + db->rep->GetColumnFamilyMetaData(column_family->rep, metadata_options, + &meta->rep); + return meta; +} + +void rocksdb_column_family_metadata_destroy( + rocksdb_column_family_metadata_t* cf_meta) { + delete cf_meta; +} + +uint64_t rocksdb_column_family_metadata_get_size( + rocksdb_column_family_metadata_t* cf_meta) { + return cf_meta->rep.size; +} + +size_t rocksdb_column_family_metadata_get_file_count( + rocksdb_column_family_metadata_t* cf_meta) { + return cf_meta->rep.file_count; +} + +char* rocksdb_column_family_metadata_get_name( + rocksdb_column_family_metadata_t* cf_meta) { + return strdup(cf_meta->rep.name.c_str()); +} + +size_t rocksdb_column_family_metadata_get_level_count( + rocksdb_column_family_metadata_t* cf_meta) { + return cf_meta->rep.levels.size(); +} + +rocksdb_level_metadata_t* rocksdb_column_family_metadata_get_level_metadata( + rocksdb_column_family_metadata_t* cf_meta, size_t i) { + if (i >= cf_meta->rep.levels.size()) { + return nullptr; + } + rocksdb_level_metadata_t* level_meta = + (rocksdb_level_metadata_t*)malloc(sizeof(rocksdb_level_metadata_t)); + level_meta->rep = &cf_meta->rep.levels[i]; + + return level_meta; +} + +void rocksdb_level_metadata_destroy(rocksdb_level_metadata_t* level_meta) { + // Only free the base pointer as its parent rocksdb_column_family_metadata_t + // has the ownership of its rep. + free(level_meta); +} + +int rocksdb_level_metadata_get_level(rocksdb_level_metadata_t* level_meta) { + return level_meta->rep->level; +} + +uint64_t rocksdb_level_metadata_get_size(rocksdb_level_metadata_t* level_meta) { + return level_meta->rep->size; +} + +size_t rocksdb_level_metadata_get_file_count( + rocksdb_level_metadata_t* level_meta) { + return level_meta->rep->files.size(); +} + +rocksdb_sst_file_metadata_t* rocksdb_level_metadata_get_sst_file_metadata( + rocksdb_level_metadata_t* level_meta, size_t i) { + if (i >= level_meta->rep->files.size()) { + return nullptr; + } + rocksdb_sst_file_metadata_t* file_meta = + (rocksdb_sst_file_metadata_t*)malloc(sizeof(rocksdb_sst_file_metadata_t)); + file_meta->rep = &level_meta->rep->files[i]; + return file_meta; +} + +void rocksdb_sst_file_metadata_destroy(rocksdb_sst_file_metadata_t* file_meta) { + // Only free the base pointer as its parent rocksdb_level_metadata_t + // has the ownership of its rep. + free(file_meta); +} + +char* rocksdb_sst_file_metadata_get_relative_filename( + rocksdb_sst_file_metadata_t* file_meta) { + return strdup(file_meta->rep->relative_filename.c_str()); +} + +char* rocksdb_sst_file_metadata_get_directory( + rocksdb_sst_file_metadata_t* file_meta) { + return strdup(file_meta->rep->directory.c_str()); +} + +uint64_t rocksdb_sst_file_metadata_get_size( + rocksdb_sst_file_metadata_t* file_meta) { + return file_meta->rep->size; +} + +char* rocksdb_sst_file_metadata_get_smallestkey( + rocksdb_sst_file_metadata_t* file_meta, size_t* key_len) { + *key_len = file_meta->rep->smallestkey.size(); + return CopyString(file_meta->rep->smallestkey); +} + +char* rocksdb_sst_file_metadata_get_largestkey( + rocksdb_sst_file_metadata_t* file_meta, size_t* key_len) { + *key_len = file_meta->rep->largestkey.size(); + return CopyString(file_meta->rep->largestkey); +} + +rocksdb_import_column_family_options_t* +rocksdb_import_column_family_options_create() { + return new rocksdb_import_column_family_options_t; +} + +void rocksdb_import_column_family_options_set_move_files( + rocksdb_import_column_family_options_t* opt, unsigned char v) { + opt->rep.move_files = v; +} + +void rocksdb_import_column_family_options_destroy( + rocksdb_import_column_family_options_t* metadata) { + delete metadata; +} + +rocksdb_export_import_files_metadata_t* +rocksdb_export_import_files_metadata_create() { + auto metadata = new rocksdb_export_import_files_metadata_t; + metadata->rep = new ExportImportFilesMetaData; + return metadata; +} + +char* rocksdb_export_import_files_metadata_get_db_comparator_name( + rocksdb_export_import_files_metadata_t* metadata) { + return strdup(metadata->rep->db_comparator_name.c_str()); +} + +void rocksdb_export_import_files_metadata_set_db_comparator_name( + rocksdb_export_import_files_metadata_t* metadata, const char* name) { + metadata->rep->db_comparator_name = std::string(name); +} + +rocksdb_livefiles_t* rocksdb_export_import_files_metadata_get_files( + rocksdb_export_import_files_metadata_t* export_import_metadata) { + auto files = new rocksdb_livefiles_t; + files->rep = std::vector(export_import_metadata->rep->files); + return files; +} + +void rocksdb_export_import_files_metadata_set_files( + rocksdb_export_import_files_metadata_t* metadata, + rocksdb_livefiles_t* files) { + metadata->rep->files = std::move(files->rep); + delete files; +} + +void rocksdb_export_import_files_metadata_destroy( + rocksdb_export_import_files_metadata_t* metadata) { + delete metadata->rep; + delete metadata; +} + +/* Transactions */ + +rocksdb_transactiondb_options_t* rocksdb_transactiondb_options_create() { + return new rocksdb_transactiondb_options_t; +} + +void rocksdb_transactiondb_options_destroy( + rocksdb_transactiondb_options_t* opt) { + delete opt; +} + +rocksdb_transaction_options_t* rocksdb_transaction_options_create() { + return new rocksdb_transaction_options_t; +} + +void rocksdb_transaction_options_destroy(rocksdb_transaction_options_t* opt) { + delete opt; +} + +rocksdb_optimistictransactiondb_lock_buckets_t* +rocksdb_optimistictransactiondb_lock_buckets_create( + size_t bucket_count, unsigned char cache_aligned) { + auto* lock_buckets = new rocksdb_optimistictransactiondb_lock_buckets_t; + lock_buckets->rep = + MakeSharedOccLockBuckets(bucket_count, cache_aligned != 0); + return lock_buckets; +} + +size_t rocksdb_optimistictransactiondb_lock_buckets_approximate_memory_usage( + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets) { + return lock_buckets->rep->ApproximateMemoryUsage(); +} + +void rocksdb_optimistictransactiondb_lock_buckets_destroy( + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets) { + delete lock_buckets; +} + +rocksdb_optimistictransactiondb_options_t* +rocksdb_optimistictransactiondb_options_create() { + return new rocksdb_optimistictransactiondb_options_t; +} + +void rocksdb_optimistictransactiondb_options_destroy( + rocksdb_optimistictransactiondb_options_t* opt) { + delete opt; +} + +void rocksdb_optimistictransactiondb_options_set_shared_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt, + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets) { + opt->rep.shared_lock_buckets = + lock_buckets != nullptr ? lock_buckets->rep : nullptr; +} + +// Hand-written bindings for ABI-frozen options with type mismatches between +// the legacy C API and the underlying C++ field types. These are blocklisted +// from auto-generation to avoid conflicting declarations. +void rocksdb_options_set_writable_file_max_buffer_size(rocksdb_options_t* opt, + uint64_t v) { + opt->rep.writable_file_max_buffer_size = static_cast(v); +} +uint64_t rocksdb_options_get_writable_file_max_buffer_size( + rocksdb_options_t* opt) { + return opt->rep.writable_file_max_buffer_size; +} +void rocksdb_options_set_soft_pending_compaction_bytes_limit( + rocksdb_options_t* opt, size_t v) { + opt->rep.soft_pending_compaction_bytes_limit = v; +} +size_t rocksdb_options_get_soft_pending_compaction_bytes_limit( + rocksdb_options_t* opt) { + return opt->rep.soft_pending_compaction_bytes_limit; +} +void rocksdb_options_set_hard_pending_compaction_bytes_limit( + rocksdb_options_t* opt, size_t v) { + opt->rep.hard_pending_compaction_bytes_limit = v; +} +size_t rocksdb_options_get_hard_pending_compaction_bytes_limit( + rocksdb_options_t* opt) { + return opt->rep.hard_pending_compaction_bytes_limit; +} +void rocksdb_options_set_max_manifest_file_size(rocksdb_options_t* opt, + size_t v) { + opt->rep.max_manifest_file_size = v; +} +size_t rocksdb_options_get_max_manifest_file_size(rocksdb_options_t* opt) { + return opt->rep.max_manifest_file_size; +} + +#include "c_api_gen/c_generated_option_structs_auto.cc.inc" + +rocksdb_optimistictransaction_options_t* +rocksdb_optimistictransaction_options_create() { + return new rocksdb_optimistictransaction_options_t; +} + +void rocksdb_optimistictransaction_options_destroy( + rocksdb_optimistictransaction_options_t* opt) { + delete opt; +} + +char* rocksdb_optimistictransactiondb_property_value( + rocksdb_optimistictransactiondb_t* db, const char* propname) { + std::string tmp; + if (db->rep->GetProperty(Slice(propname), &tmp)) { + // We use strdup() since we expect human readable output. + return strdup(tmp.c_str()); + } else { + return nullptr; + } +} + +int rocksdb_optimistictransactiondb_property_int( + rocksdb_optimistictransactiondb_t* db, const char* propname, + uint64_t* out_val) { + if (db->rep->GetIntProperty(Slice(propname), out_val)) { + return 0; + } else { + return -1; + } +} + +rocksdb_column_family_handle_t* rocksdb_transactiondb_create_column_family( + rocksdb_transactiondb_t* txn_db, + const rocksdb_options_t* column_family_options, + const char* column_family_name, char** errptr) { + rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t; + handle->rep = nullptr; + if (SaveError(errptr, txn_db->rep->CreateColumnFamily( + ColumnFamilyOptions(column_family_options->rep), + std::string(column_family_name), &(handle->rep)))) { + delete handle; + return nullptr; + } + handle->immortal = false; + return handle; +} + +rocksdb_transactiondb_t* rocksdb_transactiondb_open( + const rocksdb_options_t* options, + const rocksdb_transactiondb_options_t* txn_db_options, const char* name, + char** errptr) { + TransactionDB* txn_db; + if (SaveError(errptr, TransactionDB::Open(options->rep, txn_db_options->rep, + std::string(name), &txn_db))) { + return nullptr; + } + rocksdb_transactiondb_t* result = new rocksdb_transactiondb_t; + result->rep = txn_db; + return result; +} + +rocksdb_transactiondb_t* rocksdb_transactiondb_open_column_families( + const rocksdb_options_t* options, + const rocksdb_transactiondb_options_t* txn_db_options, const char* name, + int num_column_families, const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr) { + std::vector column_families; + for (int i = 0; i < num_column_families; i++) { + column_families.emplace_back( + std::string(column_family_names[i]), + ColumnFamilyOptions(column_family_options[i]->rep)); + } + + TransactionDB* txn_db; + std::vector handles; + if (SaveError(errptr, TransactionDB::Open(options->rep, txn_db_options->rep, + std::string(name), column_families, + &handles, &txn_db))) { + return nullptr; + } + + for (size_t i = 0; i < handles.size(); i++) { + rocksdb_column_family_handle_t* c_handle = + new rocksdb_column_family_handle_t; + c_handle->rep = handles[i]; + c_handle->immortal = false; + column_family_handles[i] = c_handle; + } + rocksdb_transactiondb_t* result = new rocksdb_transactiondb_t; + result->rep = txn_db; + return result; +} + +const rocksdb_snapshot_t* rocksdb_transactiondb_create_snapshot( + rocksdb_transactiondb_t* txn_db) { + rocksdb_snapshot_t* result = new rocksdb_snapshot_t; + result->rep = txn_db->rep->GetSnapshot(); + return result; +} + +void rocksdb_transactiondb_release_snapshot( + rocksdb_transactiondb_t* txn_db, const rocksdb_snapshot_t* snapshot) { + txn_db->rep->ReleaseSnapshot(snapshot->rep); + delete snapshot; +} + +char* rocksdb_transactiondb_property_value(rocksdb_transactiondb_t* db, + const char* propname) { + std::string tmp; + if (db->rep->GetProperty(Slice(propname), &tmp)) { + // We use strdup() since we expect human readable output. + return strdup(tmp.c_str()); + } else { + return nullptr; + } +} + +int rocksdb_transactiondb_property_int(rocksdb_transactiondb_t* db, + const char* propname, + uint64_t* out_val) { + if (db->rep->GetIntProperty(Slice(propname), out_val)) { + return 0; + } else { + return -1; + } +} + +rocksdb_t* rocksdb_transactiondb_get_base_db(rocksdb_transactiondb_t* txn_db) { + DB* base_db = txn_db->rep->GetBaseDB(); + + if (base_db != nullptr) { + rocksdb_t* result = new rocksdb_t; + result->rep = base_db; + return result; + } + + return nullptr; +} + +void rocksdb_transactiondb_close_base_db(rocksdb_t* base_db) { delete base_db; } + +rocksdb_transaction_t* rocksdb_transaction_begin( + rocksdb_transactiondb_t* txn_db, + const rocksdb_writeoptions_t* write_options, + const rocksdb_transaction_options_t* txn_options, + rocksdb_transaction_t* old_txn) { + if (old_txn == nullptr) { + rocksdb_transaction_t* result = new rocksdb_transaction_t; + result->rep = txn_db->rep->BeginTransaction(write_options->rep, + txn_options->rep, nullptr); + return result; + } + old_txn->rep = txn_db->rep->BeginTransaction(write_options->rep, + txn_options->rep, old_txn->rep); + return old_txn; +} + +rocksdb_transaction_t** rocksdb_transactiondb_get_prepared_transactions( + rocksdb_transactiondb_t* txn_db, size_t* cnt) { + std::vector txns; + txn_db->rep->GetAllPreparedTransactions(&txns); + *cnt = txns.size(); + if (txns.empty()) { + return nullptr; + } else { + rocksdb_transaction_t** buf = (rocksdb_transaction_t**)malloc( + txns.size() * sizeof(rocksdb_transaction_t*)); + for (size_t i = 0; i < txns.size(); i++) { + buf[i] = new rocksdb_transaction_t; + buf[i]->rep = txns[i]; + } + return buf; + } +} + +void rocksdb_transaction_set_name(rocksdb_transaction_t* txn, const char* name, + size_t name_len, char** errptr) { + std::string str = std::string(name, name_len); + SaveError(errptr, txn->rep->SetName(str)); +} + +char* rocksdb_transaction_get_name(rocksdb_transaction_t* txn, + size_t* name_len) { + auto name = txn->rep->GetName(); + *name_len = name.size(); + return CopyString(name); +} + +void rocksdb_transaction_prepare(rocksdb_transaction_t* txn, char** errptr) { + SaveError(errptr, txn->rep->Prepare()); +} + +rocksdb_writebatch_wi_t* rocksdb_transaction_get_writebatch_wi( + rocksdb_transaction_t* txn) { + rocksdb_writebatch_wi_t* wi = + (rocksdb_writebatch_wi_t*)malloc(sizeof(rocksdb_writebatch_wi_t)); + wi->rep = txn->rep->GetWriteBatch(); + + return wi; +} + +void rocksdb_transaction_rebuild_from_writebatch( + rocksdb_transaction_t* txn, rocksdb_writebatch_t* writebatch, + char** errptr) { + SaveError(errptr, txn->rep->RebuildFromWriteBatch(&writebatch->rep)); +} + +void rocksdb_transaction_rebuild_from_writebatch_wi(rocksdb_transaction_t* txn, + rocksdb_writebatch_wi_t* wi, + char** errptr) { + SaveError(errptr, txn->rep->RebuildFromWriteBatch(wi->rep->GetWriteBatch())); +} + +#include "c_api_gen/c_generated_transaction_subset.cc.inc" + +void rocksdb_transaction_destroy(rocksdb_transaction_t* txn) { + delete txn->rep; + delete txn; +} + +const rocksdb_snapshot_t* rocksdb_transaction_get_snapshot( + rocksdb_transaction_t* txn) { + // This will be freed later on using free, so use malloc here to avoid a + // mismatch + rocksdb_snapshot_t* result = + (rocksdb_snapshot_t*)malloc(sizeof(rocksdb_snapshot_t)); + result->rep = txn->rep->GetSnapshot(); + return result; +} + +// Read a key inside a transaction +char* rocksdb_transaction_get(rocksdb_transaction_t* txn, + const rocksdb_readoptions_t* options, + const char* key, size_t klen, size_t* vlen, + char** errptr) { + char* result = nullptr; + PinnableSlice pinnable_val; + Status s = txn->rep->Get(options->rep, Slice(key, klen), &pinnable_val); + if (s.ok()) { + *vlen = pinnable_val.size(); + result = CopyString(pinnable_val); + } else { + *vlen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +rocksdb_pinnableslice_t* rocksdb_transaction_get_pinned( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + const char* key, size_t klen, char** errptr) { + rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t); + Status s = txn->rep->Get(options->rep, Slice(key, klen), &v->rep); + if (!s.ok()) { + delete (v); + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return v; +} + +char* rocksdb_transaction_get_cf(rocksdb_transaction_t* txn, + const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, size_t* vlen, + char** errptr) { + char* result = nullptr; + PinnableSlice pinnable_val; + Status s = txn->rep->Get(options->rep, column_family->rep, Slice(key, klen), + &pinnable_val); + if (s.ok()) { + *vlen = pinnable_val.size(); + result = CopyString(pinnable_val); + } else { + *vlen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +rocksdb_pinnableslice_t* rocksdb_transaction_get_pinned_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, + char** errptr) { + rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t); + Status s = txn->rep->Get(options->rep, column_family->rep, Slice(key, klen), + &v->rep); + if (!s.ok()) { + delete (v); + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return v; +} + +// Read a key inside a transaction +char* rocksdb_transaction_get_for_update(rocksdb_transaction_t* txn, + const rocksdb_readoptions_t* options, + const char* key, size_t klen, + size_t* vlen, unsigned char exclusive, + char** errptr) { + char* result = nullptr; + PinnableSlice pinnable_val; + Status s = txn->rep->GetForUpdate(options->rep, Slice(key, klen), + &pinnable_val, exclusive); + if (s.ok()) { + *vlen = pinnable_val.size(); + result = CopyString(pinnable_val); + } else { + *vlen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +rocksdb_pinnableslice_t* rocksdb_transaction_get_pinned_for_update( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + const char* key, size_t klen, unsigned char exclusive, char** errptr) { + rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t); + Status s = txn->rep->GetForUpdate(options->rep, Slice(key, klen), + v->rep.GetSelf(), exclusive); + v->rep.PinSelf(); + if (!s.ok()) { + delete (v); + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return v; +} + +char* rocksdb_transaction_get_for_update_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, + size_t* vlen, unsigned char exclusive, char** errptr) { + char* result = nullptr; + PinnableSlice pinnable_val; + Status s = txn->rep->GetForUpdate(options->rep, column_family->rep, + Slice(key, klen), &pinnable_val, exclusive); + if (s.ok()) { + *vlen = pinnable_val.size(); + result = CopyString(pinnable_val); + } else { + *vlen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +rocksdb_pinnableslice_t* rocksdb_transaction_get_pinned_for_update_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, + unsigned char exclusive, char** errptr) { + rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t); + Status s = txn->rep->GetForUpdate(options->rep, column_family->rep, + Slice(key, klen), &v->rep, exclusive); + if (!s.ok()) { + delete (v); + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return v; +} + +void rocksdb_transaction_multi_get(rocksdb_transaction_t* txn, + const rocksdb_readoptions_t* options, + size_t num_keys, + const char* const* keys_list, + const size_t* keys_list_sizes, + char** values_list, + size_t* values_list_sizes, char** errs) { + // Use unique_ptr for efficiency + std::unique_ptr keys_arr(new Slice[num_keys]); + for (size_t i = 0; i < num_keys; i++) { + keys_arr[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + // Note: Transaction only has vector-based MultiGet API + std::vector keys(keys_arr.get(), keys_arr.get() + num_keys); + std::vector values(num_keys); + std::vector statuses = + txn->rep->MultiGet(options->rep, keys, &values); + for (size_t i = 0; i < num_keys; i++) { + if (statuses[i].ok()) { + values_list[i] = CopyString(values[i]); + values_list_sizes[i] = values[i].size(); + errs[i] = nullptr; + } else { + values_list[i] = nullptr; + values_list_sizes[i] = 0; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } +} + +void rocksdb_transaction_multi_get_for_update( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs) { + // Use unique_ptr for efficiency + std::unique_ptr keys_arr(new Slice[num_keys]); + for (size_t i = 0; i < num_keys; i++) { + keys_arr[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + // Note: GetForUpdate only has vector-based API, no array-based PinnableSlice + // variant + std::vector keys(keys_arr.get(), keys_arr.get() + num_keys); + std::vector values(num_keys); + std::vector statuses = + txn->rep->MultiGetForUpdate(options->rep, keys, &values); + for (size_t i = 0; i < num_keys; i++) { + if (statuses[i].ok()) { + values_list[i] = CopyString(values[i]); + values_list_sizes[i] = values[i].size(); + errs[i] = nullptr; + } else { + values_list[i] = nullptr; + values_list_sizes[i] = 0; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } +} + +void rocksdb_transaction_multi_get_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + const rocksdb_column_family_handle_t* const* column_families, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs) { + // Use unique_ptr for efficiency + std::unique_ptr keys_arr(new Slice[num_keys]); + std::vector cfs(num_keys); + for (size_t i = 0; i < num_keys; i++) { + keys_arr[i] = Slice(keys_list[i], keys_list_sizes[i]); + cfs[i] = column_families[i]->rep; + } + // Note: Transaction only has vector-based MultiGet API + std::vector keys(keys_arr.get(), keys_arr.get() + num_keys); + std::vector values(num_keys); + std::vector statuses = + txn->rep->MultiGet(options->rep, cfs, keys, &values); + for (size_t i = 0; i < num_keys; i++) { + if (statuses[i].ok()) { + values_list[i] = CopyString(values[i]); + values_list_sizes[i] = values[i].size(); + errs[i] = nullptr; + } else { + values_list[i] = nullptr; + values_list_sizes[i] = 0; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } +} + +void rocksdb_transaction_multi_get_for_update_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + const rocksdb_column_family_handle_t* const* column_families, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs) { + // Use unique_ptr for efficiency + std::unique_ptr keys_arr(new Slice[num_keys]); + std::vector cfs(num_keys); + for (size_t i = 0; i < num_keys; i++) { + keys_arr[i] = Slice(keys_list[i], keys_list_sizes[i]); + cfs[i] = column_families[i]->rep; + } + // Note: GetForUpdate only has vector-based API, no array-based PinnableSlice + // variant + std::vector keys(keys_arr.get(), keys_arr.get() + num_keys); + std::vector values(num_keys); + std::vector statuses = + txn->rep->MultiGetForUpdate(options->rep, cfs, keys, &values); + for (size_t i = 0; i < num_keys; i++) { + if (statuses[i].ok()) { + values_list[i] = CopyString(values[i]); + values_list_sizes[i] = values[i].size(); + errs[i] = nullptr; + } else { + values_list[i] = nullptr; + values_list_sizes[i] = 0; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } +} + +// Read a key outside a transaction +char* rocksdb_transactiondb_get(rocksdb_transactiondb_t* txn_db, + const rocksdb_readoptions_t* options, + const char* key, size_t klen, size_t* vlen, + char** errptr) { + char* result = nullptr; + PinnableSlice pinnable_val; + Status s = txn_db->rep->Get(options->rep, txn_db->rep->DefaultColumnFamily(), + Slice(key, klen), &pinnable_val); + if (s.ok()) { + *vlen = pinnable_val.size(); + result = CopyString(pinnable_val); + } else { + *vlen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +rocksdb_pinnableslice_t* rocksdb_transactiondb_get_pinned( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + const char* key, size_t klen, char** errptr) { + rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t); + Status s = txn_db->rep->Get(options->rep, txn_db->rep->DefaultColumnFamily(), + Slice(key, klen), &v->rep); + if (!s.ok()) { + delete (v); + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return v; +} + +char* rocksdb_transactiondb_get_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, size_t* vallen, char** errptr) { + char* result = nullptr; + PinnableSlice pinnable_val; + Status s = txn_db->rep->Get(options->rep, column_family->rep, + Slice(key, keylen), &pinnable_val); + if (s.ok()) { + *vallen = pinnable_val.size(); + result = CopyString(pinnable_val); + } else { + *vallen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + } + return result; +} + +rocksdb_pinnableslice_t* rocksdb_transactiondb_get_pinned_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr) { + rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t); + Status s = txn_db->rep->Get(options->rep, column_family->rep, + Slice(key, keylen), &v->rep); + if (!s.ok()) { + delete (v); + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return v; +} + +void rocksdb_transactiondb_multi_get(rocksdb_transactiondb_t* txn_db, + const rocksdb_readoptions_t* options, + size_t num_keys, + const char* const* keys_list, + const size_t* keys_list_sizes, + char** values_list, + size_t* values_list_sizes, char** errs) { + // Use unique_ptr for efficiency + std::unique_ptr keys(new Slice[num_keys]); + for (size_t i = 0; i < num_keys; i++) { + keys[i] = Slice(keys_list[i], keys_list_sizes[i]); + } + // Use PinnableSlice to avoid unnecessary allocations + auto cfh = txn_db->rep->DefaultColumnFamily(); + std::vector values(num_keys); + std::vector statuses(num_keys); + txn_db->rep->MultiGet(options->rep, cfh, num_keys, keys.get(), values.data(), + statuses.data()); + for (size_t i = 0; i < num_keys; i++) { + if (statuses[i].ok()) { + values_list[i] = CopyString(values[i]); + values_list_sizes[i] = values[i].size(); + errs[i] = nullptr; + } else { + values_list[i] = nullptr; + values_list_sizes[i] = 0; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } +} + +void rocksdb_transactiondb_multi_get_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + const rocksdb_column_family_handle_t* const* column_families, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs) { + // Use unique_ptr for efficiency + std::unique_ptr keys(new Slice[num_keys]); + std::unique_ptr cfs(new ColumnFamilyHandle*[num_keys]); + for (size_t i = 0; i < num_keys; i++) { + keys[i] = Slice(keys_list[i], keys_list_sizes[i]); + cfs[i] = column_families[i]->rep; + } + // Use PinnableSlice to avoid unnecessary allocations + std::vector values(num_keys); + std::vector statuses(num_keys); + txn_db->rep->MultiGet(options->rep, num_keys, cfs.get(), keys.get(), + values.data(), statuses.data()); + for (size_t i = 0; i < num_keys; i++) { + if (statuses[i].ok()) { + values_list[i] = CopyString(values[i]); + values_list_sizes[i] = values[i].size(); + errs[i] = nullptr; + } else { + values_list[i] = nullptr; + values_list_sizes[i] = 0; + if (!statuses[i].IsNotFound()) { + errs[i] = strdup(statuses[i].ToString().c_str()); + } else { + errs[i] = nullptr; + } + } + } +} + +void rocksdb_transaction_set_commit_timestamp(rocksdb_transaction_t* txn, + uint64_t commit_timestamp) { + txn->rep->SetCommitTimestamp(commit_timestamp); +} + +void rocksdb_transaction_set_read_timestamp_for_validation( + rocksdb_transaction_t* txn, uint64_t read_timestamp) { + txn->rep->SetReadTimestampForValidation(read_timestamp); +} + +#include "c_api_gen/c_generated_transactiondb_subset.cc.inc" + +// Create an iterator inside a transaction +rocksdb_iterator_t* rocksdb_transaction_create_iterator( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; + result->rep = txn->rep->GetIterator(options->rep); + return result; +} + +// Create an iterator inside a transaction with column family +rocksdb_iterator_t* rocksdb_transaction_create_iterator_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; + result->rep = txn->rep->GetIterator(options->rep, column_family->rep); + return result; +} + +// Create an iterator outside a transaction +rocksdb_iterator_t* rocksdb_transactiondb_create_iterator( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; + result->rep = txn_db->rep->NewIterator(options->rep); + return result; +} + +rocksdb_iterator_t* rocksdb_transactiondb_create_iterator_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family) { + rocksdb_iterator_t* result = new rocksdb_iterator_t; + result->rep = txn_db->rep->NewIterator(options->rep, column_family->rep); + return result; +} + +void rocksdb_transactiondb_close(rocksdb_transactiondb_t* txn_db) { + delete txn_db->rep; + delete txn_db; +} + +void rocksdb_transactiondb_flush_cfs( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t** column_families, int num_column_families, + char** errptr) { + std::vector column_family_handles; + for (int i = 0; i < num_column_families; i++) { + column_family_handles.push_back(column_families[i]->rep); + } + + SaveError(errptr, txn_db->rep->Flush(options->rep, column_family_handles)); +} + +void rocksdb_transactiondb_flush_wal_with_options( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushwaloptions_t* options, + char** errptr) { + FlushWALOptions default_options; + SaveError(errptr, txn_db->rep->FlushWAL( + GetFlushWALOptions(options, &default_options))); +} + +rocksdb_checkpoint_t* rocksdb_transactiondb_checkpoint_object_create( + rocksdb_transactiondb_t* txn_db, char** errptr) { + Checkpoint* checkpoint; + if (SaveError(errptr, Checkpoint::Create(txn_db->rep, &checkpoint))) { + return nullptr; + } + rocksdb_checkpoint_t* result = new rocksdb_checkpoint_t; + result->rep = checkpoint; + return result; +} + +rocksdb_optimistictransactiondb_t* rocksdb_optimistictransactiondb_open( + const rocksdb_options_t* options, const char* name, char** errptr) { + OptimisticTransactionDB* otxn_db; + if (SaveError(errptr, OptimisticTransactionDB::Open( + options->rep, std::string(name), &otxn_db))) { + return nullptr; + } + return WrapOptimisticTransactionDB(otxn_db); +} + +rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open_with_otxn_db_options( + const rocksdb_options_t* options, + const rocksdb_optimistictransactiondb_options_t* otxn_db_options, + const char* name, char** errptr) { + std::vector column_families; + column_families.emplace_back(ROCKSDB_NAMESPACE::kDefaultColumnFamilyName, + ColumnFamilyOptions(options->rep)); + + std::vector handles; + OptimisticTransactionDBOptions default_options; + const OptimisticTransactionDBOptions& effective_options = + GetOptimisticTransactionDBOptions(otxn_db_options, &default_options); + OptimisticTransactionDB* otxn_db; + if (SaveError(errptr, + OptimisticTransactionDB::Open( + DBOptions(options->rep), effective_options, + std::string(name), column_families, &handles, &otxn_db))) { + return nullptr; + } + for (auto* handle : handles) { + delete handle; + } + return WrapOptimisticTransactionDB(otxn_db); +} + +rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open_column_families( + const rocksdb_options_t* db_options, const char* name, + int num_column_families, const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr) { + std::vector column_families; + for (int i = 0; i < num_column_families; i++) { + column_families.emplace_back( + std::string(column_family_names[i]), + ColumnFamilyOptions(column_family_options[i]->rep)); + } + + OptimisticTransactionDB* otxn_db; + std::vector handles; + if (SaveError(errptr, OptimisticTransactionDB::Open( + DBOptions(db_options->rep), std::string(name), + column_families, &handles, &otxn_db))) { + return nullptr; + } + + for (size_t i = 0; i < handles.size(); i++) { + rocksdb_column_family_handle_t* c_handle = + new rocksdb_column_family_handle_t; + c_handle->rep = handles[i]; + c_handle->immortal = false; + column_family_handles[i] = c_handle; + } + return WrapOptimisticTransactionDB(otxn_db); +} + +rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open_column_families_with_otxn_db_options( + const rocksdb_options_t* db_options, + const rocksdb_optimistictransactiondb_options_t* otxn_db_options, + const char* name, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr) { + std::vector column_families; + column_families.reserve(num_column_families); + for (int i = 0; i < num_column_families; i++) { + column_families.emplace_back( + std::string(column_family_names[i]), + ColumnFamilyOptions(column_family_options[i]->rep)); + } + + OptimisticTransactionDBOptions default_options; + const OptimisticTransactionDBOptions& effective_options = + GetOptimisticTransactionDBOptions(otxn_db_options, &default_options); + + OptimisticTransactionDB* otxn_db; + std::vector handles; + if (SaveError(errptr, + OptimisticTransactionDB::Open( + DBOptions(db_options->rep), effective_options, + std::string(name), column_families, &handles, &otxn_db))) { + return nullptr; + } + + for (size_t i = 0; i < handles.size(); i++) { + auto* c_handle = new rocksdb_column_family_handle_t; + c_handle->rep = handles[i]; + c_handle->immortal = false; + column_family_handles[i] = c_handle; + } + return WrapOptimisticTransactionDB(otxn_db); +} + +rocksdb_t* rocksdb_optimistictransactiondb_get_base_db( + rocksdb_optimistictransactiondb_t* otxn_db) { + DB* base_db = otxn_db->rep->GetBaseDB(); + + if (base_db != nullptr) { + rocksdb_t* result = new rocksdb_t; + result->rep = base_db; + return result; + } + + return nullptr; +} + +void rocksdb_optimistictransactiondb_close_base_db(rocksdb_t* base_db) { + delete base_db; +} + +rocksdb_transaction_t* rocksdb_optimistictransaction_begin( + rocksdb_optimistictransactiondb_t* otxn_db, + const rocksdb_writeoptions_t* write_options, + const rocksdb_optimistictransaction_options_t* otxn_options, + rocksdb_transaction_t* old_txn) { + if (old_txn == nullptr) { + rocksdb_transaction_t* result = new rocksdb_transaction_t; + result->rep = otxn_db->rep->BeginTransaction(write_options->rep, + otxn_options->rep, nullptr); + return result; + } + old_txn->rep = otxn_db->rep->BeginTransaction( + write_options->rep, otxn_options->rep, old_txn->rep); + return old_txn; +} + +// Write batch into OptimisticTransactionDB +void rocksdb_optimistictransactiondb_write( + rocksdb_optimistictransactiondb_t* otxn_db, + const rocksdb_writeoptions_t* options, rocksdb_writebatch_t* batch, + char** errptr) { + SaveError(errptr, otxn_db->rep->Write(options->rep, &batch->rep)); +} + +void rocksdb_optimistictransactiondb_close( + rocksdb_optimistictransactiondb_t* otxn_db) { + delete otxn_db->rep; + delete otxn_db; +} + +rocksdb_checkpoint_t* rocksdb_optimistictransactiondb_checkpoint_object_create( + rocksdb_optimistictransactiondb_t* otxn_db, char** errptr) { + Checkpoint* checkpoint; + if (SaveError(errptr, Checkpoint::Create(otxn_db->rep, &checkpoint))) { + return nullptr; + } + rocksdb_checkpoint_t* result = new rocksdb_checkpoint_t; + result->rep = checkpoint; + return result; +} + +void rocksdb_free(void* ptr) { free(ptr); } + +rocksdb_pinnableslice_t* rocksdb_get_pinned( + rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key, + size_t keylen, char** errptr) { + rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t); + Status s = db->rep->Get(options->rep, db->rep->DefaultColumnFamily(), + Slice(key, keylen), &v->rep); + if (!s.ok()) { + delete (v); + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return v; +} + +rocksdb_pinnableslice_t* rocksdb_get_pinned_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr) { + rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t); + Status s = db->rep->Get(options->rep, column_family->rep, Slice(key, keylen), + &v->rep); + if (!s.ok()) { + delete v; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return v; +} + +void rocksdb_pinnableslice_destroy(rocksdb_pinnableslice_t* v) { delete v; } + +const char* rocksdb_pinnableslice_value(const rocksdb_pinnableslice_t* v, + size_t* vlen) { + if (!v) { + *vlen = 0; + return nullptr; + } + + *vlen = v->rep.size(); + return v->rep.data(); +} + +// container to keep databases and caches in order to use +// ROCKSDB_NAMESPACE::MemoryUtil +struct rocksdb_memory_consumers_t { + std::vector dbs; + std::unordered_set caches; +}; + +// initializes new container of memory consumers +rocksdb_memory_consumers_t* rocksdb_memory_consumers_create() { + return new rocksdb_memory_consumers_t; +} + +// adds datatabase to the container of memory consumers +void rocksdb_memory_consumers_add_db(rocksdb_memory_consumers_t* consumers, + rocksdb_t* db) { + consumers->dbs.push_back(db); +} + +// adds cache to the container of memory consumers +void rocksdb_memory_consumers_add_cache(rocksdb_memory_consumers_t* consumers, + rocksdb_cache_t* cache) { + consumers->caches.insert(cache); +} + +// deletes container with memory consumers +void rocksdb_memory_consumers_destroy(rocksdb_memory_consumers_t* consumers) { + delete consumers; +} + +// contains memory usage statistics provided by ROCKSDB_NAMESPACE::MemoryUtil +struct rocksdb_memory_usage_t { + uint64_t mem_table_total; + uint64_t mem_table_unflushed; + uint64_t mem_table_readers_total; + uint64_t cache_total; +}; + +// estimates amount of memory occupied by consumers (dbs and caches) +rocksdb_memory_usage_t* rocksdb_approximate_memory_usage_create( + rocksdb_memory_consumers_t* consumers, char** errptr) { + vector dbs; + for (auto db : consumers->dbs) { + dbs.push_back(db->rep); + } + + std::unordered_set cache_set; + for (auto cache : consumers->caches) { + cache_set.insert(const_cast(cache->rep.get())); + } + + std::map usage_by_type; + + auto status = MemoryUtil::GetApproximateMemoryUsageByType(dbs, cache_set, + &usage_by_type); + if (SaveError(errptr, status)) { + return nullptr; + } + + auto result = new rocksdb_memory_usage_t; + result->mem_table_total = usage_by_type[MemoryUtil::kMemTableTotal]; + result->mem_table_unflushed = usage_by_type[MemoryUtil::kMemTableUnFlushed]; + result->mem_table_readers_total = + usage_by_type[MemoryUtil::kTableReadersTotal]; + result->cache_total = usage_by_type[MemoryUtil::kCacheTotal]; + return result; +} + +uint64_t rocksdb_approximate_memory_usage_get_mem_table_total( + rocksdb_memory_usage_t* memory_usage) { + return memory_usage->mem_table_total; +} + +uint64_t rocksdb_approximate_memory_usage_get_mem_table_unflushed( + rocksdb_memory_usage_t* memory_usage) { + return memory_usage->mem_table_unflushed; +} + +uint64_t rocksdb_approximate_memory_usage_get_mem_table_readers_total( + rocksdb_memory_usage_t* memory_usage) { + return memory_usage->mem_table_readers_total; +} + +uint64_t rocksdb_approximate_memory_usage_get_cache_total( + rocksdb_memory_usage_t* memory_usage) { + return memory_usage->cache_total; +} + +// deletes container with memory usage estimates +void rocksdb_approximate_memory_usage_destroy(rocksdb_memory_usage_t* usage) { + delete usage; +} + +void rocksdb_cancel_all_background_work(rocksdb_t* db, unsigned char wait) { + CancelAllBackgroundWork(db->rep, wait); +} + +void rocksdb_disable_manual_compaction(rocksdb_t* db) { + db->rep->DisableManualCompaction(); +} + +void rocksdb_enable_manual_compaction(rocksdb_t* db) { + db->rep->EnableManualCompaction(); +} + +void rocksdb_abort_all_compactions(rocksdb_t* db) { + db->rep->AbortAllCompactions(); +} + +void rocksdb_resume_all_compactions(rocksdb_t* db) { + db->rep->ResumeAllCompactions(); +} + +rocksdb_statistics_histogram_data_t* +rocksdb_statistics_histogram_data_create() { + return new rocksdb_statistics_histogram_data_t{}; +} + +void rocksdb_statistics_histogram_data_destroy( + rocksdb_statistics_histogram_data_t* data) { + delete data; +} + +double rocksdb_statistics_histogram_data_get_median( + rocksdb_statistics_histogram_data_t* data) { + return data->rep.median; +} + +double rocksdb_statistics_histogram_data_get_p95( + rocksdb_statistics_histogram_data_t* data) { + return data->rep.percentile95; +} + +double rocksdb_statistics_histogram_data_get_p99( + rocksdb_statistics_histogram_data_t* data) { + return data->rep.percentile99; +} + +double rocksdb_statistics_histogram_data_get_average( + rocksdb_statistics_histogram_data_t* data) { + return data->rep.average; +} + +double rocksdb_statistics_histogram_data_get_std_dev( + rocksdb_statistics_histogram_data_t* data) { + return data->rep.standard_deviation; +} + +double rocksdb_statistics_histogram_data_get_max( + rocksdb_statistics_histogram_data_t* data) { + return data->rep.max; +} + +uint64_t rocksdb_statistics_histogram_data_get_count( + rocksdb_statistics_histogram_data_t* data) { + return data->rep.count; +} + +uint64_t rocksdb_statistics_histogram_data_get_sum( + rocksdb_statistics_histogram_data_t* data) { + return data->rep.sum; +} + +double rocksdb_statistics_histogram_data_get_min( + rocksdb_statistics_histogram_data_t* data) { + return data->rep.min; +} + +void rocksdb_wait_for_compact(rocksdb_t* db, + rocksdb_wait_for_compact_options_t* options, + char** errptr) { + SaveError(errptr, db->rep->WaitForCompact(options->rep)); +} + +rocksdb_wait_for_compact_options_t* rocksdb_wait_for_compact_options_create() { + return new rocksdb_wait_for_compact_options_t; +} + +void rocksdb_wait_for_compact_options_destroy( + rocksdb_wait_for_compact_options_t* opt) { + delete opt; +} + +void rocksdb_wait_for_compact_options_set_abort_on_pause( + rocksdb_wait_for_compact_options_t* opt, unsigned char v) { + opt->rep.abort_on_pause = v; +} + +unsigned char rocksdb_wait_for_compact_options_get_abort_on_pause( + rocksdb_wait_for_compact_options_t* opt) { + return opt->rep.abort_on_pause; +} + +void rocksdb_wait_for_compact_options_set_flush( + rocksdb_wait_for_compact_options_t* opt, unsigned char v) { + opt->rep.flush = v; +} + +unsigned char rocksdb_wait_for_compact_options_get_flush( + rocksdb_wait_for_compact_options_t* opt) { + return opt->rep.flush; +} + +void rocksdb_wait_for_compact_options_set_close_db( + rocksdb_wait_for_compact_options_t* opt, unsigned char v) { + opt->rep.close_db = v; +} + +unsigned char rocksdb_wait_for_compact_options_get_close_db( + rocksdb_wait_for_compact_options_t* opt) { + return opt->rep.close_db; +} + +void rocksdb_wait_for_compact_options_set_timeout( + rocksdb_wait_for_compact_options_t* opt, uint64_t microseconds) { + opt->rep.timeout = std::chrono::microseconds(microseconds); +} + +uint64_t rocksdb_wait_for_compact_options_get_timeout( + rocksdb_wait_for_compact_options_t* opt) { + return opt->rep.timeout.count(); +} + +/* High-performance zero-copy Get implementations */ + +struct rocksdb_pinnable_handle_t { + PinnableSlice rep; +}; + +rocksdb_pinnable_handle_t* rocksdb_get_pinned_v2( + rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key, + size_t keylen, char** errptr) { + rocksdb_pinnable_handle_t* handle = new rocksdb_pinnable_handle_t; + Status s = db->rep->Get(options->rep, db->rep->DefaultColumnFamily(), + Slice(key, keylen), &handle->rep); + if (!s.ok()) { + delete handle; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return handle; +} + +rocksdb_pinnable_handle_t* rocksdb_get_pinned_cf_v2( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr) { + rocksdb_pinnable_handle_t* handle = new rocksdb_pinnable_handle_t; + Status s = db->rep->Get(options->rep, column_family->rep, Slice(key, keylen), + &handle->rep); + if (!s.ok()) { + delete handle; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return nullptr; + } + return handle; +} + +const char* rocksdb_pinnable_handle_get_value( + const rocksdb_pinnable_handle_t* handle, size_t* vallen) { + if (!handle) { + *vallen = 0; + return nullptr; + } + *vallen = handle->rep.size(); + return handle->rep.data(); +} + +void rocksdb_pinnable_handle_destroy(rocksdb_pinnable_handle_t* handle) { + delete handle; +} + +unsigned char rocksdb_get_into_buffer(rocksdb_t* db, + const rocksdb_readoptions_t* options, + const char* key, size_t keylen, + char* buffer, size_t buffer_size, + size_t* vallen, unsigned char* found, + char** errptr) { + PinnableSlice pinnable_val; + Status s = db->rep->Get(options->rep, db->rep->DefaultColumnFamily(), + Slice(key, keylen), &pinnable_val); + if (s.ok()) { + *found = 1; + *vallen = pinnable_val.size(); + if (buffer_size >= pinnable_val.size()) { + memcpy(buffer, pinnable_val.data(), pinnable_val.size()); + return 1; // Success - data copied + } + return 0; // Buffer too small + } else { + *found = 0; + *vallen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return 0; + } +} + +unsigned char rocksdb_get_into_buffer_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char* buffer, size_t buffer_size, size_t* vallen, + unsigned char* found, char** errptr) { + PinnableSlice pinnable_val; + Status s = db->rep->Get(options->rep, column_family->rep, Slice(key, keylen), + &pinnable_val); + if (s.ok()) { + *found = 1; + *vallen = pinnable_val.size(); + if (buffer_size >= pinnable_val.size()) { + memcpy(buffer, pinnable_val.data(), pinnable_val.size()); + return 1; // Success - data copied + } + return 0; // Buffer too small + } else { + *found = 0; + *vallen = 0; + if (!s.IsNotFound()) { + SaveError(errptr, s); + } + return 0; + } +} + +} // end extern "C" diff --git a/tools/c_api_gen/c_base.h b/tools/c_api_gen/c_base.h new file mode 100644 index 0000000000..19e5d42c07 --- /dev/null +++ b/tools/c_api_gen/c_base.h @@ -0,0 +1,3830 @@ +// 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). + +// SOURCE TEMPLATE -- DO NOT INCLUDE DIRECTLY. +// Edit this file to modify the C API, then run: +// python3 tools/c_api_gen/regen_all.py +// The public header for consumers is include/rocksdb/c.h +// +/* + Does not support: + . getters for the option types + . custom comparators that implement key shortening + . capturing post-write-snapshot + . custom iter, db, env, cache implementations using just the C bindings + + Some conventions: + + (1) We expose just opaque struct pointers and functions to clients. + This allows us to change internal representations without having to + recompile clients. + + (2) For simplicity, there is no equivalent to the Slice type. Instead, + the caller has to pass the pointer and length as separate + arguments. + + (3) Errors are represented by a null-terminated c string. NULL + means no error. All operations that can raise an error are passed + a "char** errptr" as the last argument. One of the following must + be true on entry: + *errptr == NULL + *errptr points to a malloc()ed null-terminated error message + On success, a leveldb routine leaves *errptr unchanged. + On failure, leveldb frees the old value of *errptr and + set *errptr to a malloc()ed error message. + + (4) Bools have the type unsigned char (0 == false; rest == true) + + (5) All of the pointer arguments must be non-NULL. +*/ + +#pragma once + +#ifdef _WIN32 +#ifdef ROCKSDB_DLL +#ifdef ROCKSDB_LIBRARY_EXPORTS +#define ROCKSDB_LIBRARY_API __declspec(dllexport) +#else +#define ROCKSDB_LIBRARY_API __declspec(dllimport) +#endif +#else +#define ROCKSDB_LIBRARY_API +#endif +#else +#define ROCKSDB_LIBRARY_API +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +/* Exported types */ + +typedef struct rocksdb_t rocksdb_t; +typedef struct rocksdb_status_ptr_t rocksdb_status_ptr_t; +typedef struct rocksdb_backup_engine_t rocksdb_backup_engine_t; +typedef struct rocksdb_backup_engine_info_t rocksdb_backup_engine_info_t; +typedef struct rocksdb_backup_engine_options_t rocksdb_backup_engine_options_t; +typedef struct rocksdb_create_backup_options_t rocksdb_create_backup_options_t; +typedef struct rocksdb_restore_options_t rocksdb_restore_options_t; +typedef struct rocksdb_memory_allocator_t rocksdb_memory_allocator_t; +typedef struct rocksdb_lru_cache_options_t rocksdb_lru_cache_options_t; +typedef struct rocksdb_hyper_clock_cache_options_t + rocksdb_hyper_clock_cache_options_t; +typedef struct rocksdb_cache_t rocksdb_cache_t; +typedef struct rocksdb_write_buffer_manager_t rocksdb_write_buffer_manager_t; +typedef struct rocksdb_sst_file_manager_t rocksdb_sst_file_manager_t; +typedef struct rocksdb_compactionfilter_t rocksdb_compactionfilter_t; +typedef struct rocksdb_compactionfiltercontext_t + rocksdb_compactionfiltercontext_t; +typedef struct rocksdb_compactionfilterfactory_t + rocksdb_compactionfilterfactory_t; +typedef struct rocksdb_walfilter_t rocksdb_walfilter_t; +typedef struct rocksdb_file_checksum_gen_factory_t + rocksdb_file_checksum_gen_factory_t; +typedef struct rocksdb_sst_partitioner_factory_t + rocksdb_sst_partitioner_factory_t; +typedef struct rocksdb_table_properties_collector_factory_t + rocksdb_table_properties_collector_factory_t; +typedef struct rocksdb_comparator_t rocksdb_comparator_t; +typedef struct rocksdb_dbpath_t rocksdb_dbpath_t; +typedef struct rocksdb_env_t rocksdb_env_t; +typedef struct rocksdb_fifo_compaction_options_t + rocksdb_fifo_compaction_options_t; +typedef struct rocksdb_filelock_t rocksdb_filelock_t; +typedef struct rocksdb_filterpolicy_t rocksdb_filterpolicy_t; +typedef struct rocksdb_flushoptions_t rocksdb_flushoptions_t; +typedef struct rocksdb_flushwaloptions_t rocksdb_flushwaloptions_t; +typedef struct rocksdb_iterator_t rocksdb_iterator_t; +typedef struct rocksdb_logger_t rocksdb_logger_t; +typedef struct rocksdb_mergeoperator_t rocksdb_mergeoperator_t; +typedef struct rocksdb_options_t rocksdb_options_t; +typedef struct rocksdb_compaction_options_t rocksdb_compaction_options_t; +typedef struct rocksdb_compactoptions_t rocksdb_compactoptions_t; +typedef struct rocksdb_block_based_table_options_t + rocksdb_block_based_table_options_t; +typedef struct rocksdb_block_cache_trace_options_t + rocksdb_block_cache_trace_options_t; +typedef struct rocksdb_block_cache_trace_writer_options_t + rocksdb_block_cache_trace_writer_options_t; +typedef struct rocksdb_cuckoo_table_options_t rocksdb_cuckoo_table_options_t; +typedef struct rocksdb_randomfile_t rocksdb_randomfile_t; +typedef struct rocksdb_readoptions_t rocksdb_readoptions_t; +typedef struct rocksdb_seqfile_t rocksdb_seqfile_t; +typedef struct rocksdb_slicetransform_t rocksdb_slicetransform_t; +typedef struct rocksdb_snapshot_t rocksdb_snapshot_t; +typedef struct rocksdb_writablefile_t rocksdb_writablefile_t; +typedef struct rocksdb_writebatch_t rocksdb_writebatch_t; +typedef struct rocksdb_writebatch_wi_t rocksdb_writebatch_wi_t; +typedef struct rocksdb_writeoptions_t rocksdb_writeoptions_t; +typedef struct rocksdb_universal_compaction_options_t + rocksdb_universal_compaction_options_t; +typedef struct rocksdb_livefile_t rocksdb_livefile_t; +typedef struct rocksdb_livefiles_t rocksdb_livefiles_t; +typedef struct rocksdb_column_family_handle_t rocksdb_column_family_handle_t; +typedef struct rocksdb_column_family_metadata_t + rocksdb_column_family_metadata_t; +typedef struct rocksdb_import_column_family_options_t + rocksdb_import_column_family_options_t; +typedef struct rocksdb_export_import_files_metadata_t + rocksdb_export_import_files_metadata_t; +typedef struct rocksdb_level_metadata_t rocksdb_level_metadata_t; +typedef struct rocksdb_sst_file_metadata_t rocksdb_sst_file_metadata_t; +typedef struct rocksdb_column_family_metadata_options_t + rocksdb_column_family_metadata_options_t; +typedef struct rocksdb_envoptions_t rocksdb_envoptions_t; +typedef struct rocksdb_ingestexternalfileoptions_t + rocksdb_ingestexternalfileoptions_t; +typedef struct rocksdb_trace_options_t rocksdb_trace_options_t; +typedef struct rocksdb_trace_reader_t rocksdb_trace_reader_t; +typedef struct rocksdb_replay_options_t rocksdb_replay_options_t; +typedef struct rocksdb_replayer_t rocksdb_replayer_t; +typedef struct rocksdb_size_approximation_options_t + rocksdb_size_approximation_options_t; +typedef struct rocksdb_livefiles_storage_info_options_t + rocksdb_livefiles_storage_info_options_t; +typedef struct rocksdb_livefiles_storage_info_t + rocksdb_livefiles_storage_info_t; +typedef struct rocksdb_sstfilewriter_t rocksdb_sstfilewriter_t; +typedef struct rocksdb_ratelimiter_t rocksdb_ratelimiter_t; +typedef struct rocksdb_perfcontext_t rocksdb_perfcontext_t; +typedef struct rocksdb_pinnableslice_t rocksdb_pinnableslice_t; +typedef struct rocksdb_transactiondb_options_t rocksdb_transactiondb_options_t; +typedef struct rocksdb_transactiondb_t rocksdb_transactiondb_t; +typedef struct rocksdb_transaction_options_t rocksdb_transaction_options_t; +typedef struct rocksdb_optimistictransactiondb_t + rocksdb_optimistictransactiondb_t; +typedef struct rocksdb_optimistictransactiondb_options_t + rocksdb_optimistictransactiondb_options_t; +typedef struct rocksdb_optimistictransactiondb_lock_buckets_t + rocksdb_optimistictransactiondb_lock_buckets_t; +typedef struct rocksdb_optimistictransaction_options_t + rocksdb_optimistictransaction_options_t; +typedef struct rocksdb_transaction_t rocksdb_transaction_t; +typedef struct rocksdb_checkpoint_t rocksdb_checkpoint_t; +typedef struct rocksdb_wal_iterator_t rocksdb_wal_iterator_t; +typedef struct rocksdb_wal_readoptions_t rocksdb_wal_readoptions_t; +typedef struct rocksdb_wal_file_t rocksdb_wal_file_t; +typedef struct rocksdb_wal_files_t rocksdb_wal_files_t; +typedef struct rocksdb_memory_consumers_t rocksdb_memory_consumers_t; +typedef struct rocksdb_memory_usage_t rocksdb_memory_usage_t; +typedef struct rocksdb_statistics_histogram_data_t + rocksdb_statistics_histogram_data_t; +typedef struct rocksdb_wait_for_compact_options_t + rocksdb_wait_for_compact_options_t; + +/* rocksdb_slice_t: Optimized slice type for high-performance C API operations + * This struct is ABI-compatible with rocksdb::Slice for zero-copy interop. + * Used by slice iterator functions and batched operations. */ +typedef struct rocksdb_slice_t { + const char* data; + size_t size; +} rocksdb_slice_t; +typedef struct rocksdb_flushjobinfo_t rocksdb_flushjobinfo_t; +typedef struct rocksdb_compactionjobinfo_t rocksdb_compactionjobinfo_t; +typedef struct rocksdb_subcompactionjobinfo_t rocksdb_subcompactionjobinfo_t; +typedef struct rocksdb_externalfileingestioninfo_t + rocksdb_externalfileingestioninfo_t; +typedef struct rocksdb_table_properties_t rocksdb_table_properties_t; +typedef struct rocksdb_compaction_job_stats_t rocksdb_compaction_job_stats_t; +typedef struct rocksdb_compaction_file_info_t rocksdb_compaction_file_info_t; +typedef struct rocksdb_blob_file_addition_info_t + rocksdb_blob_file_addition_info_t; +typedef struct rocksdb_blob_file_garbage_info_t + rocksdb_blob_file_garbage_info_t; +typedef struct rocksdb_eventlistener_t rocksdb_eventlistener_t; +typedef struct rocksdb_writestallinfo_t rocksdb_writestallinfo_t; +typedef struct rocksdb_writestallcondition_t rocksdb_writestallcondition_t; +typedef struct rocksdb_memtableinfo_t rocksdb_memtableinfo_t; + +// Remote Compaction typedef +typedef struct rocksdb_compactionservice_scheduleresponse_t + rocksdb_compactionservice_scheduleresponse_t; +typedef struct rocksdb_compactionservice_jobinfo_t + rocksdb_compactionservice_jobinfo_t; +typedef struct rocksdb_compactionservice_t rocksdb_compactionservice_t; +typedef struct rocksdb_compaction_service_options_override_t + rocksdb_compaction_service_options_override_t; +typedef struct rocksdb_open_and_compact_options_t + rocksdb_open_and_compact_options_t; +typedef rocksdb_compactionservice_scheduleresponse_t* ( + *rocksdb_compaction_service_schedule_cb)( + void* state, const rocksdb_compactionservice_jobinfo_t* info, + const char* compaction_service_input, size_t input_len); + +typedef int (*rocksdb_compaction_service_wait_cb)(void* state, + const char* scheduled_job_id, + char** result, + size_t* result_len); + +typedef void (*rocksdb_compaction_service_cancel_awaiting_jobs_cb)(void* state); + +typedef void (*rocksdb_compaction_service_on_installation_cb)( + void* state, const char* scheduled_job_id, int status); + +typedef void (*rocksdb_create_backup_options_progress_cb)(void* state); +typedef unsigned char (*rocksdb_create_backup_options_exclude_files_cb)( + void* state, const char* relative_file, size_t relative_file_len); +typedef unsigned char (*rocksdb_readoptions_table_filter_cb)( + void* state, const rocksdb_table_properties_t* table_properties); +typedef void (*rocksdb_walfilter_column_family_log_number_map_cb)( + void* state, const uint32_t* column_family_ids, const uint64_t* log_numbers, + size_t column_family_log_number_count, + const char* const* column_family_names, + const size_t* column_family_name_lengths, + const uint32_t* column_family_name_ids, size_t column_family_name_count); +typedef int (*rocksdb_walfilter_log_record_found_cb)( + void* state, unsigned long long log_number, const char* log_file_name, + size_t log_file_name_len, const rocksdb_writebatch_t* batch, + rocksdb_writebatch_t* new_batch, unsigned char* batch_changed); + +/* DB operations */ + +extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open( + const rocksdb_options_t* options, const char* name, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_with_ttl( + const rocksdb_options_t* options, const char* name, int ttl, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_for_read_only( + const rocksdb_options_t* options, const char* name, + unsigned char error_if_wal_file_exists, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_as_secondary( + const rocksdb_options_t* options, const char* name, + const char* secondary_path, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_backup_engine_t* rocksdb_backup_engine_open( + const rocksdb_options_t* options, const char* path, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_backup_engine_t* +rocksdb_backup_engine_open_opts(const rocksdb_backup_engine_options_t* options, + rocksdb_env_t* env, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_create_backup_options_t* +rocksdb_create_backup_options_create(void); + +extern ROCKSDB_LIBRARY_API void rocksdb_create_backup_options_destroy( + rocksdb_create_backup_options_t* options); + +extern ROCKSDB_LIBRARY_API void +rocksdb_create_backup_options_set_progress_callback( + rocksdb_create_backup_options_t* options, void* state, + rocksdb_create_backup_options_progress_cb callback); + +extern ROCKSDB_LIBRARY_API void +rocksdb_create_backup_options_set_exclude_files_callback( + rocksdb_create_backup_options_t* options, void* state, + rocksdb_create_backup_options_exclude_files_cb callback); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_create_new_backup( + rocksdb_backup_engine_t* be, rocksdb_t* db, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_create_new_backup_flush( + rocksdb_backup_engine_t* be, rocksdb_t* db, + unsigned char flush_before_backup, char** errptr); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_create_new_backup_with_options( + rocksdb_backup_engine_t* be, rocksdb_t* db, + const rocksdb_create_backup_options_t* options, uint32_t* backup_id, + char** errptr); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_create_new_backup_with_metadata( + rocksdb_backup_engine_t* be, rocksdb_t* db, + const rocksdb_create_backup_options_t* options, const char* app_metadata, + size_t app_metadata_len, uint32_t* backup_id, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_purge_old_backups( + rocksdb_backup_engine_t* be, uint32_t num_backups_to_keep, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_restore_options_t* +rocksdb_restore_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_restore_options_destroy( + rocksdb_restore_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_verify_backup( + rocksdb_backup_engine_t* be, uint32_t backup_id, char** errptr); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_restore_db_from_latest_backup( + rocksdb_backup_engine_t* be, const char* db_dir, const char* wal_dir, + const rocksdb_restore_options_t* restore_options, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_restore_db_from_backup( + rocksdb_backup_engine_t* be, const char* db_dir, const char* wal_dir, + const rocksdb_restore_options_t* restore_options, const uint32_t backup_id, + char** errptr); + +extern ROCKSDB_LIBRARY_API const rocksdb_backup_engine_info_t* +rocksdb_backup_engine_get_backup_info(rocksdb_backup_engine_t* be); + +extern ROCKSDB_LIBRARY_API int rocksdb_backup_engine_info_count( + const rocksdb_backup_engine_info_t* info); + +extern ROCKSDB_LIBRARY_API int64_t rocksdb_backup_engine_info_timestamp( + const rocksdb_backup_engine_info_t* info, int index); + +extern ROCKSDB_LIBRARY_API uint32_t rocksdb_backup_engine_info_backup_id( + const rocksdb_backup_engine_info_t* info, int index); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_backup_engine_info_size( + const rocksdb_backup_engine_info_t* info, int index); + +extern ROCKSDB_LIBRARY_API uint32_t rocksdb_backup_engine_info_number_files( + const rocksdb_backup_engine_info_t* info, int index); + +extern ROCKSDB_LIBRARY_API const char* rocksdb_backup_engine_info_app_metadata( + const rocksdb_backup_engine_info_t* info, int index, size_t* len); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_info_destroy( + const rocksdb_backup_engine_info_t* info); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_stop_backup( + rocksdb_backup_engine_t* be); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_close( + rocksdb_backup_engine_t* be); + +#include "c_api_gen/c_generated_db_simple_subset.h.inc" +extern ROCKSDB_LIBRARY_API void rocksdb_verify_checksum_with_options( + rocksdb_t* db, const rocksdb_readoptions_t* options, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_verify_file_checksums_with_options( + rocksdb_t* db, const rocksdb_readoptions_t* options, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_increase_full_history_ts_low( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const char* ts_low, size_t ts_lowlen, char** errptr); + +extern ROCKSDB_LIBRARY_API char* rocksdb_get_full_history_ts_low( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + size_t* ts_lowlen, char** errptr); + +/* BackupEngineOptions */ + +extern ROCKSDB_LIBRARY_API rocksdb_backup_engine_options_t* +rocksdb_backup_engine_options_create(const char* backup_dir); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_set_env( + rocksdb_backup_engine_options_t* options, rocksdb_env_t* env); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_backup_rate_limiter( + rocksdb_backup_engine_options_t* options, rocksdb_ratelimiter_t* limiter); + +extern ROCKSDB_LIBRARY_API void +rocksdb_backup_engine_options_set_restore_rate_limiter( + rocksdb_backup_engine_options_t* options, rocksdb_ratelimiter_t* limiter); + +extern ROCKSDB_LIBRARY_API void rocksdb_backup_engine_options_destroy( + rocksdb_backup_engine_options_t*); + +/* Checkpoint */ + +extern ROCKSDB_LIBRARY_API rocksdb_checkpoint_t* +rocksdb_checkpoint_object_create(rocksdb_t* db, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_checkpoint_create( + rocksdb_checkpoint_t* checkpoint, const char* checkpoint_dir, + uint64_t log_size_for_flush, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_export_import_files_metadata_t* +rocksdb_checkpoint_export_column_family( + rocksdb_checkpoint_t* checkpoint, + rocksdb_column_family_handle_t* column_family, const char* export_dir, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_checkpoint_object_destroy( + rocksdb_checkpoint_t* checkpoint); + +extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_and_trim_history( + const rocksdb_options_t* options, const char* name, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char* trim_ts, + size_t trim_tslen, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_column_families( + const rocksdb_options_t* options, const char* name, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_column_families_with_ttl( + const rocksdb_options_t* options, const char* name, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, const int* ttls, + char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_t* +rocksdb_open_for_read_only_column_families( + const rocksdb_options_t* options, const char* name, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, + unsigned char error_if_wal_file_exists, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_as_secondary_column_families( + const rocksdb_options_t* options, const char* name, + const char* secondary_path, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr); + +extern ROCKSDB_LIBRARY_API char** rocksdb_list_column_families( + const rocksdb_options_t* options, const char* name, size_t* lencf, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_list_column_families_destroy( + char** list, size_t len); + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_handle_t* +rocksdb_create_column_family(rocksdb_t* db, + const rocksdb_options_t* column_family_options, + const char* column_family_name, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_handle_t** +rocksdb_create_column_families(rocksdb_t* db, + const rocksdb_options_t* column_family_options, + int num_column_families, + const char* const* column_family_names, + size_t* lencfs, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_create_column_families_destroy( + rocksdb_column_family_handle_t** list); + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_handle_t* +rocksdb_create_column_family_with_import( + rocksdb_t* db, rocksdb_options_t* column_family_options, + const char* column_family_name, + rocksdb_import_column_family_options_t* import_options, + rocksdb_export_import_files_metadata_t* metadata, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_handle_t* +rocksdb_create_column_family_with_ttl( + rocksdb_t* db, const rocksdb_options_t* column_family_options, + const char* column_family_name, int ttl, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_drop_column_family( + rocksdb_t* db, rocksdb_column_family_handle_t* handle, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_handle_t* +rocksdb_get_default_column_family_handle(rocksdb_t* db); + +extern ROCKSDB_LIBRARY_API void rocksdb_column_family_handle_destroy( + rocksdb_column_family_handle_t*); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_column_family_handle_get_id(rocksdb_column_family_handle_t* handle); + +extern ROCKSDB_LIBRARY_API char* rocksdb_column_family_handle_get_name( + rocksdb_column_family_handle_t* handle, size_t* name_len); + +extern ROCKSDB_LIBRARY_API void rocksdb_close(rocksdb_t* db); + +/* Returns NULL if not found. A malloc()ed array otherwise. + Stores the length of the array in *vallen. */ +extern ROCKSDB_LIBRARY_API char* rocksdb_get( + rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key, + size_t keylen, size_t* vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API char* rocksdb_get_with_ts( + rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key, + size_t keylen, size_t* vallen, char** ts, size_t* tslen, char** errptr); + +extern ROCKSDB_LIBRARY_API char* rocksdb_get_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, size_t* vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API char* rocksdb_get_cf_with_ts( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, size_t* vallen, char** ts, size_t* tslen, char** errptr); + +/** + * Returns a malloc() buffer with the DB identity, assigning the length to + * *id_len. Returns NULL if an error occurred. + */ +extern ROCKSDB_LIBRARY_API char* rocksdb_get_db_identity(rocksdb_t* db, + size_t* id_len); + +// if values_list[i] == NULL and errs[i] == NULL, +// then we got status.IsNotFound(), which we will not return. +// all errors except status status.ok() and status.IsNotFound() are returned. +// +// errs, values_list and values_list_sizes must be num_keys in length, +// allocated by the caller. +// errs is a list of strings as opposed to the conventional one error, +// where errs[i] is the status for retrieval of keys_list[i]. +// each non-NULL errs entry is a malloc()ed, null terminated string. +// each non-NULL values_list entry is a malloc()ed array, with +// the length for each stored in values_list_sizes[i]. +extern ROCKSDB_LIBRARY_API void rocksdb_multi_get( + rocksdb_t* db, const rocksdb_readoptions_t* options, size_t num_keys, + const char* const* keys_list, const size_t* keys_list_sizes, + char** values_list, size_t* values_list_sizes, char** errs); + +extern ROCKSDB_LIBRARY_API void rocksdb_multi_get_with_ts( + rocksdb_t* db, const rocksdb_readoptions_t* options, size_t num_keys, + const char* const* keys_list, const size_t* keys_list_sizes, + char** values_list, size_t* values_list_sizes, char** timestamp_list, + size_t* timestamp_list_sizes, char** errs); + +extern ROCKSDB_LIBRARY_API void rocksdb_multi_get_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + const rocksdb_column_family_handle_t* const* column_families, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs); + +extern ROCKSDB_LIBRARY_API void rocksdb_multi_get_cf_with_ts( + rocksdb_t* db, const rocksdb_readoptions_t* options, + const rocksdb_column_family_handle_t* const* column_families, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** timestamps_list, + size_t* timestamps_list_sizes, char** errs); + +// The MultiGet API that improves performance by batching operations +// in the read path for greater efficiency. Currently, only the block based +// table format with full filters are supported. Other table formats such +// as plain table, block based table with block based filters and +// partitioned indexes will still work, but will not get any performance +// benefits. +// +// Note that all the keys passed to this API are restricted to a single +// column family. +// +// Parameters - +// db - the RocksDB instance. +// options - ReadOptions +// column_family - ColumnFamilyHandle* that the keys belong to. All the keys +// passed to the API are restricted to a single column family +// num_keys - Number of keys to lookup +// keys_list - Pointer to C style array of keys with num_keys elements +// keys_list_sizes - Pointer to C style array of the size of corresponding key +// in key_list with num_keys elements. +// values - Pointer to C style array of PinnableSlices with num_keys elements +// statuses - Pointer to C style array of Status with num_keys elements +// sorted_input - If true, it means the input keys are already sorted by key +// order, so the MultiGet() API doesn't have to sort them +// again. If false, the keys will be copied and sorted +// internally by the API - the input array will not be +// modified +extern ROCKSDB_LIBRARY_API void rocksdb_batched_multi_get_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, size_t num_keys, + const char* const* keys_list, const size_t* keys_list_sizes, + rocksdb_pinnableslice_t** values, char** errs, const bool sorted_input); + +/* Batched MultiGet with slice array: Takes rocksdb_slice_t array directly, + * avoiding key conversion. faster than rocksdb_batched_multi_get_cf for + * operations with many keys. Eliminates overhead of converting keys from + * separate pointer+size arrays to Slice objects. */ +extern ROCKSDB_LIBRARY_API void rocksdb_batched_multi_get_cf_slice( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, size_t num_keys, + const rocksdb_slice_t* keys_list, rocksdb_pinnableslice_t** values, + char** errs, const bool sorted_input); + +// The value is only allocated (using malloc) and returned if it is found and +// value_found isn't NULL. In that case the user is responsible for freeing it. +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_key_may_exist( + rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key, + size_t key_len, char** value, size_t* val_len, const char* timestamp, + size_t timestamp_len, unsigned char* value_found); + +// The value is only allocated (using malloc) and returned if it is found and +// value_found isn't NULL. In that case the user is responsible for freeing it. +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_key_may_exist_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t key_len, char** value, size_t* val_len, const char* timestamp, + size_t timestamp_len, unsigned char* value_found); + +extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* rocksdb_create_iterator( + rocksdb_t* db, const rocksdb_readoptions_t* options); + +extern ROCKSDB_LIBRARY_API rocksdb_wal_iterator_t* rocksdb_get_updates_since( + rocksdb_t* db, uint64_t seq_number, + const rocksdb_wal_readoptions_t* options, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_wal_files_t* rocksdb_get_sorted_wal_files( + rocksdb_t* db, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_wal_file_t* rocksdb_get_current_wal_file( + rocksdb_t* db, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* rocksdb_create_iterator_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family); + +extern ROCKSDB_LIBRARY_API void rocksdb_create_iterators( + rocksdb_t* db, rocksdb_readoptions_t* opts, + rocksdb_column_family_handle_t** column_families, + rocksdb_iterator_t** iterators, size_t size, char** errptr); + +extern ROCKSDB_LIBRARY_API const rocksdb_snapshot_t* rocksdb_create_snapshot( + rocksdb_t* db); + +extern ROCKSDB_LIBRARY_API void rocksdb_release_snapshot( + rocksdb_t* db, const rocksdb_snapshot_t* snapshot); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_snapshot_get_sequence_number(const rocksdb_snapshot_t* snapshot); + +/* Returns NULL if property name is unknown. + Else returns a pointer to a malloc()-ed null-terminated value. */ +extern ROCKSDB_LIBRARY_API char* rocksdb_property_value(rocksdb_t* db, + const char* propname); +/* returns 0 on success, -1 otherwise */ +extern ROCKSDB_LIBRARY_API int rocksdb_property_int(rocksdb_t* db, + const char* propname, + uint64_t* out_val); + +/* returns 0 on success, -1 otherwise */ +extern ROCKSDB_LIBRARY_API int rocksdb_property_int_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const char* propname, uint64_t* out_val); + +extern ROCKSDB_LIBRARY_API char* rocksdb_property_value_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const char* propname); + +extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes( + rocksdb_t* db, int num_ranges, const char* const* range_start_key, + const size_t* range_start_key_len, const char* const* range_limit_key, + const size_t* range_limit_key_len, uint64_t* sizes, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + int num_ranges, const char* const* range_start_key, + const size_t* range_start_key_len, const char* const* range_limit_key, + const size_t* range_limit_key_len, uint64_t* sizes, char** errptr); + +enum { + rocksdb_size_approximation_flags_none = 0, + rocksdb_size_approximation_flags_include_memtable = 1 << 0, + rocksdb_size_approximation_flags_include_files = 1 << 1, + rocksdb_size_approximation_flags_include_blob_files = 1 << 2, +}; + +extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_cf_with_flags( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + int num_ranges, const char* const* range_start_key, + const size_t* range_start_key_len, const char* const* range_limit_key, + const size_t* range_limit_key_len, uint8_t include_flags, uint64_t* sizes, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_with_options( + rocksdb_t* db, const rocksdb_size_approximation_options_t* options, + int num_ranges, const char* const* range_start_key, + const size_t* range_start_key_len, const char* const* range_limit_key, + const size_t* range_limit_key_len, uint64_t* sizes, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_cf_with_options( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const rocksdb_size_approximation_options_t* options, int num_ranges, + const char* const* range_start_key, const size_t* range_start_key_len, + const char* const* range_limit_key, const size_t* range_limit_key_len, + uint64_t* sizes, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_size_approximation_options_t* +rocksdb_size_approximation_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_size_approximation_options_destroy( + rocksdb_size_approximation_options_t* options); + +extern ROCKSDB_LIBRARY_API void rocksdb_compact_range(rocksdb_t* db, + const char* start_key, + size_t start_key_len, + const char* limit_key, + size_t limit_key_len); + +extern ROCKSDB_LIBRARY_API void rocksdb_compact_range_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, const char* limit_key, + size_t limit_key_len); + +extern ROCKSDB_LIBRARY_API void rocksdb_suggest_compact_range( + rocksdb_t* db, const char* start_key, size_t start_key_len, + const char* limit_key, size_t limit_key_len, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_suggest_compact_range_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, const char* limit_key, + size_t limit_key_len, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_compact_range_opt( + rocksdb_t* db, rocksdb_compactoptions_t* opt, const char* start_key, + size_t start_key_len, const char* limit_key, size_t limit_key_len); + +extern ROCKSDB_LIBRARY_API void rocksdb_compact_range_cf_opt( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + rocksdb_compactoptions_t* opt, const char* start_key, size_t start_key_len, + const char* limit_key, size_t limit_key_len); + +extern ROCKSDB_LIBRARY_API void rocksdb_compact_files( + rocksdb_t* db, const rocksdb_compaction_options_t* options, + const char* const* input_file_names, size_t num_input_file_names, + int output_level, int output_path_id, char*** output_file_names, + size_t* num_output_file_names, + rocksdb_compactionjobinfo_t* compaction_job_info, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_compact_files_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const rocksdb_compaction_options_t* options, + const char* const* input_file_names, size_t num_input_file_names, + int output_level, int output_path_id, char*** output_file_names, + size_t* num_output_file_names, + rocksdb_compactionjobinfo_t* compaction_job_info, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_compact_files_output_file_names_destroy( + char** output_file_names, size_t num_output_file_names); + +extern ROCKSDB_LIBRARY_API const rocksdb_livefiles_t* rocksdb_livefiles( + rocksdb_t* db); + +extern ROCKSDB_LIBRARY_API void rocksdb_flush_cfs( + rocksdb_t* db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t** column_family, int num_column_families, + char** errptr); + +/* Management operations */ + +/* Iterator */ + +extern ROCKSDB_LIBRARY_API void rocksdb_iter_destroy(rocksdb_iterator_t*); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_iter_valid( + const rocksdb_iterator_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_iter_seek_to_first(rocksdb_iterator_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_iter_seek_to_last(rocksdb_iterator_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_iter_seek(rocksdb_iterator_t*, + const char* k, size_t klen); +extern ROCKSDB_LIBRARY_API void rocksdb_iter_seek_for_prev(rocksdb_iterator_t*, + const char* k, + size_t klen); +extern ROCKSDB_LIBRARY_API void rocksdb_iter_next(rocksdb_iterator_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_iter_prev(rocksdb_iterator_t*); +extern ROCKSDB_LIBRARY_API const char* rocksdb_iter_key( + const rocksdb_iterator_t*, size_t* klen); +extern ROCKSDB_LIBRARY_API const char* rocksdb_iter_value( + const rocksdb_iterator_t*, size_t* vlen); +extern ROCKSDB_LIBRARY_API const char* rocksdb_iter_timestamp( + const rocksdb_iterator_t*, size_t* tslen); +extern ROCKSDB_LIBRARY_API void rocksdb_iter_get_error( + const rocksdb_iterator_t*, char** errptr); + +/* Slice iterator functions: Return rocksdb_slice_t directly for better + * performance. These functions avoid the overhead of passing output parameters + * and provide zero-copy access to key/value/timestamp data. faster than + * traditional rocksdb_iter_key/value/timestamp functions. */ +extern ROCKSDB_LIBRARY_API rocksdb_slice_t +rocksdb_iter_key_slice(const rocksdb_iterator_t* iter); +extern ROCKSDB_LIBRARY_API rocksdb_slice_t +rocksdb_iter_value_slice(const rocksdb_iterator_t* iter); +extern ROCKSDB_LIBRARY_API rocksdb_slice_t +rocksdb_iter_timestamp_slice(const rocksdb_iterator_t* iter); + +extern ROCKSDB_LIBRARY_API void rocksdb_iter_refresh( + const rocksdb_iterator_t* iter, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_wal_iter_next( + rocksdb_wal_iterator_t* iter); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_wal_iter_valid( + const rocksdb_wal_iterator_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_wal_iter_status( + const rocksdb_wal_iterator_t* iter, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_writebatch_t* rocksdb_wal_iter_get_batch( + const rocksdb_wal_iterator_t* iter, uint64_t* seq); +enum { + rocksdb_wal_file_type_archived_log = 0, + rocksdb_wal_file_type_alive_log = 1, +}; +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_get_latest_sequence_number(rocksdb_t* db); +extern ROCKSDB_LIBRARY_API void rocksdb_wal_iter_destroy( + const rocksdb_wal_iterator_t* iter); +extern ROCKSDB_LIBRARY_API rocksdb_wal_readoptions_t* +rocksdb_wal_readoptions_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_wal_readoptions_destroy( + rocksdb_wal_readoptions_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_wal_readoptions_set_verify_checksums( + rocksdb_wal_readoptions_t* options, unsigned char verify_checksums); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_wal_readoptions_get_verify_checksums( + rocksdb_wal_readoptions_t* options); +extern ROCKSDB_LIBRARY_API const char* rocksdb_wal_file_path_name( + const rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_wal_file_log_number(const rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API int rocksdb_wal_file_type( + const rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_wal_file_start_sequence(const rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_wal_file_size_file_bytes(const rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API void rocksdb_wal_file_destroy( + rocksdb_wal_file_t* file); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_wal_files_count(const rocksdb_wal_files_t* files); +extern ROCKSDB_LIBRARY_API const rocksdb_wal_file_t* +rocksdb_wal_files_get_wal_file(const rocksdb_wal_files_t* files, size_t index); +extern ROCKSDB_LIBRARY_API void rocksdb_wal_files_destroy( + rocksdb_wal_files_t* files); + +/* Write batch */ + +extern ROCKSDB_LIBRARY_API rocksdb_writebatch_t* rocksdb_writebatch_create( + void); +extern ROCKSDB_LIBRARY_API rocksdb_writebatch_t* rocksdb_writebatch_create_from( + const char* rep, size_t size); +extern ROCKSDB_LIBRARY_API rocksdb_writebatch_t* +rocksdb_writebatch_create_with_params(size_t reserved_bytes, size_t max_bytes, + size_t protection_bytes_per_key, + size_t default_cf_ts_sz); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_destroy( + rocksdb_writebatch_t*); +#include "c_api_gen/c_generated_writebatch_subset.h.inc" +extern ROCKSDB_LIBRARY_API int rocksdb_writebatch_count(rocksdb_writebatch_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_put_cf_with_ts( + rocksdb_writebatch_t*, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* ts, size_t tslen, const char* val, + size_t vlen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_putv( + rocksdb_writebatch_t* b, int num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, int num_values, + const char* const* values_list, const size_t* values_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_putv_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, const size_t* keys_list_sizes, + int num_values, const char* const* values_list, + const size_t* values_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_merge(rocksdb_writebatch_t*, + const char* key, + size_t klen, + const char* val, + size_t vlen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_merge_cf( + rocksdb_writebatch_t*, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_mergev( + rocksdb_writebatch_t* b, int num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, int num_values, + const char* const* values_list, const size_t* values_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_mergev_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, const size_t* keys_list_sizes, + int num_values, const char* const* values_list, + const size_t* values_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_singledelete( + rocksdb_writebatch_t* b, const char* key, size_t klen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_cf( + rocksdb_writebatch_t*, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_cf_with_ts( + rocksdb_writebatch_t*, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* ts, size_t tslen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_singledelete_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_singledelete_cf_with_ts( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* ts, size_t tslen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_deletev( + rocksdb_writebatch_t* b, int num_keys, const char* const* keys_list, + const size_t* keys_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_deletev_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, const size_t* keys_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_range( + rocksdb_writebatch_t* b, const char* start_key, size_t start_key_len, + const char* end_key, size_t end_key_len); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_range_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, const char* end_key, + size_t end_key_len); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_rangev( + rocksdb_writebatch_t* b, int num_keys, const char* const* start_keys_list, + const size_t* start_keys_list_sizes, const char* const* end_keys_list, + const size_t* end_keys_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_delete_rangev_cf( + rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* start_keys_list, + const size_t* start_keys_list_sizes, const char* const* end_keys_list, + const size_t* end_keys_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_iterate( + rocksdb_writebatch_t*, void* state, + void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen), + void (*deleted)(void*, const char* k, size_t klen)); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_iterate_ld( + rocksdb_writebatch_t*, void* state, + void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen), + void (*deleted)(void*, const char* k, size_t klen), + void (*log_data)(void*, const char* blob, size_t blob_len)); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_iterate_cf( + rocksdb_writebatch_t*, void* state, + void (*put_cf)(void*, uint32_t cfid, const char* k, size_t klen, + const char* v, size_t vlen), + void (*deleted_cf)(void*, uint32_t cfid, const char* k, size_t klen), + void (*merge_cf)(void*, uint32_t cfid, const char* k, size_t klen, + const char* v, size_t vlen)); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_iterate_cf_ld( + rocksdb_writebatch_t*, void* state, + void (*put_cf)(void*, uint32_t cfid, const char* k, size_t klen, + const char* v, size_t vlen), + void (*deleted_cf)(void*, uint32_t cfid, const char* k, size_t klen), + void (*merge_cf)(void*, uint32_t cfid, const char* k, size_t klen, + const char* v, size_t vlen), + void (*log_data)(void*, const char* blob, size_t blob_len)); +extern ROCKSDB_LIBRARY_API const char* rocksdb_writebatch_data( + rocksdb_writebatch_t*, size_t* size); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_update_timestamps( + rocksdb_writebatch_t* wb, const char* ts, size_t tslen, void* state, + size_t (*get_ts_size)(void*, uint32_t), char** errptr); + +/* Write batch with index */ + +extern ROCKSDB_LIBRARY_API rocksdb_writebatch_wi_t* +rocksdb_writebatch_wi_create(size_t reserved_bytes, + unsigned char overwrite_keys); +extern ROCKSDB_LIBRARY_API rocksdb_writebatch_wi_t* +rocksdb_writebatch_wi_create_with_params( + rocksdb_comparator_t* backup_index_comparator, size_t reserved_bytes, + unsigned char overwrite_key, size_t max_bytes, + size_t protection_bytes_per_key); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_destroy( + rocksdb_writebatch_wi_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_clear( + rocksdb_writebatch_wi_t*); +extern ROCKSDB_LIBRARY_API int rocksdb_writebatch_wi_count( + rocksdb_writebatch_wi_t* b); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_put( + rocksdb_writebatch_wi_t*, const char* key, size_t klen, const char* val, + size_t vlen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_put_cf( + rocksdb_writebatch_wi_t*, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_putv( + rocksdb_writebatch_wi_t* b, int num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, int num_values, + const char* const* values_list, const size_t* values_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_putv_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, const size_t* keys_list_sizes, + int num_values, const char* const* values_list, + const size_t* values_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_merge( + rocksdb_writebatch_wi_t*, const char* key, size_t klen, const char* val, + size_t vlen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_merge_cf( + rocksdb_writebatch_wi_t*, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, const char* val, size_t vlen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_mergev( + rocksdb_writebatch_wi_t* b, int num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, int num_values, + const char* const* values_list, const size_t* values_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_mergev_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, const size_t* keys_list_sizes, + int num_values, const char* const* values_list, + const size_t* values_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_delete( + rocksdb_writebatch_wi_t*, const char* key, size_t klen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_singledelete( + rocksdb_writebatch_wi_t*, const char* key, size_t klen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_delete_cf( + rocksdb_writebatch_wi_t*, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_singledelete_cf( + rocksdb_writebatch_wi_t*, rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_deletev( + rocksdb_writebatch_wi_t* b, int num_keys, const char* const* keys_list, + const size_t* keys_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_deletev_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* keys_list, const size_t* keys_list_sizes); +// DO NOT USE - rocksdb_writebatch_wi_delete_range is not yet supported +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_delete_range( + rocksdb_writebatch_wi_t* b, const char* start_key, size_t start_key_len, + const char* end_key, size_t end_key_len); +// DO NOT USE - rocksdb_writebatch_wi_delete_range_cf is not yet supported +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_delete_range_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, const char* end_key, + size_t end_key_len); +// DO NOT USE - rocksdb_writebatch_wi_delete_rangev is not yet supported +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_delete_rangev( + rocksdb_writebatch_wi_t* b, int num_keys, + const char* const* start_keys_list, const size_t* start_keys_list_sizes, + const char* const* end_keys_list, const size_t* end_keys_list_sizes); +// DO NOT USE - rocksdb_writebatch_wi_delete_rangev_cf is not yet supported +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_delete_rangev_cf( + rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family, + int num_keys, const char* const* start_keys_list, + const size_t* start_keys_list_sizes, const char* const* end_keys_list, + const size_t* end_keys_list_sizes); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_put_log_data( + rocksdb_writebatch_wi_t*, const char* blob, size_t len); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_iterate( + rocksdb_writebatch_wi_t* b, void* state, + void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen), + void (*deleted)(void*, const char* k, size_t klen)); +extern ROCKSDB_LIBRARY_API const char* rocksdb_writebatch_wi_data( + rocksdb_writebatch_wi_t* b, size_t* size); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_set_save_point( + rocksdb_writebatch_wi_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_rollback_to_save_point( + rocksdb_writebatch_wi_t*, char** errptr); +extern ROCKSDB_LIBRARY_API char* rocksdb_writebatch_wi_get_from_batch( + rocksdb_writebatch_wi_t* wbwi, const rocksdb_options_t* options, + const char* key, size_t keylen, size_t* vallen, char** errptr); +extern ROCKSDB_LIBRARY_API char* rocksdb_writebatch_wi_get_from_batch_cf( + rocksdb_writebatch_wi_t* wbwi, const rocksdb_options_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, size_t* vallen, char** errptr); +extern ROCKSDB_LIBRARY_API char* rocksdb_writebatch_wi_get_from_batch_and_db( + rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db, + const rocksdb_readoptions_t* options, const char* key, size_t keylen, + size_t* vallen, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_pinnableslice_t* +rocksdb_writebatch_wi_get_pinned_from_batch_and_db( + rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db, + const rocksdb_readoptions_t* options, const char* key, size_t keylen, + char** errptr); +extern ROCKSDB_LIBRARY_API char* rocksdb_writebatch_wi_get_from_batch_and_db_cf( + rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db, + const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, size_t* vallen, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_pinnableslice_t* +rocksdb_writebatch_wi_get_pinned_from_batch_and_db_cf( + rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db, + const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_write_writebatch_wi( + rocksdb_t* db, const rocksdb_writeoptions_t* options, + rocksdb_writebatch_wi_t* wbwi, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* +rocksdb_writebatch_wi_create_iterator_with_base( + rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator); +extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* +rocksdb_writebatch_wi_create_iterator_with_base_readopts( + rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator, + const rocksdb_readoptions_t* options); +extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* +rocksdb_writebatch_wi_create_iterator_with_base_cf( + rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator, + rocksdb_column_family_handle_t* cf); +extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* +rocksdb_writebatch_wi_create_iterator_with_base_cf_readopts( + rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator, + rocksdb_column_family_handle_t* cf, const rocksdb_readoptions_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_writebatch_wi_update_timestamps( + rocksdb_writebatch_wi_t* wbwi, const char* ts, size_t tslen, void* state, + size_t (*get_ts_size)(void*, uint32_t), char** errptr); +/* Options utils */ + +// Load the latest rocksdb options from the specified db_path. +// +// On success, num_column_families will be updated with a non-zero +// number indicating the number of column families. +// The returned db_options, column_family_names, and column_family_options +// should be released via rocksdb_load_latest_options_destroy(). +// +// On error, a non-null errptr that includes the error message will be +// returned. db_options, column_family_names, and column_family_options +// will be set to NULL. +extern ROCKSDB_LIBRARY_API void rocksdb_load_latest_options( + const char* db_path, rocksdb_env_t* env, bool ignore_unknown_options, + rocksdb_cache_t* cache, rocksdb_options_t** db_options, + size_t* num_column_families, char*** column_family_names, + rocksdb_options_t*** column_family_options, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_load_latest_options_destroy( + rocksdb_options_t* db_options, char** list_column_family_names, + rocksdb_options_t** list_column_family_options, size_t len); + +/* Block based table options */ + +extern ROCKSDB_LIBRARY_API rocksdb_block_based_table_options_t* +rocksdb_block_based_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_destroy( + rocksdb_block_based_table_options_t* options); +#include "c_api_gen/c_generated_block_based_options_subset.h.inc" +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_filter_policy( + rocksdb_block_based_table_options_t* options, + rocksdb_filterpolicy_t* filter_policy); +extern ROCKSDB_LIBRARY_API void rocksdb_block_based_options_set_block_cache( + rocksdb_block_based_table_options_t* options, rocksdb_cache_t* block_cache); +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_set_user_defined_index_factory_from_string( + rocksdb_block_based_table_options_t* options, const char* value, + size_t value_len, char** errptr); +extern ROCKSDB_LIBRARY_API void +rocksdb_block_based_options_clear_user_defined_index_factory( + rocksdb_block_based_table_options_t* options); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_block_based_options_get_user_defined_index_factory_name( + const rocksdb_block_based_table_options_t* options, size_t* name_len); +enum { + rocksdb_block_based_table_index_type_binary_search = 0, + rocksdb_block_based_table_index_type_hash_search = 1, + rocksdb_block_based_table_index_type_two_level_index_search = 2, +}; +enum { + rocksdb_block_based_table_data_block_index_type_binary_search = 0, + rocksdb_block_based_table_data_block_index_type_binary_search_and_hash = 1, +}; +enum { + rocksdb_block_based_table_index_block_search_type_binary = 0, + rocksdb_block_based_table_index_block_search_type_interpolation = 1, + rocksdb_block_based_table_index_block_search_type_auto = 2, +}; +// rocksdb_block_based_options_set_hash_index_allow_collision() +// is removed since BlockBasedTableOptions.hash_index_allow_collision() +// is removed +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_block_based_table_factory( + rocksdb_options_t* opt, rocksdb_block_based_table_options_t* table_options); +enum { + rocksdb_block_based_k_fallback_pinning_tier = 0, + rocksdb_block_based_k_none_pinning_tier = 1, + rocksdb_block_based_k_flush_and_similar_pinning_tier = 2, + rocksdb_block_based_k_all_pinning_tier = 3, +}; +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_buffer_manager( + rocksdb_options_t* opt, rocksdb_write_buffer_manager_t* wbm); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_sst_file_manager( + rocksdb_options_t* opt, rocksdb_sst_file_manager_t* sfm); + +/* Flush job info */ +#include "c_api_gen/c_generated_jobinfo_auto.h.inc" +#include "c_api_gen/c_generated_jobinfo_metadata_subset.h.inc" +#include "c_api_gen/c_generated_metadata_structs_auto.h.inc" +extern ROCKSDB_LIBRARY_API rocksdb_compactionjobinfo_t* +rocksdb_compactionjobinfo_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_compactionjobinfo_destroy( + rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API void rocksdb_reset_status( + rocksdb_status_ptr_t* status_ptr); +extern ROCKSDB_LIBRARY_API void rocksdb_status_ptr_get_error( + rocksdb_status_ptr_t* status, char** errptr); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_table_properties_has_key_largest_seqno( + const rocksdb_table_properties_t* props); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_table_properties_has_key_smallest_seqno( + const rocksdb_table_properties_t* props); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_table_properties_user_collected_properties_count( + const rocksdb_table_properties_t* props); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_user_collected_properties_key_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* key_len); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_user_collected_properties_value_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* value_len); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_table_properties_readable_properties_count( + const rocksdb_table_properties_t* props); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_readable_properties_key_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* key_len); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_table_properties_readable_properties_value_at( + const rocksdb_table_properties_t* props, size_t pos, size_t* value_len); +extern ROCKSDB_LIBRARY_API const rocksdb_table_properties_t* +rocksdb_flushjobinfo_table_properties(const rocksdb_flushjobinfo_t* info); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_flushjobinfo_blob_file_addition_infos_count( + const rocksdb_flushjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_blob_file_addition_info_t* +rocksdb_flushjobinfo_blob_file_addition_info_at( + const rocksdb_flushjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API const char* rocksdb_compactionjobinfo_input_file_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size); +extern ROCKSDB_LIBRARY_API const char* rocksdb_compactionjobinfo_output_file_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size); +extern ROCKSDB_LIBRARY_API const rocksdb_compaction_job_stats_t* +rocksdb_compactionjobinfo_stats(const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_input_file_infos_count( + const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_compaction_file_info_t* +rocksdb_compactionjobinfo_input_file_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_output_file_infos_count( + const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_compaction_file_info_t* +rocksdb_compactionjobinfo_output_file_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_table_properties_count( + const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compactionjobinfo_table_properties_key_at( + const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* key_len); +extern ROCKSDB_LIBRARY_API const rocksdb_table_properties_t* +rocksdb_compactionjobinfo_table_properties_value_at( + const rocksdb_compactionjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API const rocksdb_table_properties_t* +rocksdb_compactionjobinfo_table_properties_for_file( + const rocksdb_compactionjobinfo_t* info, const char* file_name, + size_t file_name_len); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_blob_file_addition_infos_count( + const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_blob_file_addition_info_t* +rocksdb_compactionjobinfo_blob_file_addition_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_compactionjobinfo_blob_file_garbage_infos_count( + const rocksdb_compactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_blob_file_garbage_info_t* +rocksdb_compactionjobinfo_blob_file_garbage_info_at( + const rocksdb_compactionjobinfo_t* info, size_t pos); +extern ROCKSDB_LIBRARY_API const rocksdb_compaction_job_stats_t* +rocksdb_subcompactionjobinfo_stats(const rocksdb_subcompactionjobinfo_t* info); +extern ROCKSDB_LIBRARY_API const rocksdb_table_properties_t* +rocksdb_externalfileingestioninfo_table_properties( + const rocksdb_externalfileingestioninfo_t* info); + +/* Event listener */ + +typedef void (*on_flush_begin_cb)(void*, rocksdb_t*, + const rocksdb_flushjobinfo_t*); +typedef void (*on_flush_completed_cb)(void*, rocksdb_t*, + const rocksdb_flushjobinfo_t*); +typedef void (*on_compaction_begin_cb)(void*, rocksdb_t*, + const rocksdb_compactionjobinfo_t*); +typedef void (*on_compaction_completed_cb)(void*, rocksdb_t*, + const rocksdb_compactionjobinfo_t*); +typedef void (*on_subcompaction_begin_cb)( + void*, const rocksdb_subcompactionjobinfo_t*); +typedef void (*on_subcompaction_completed_cb)( + void*, const rocksdb_subcompactionjobinfo_t*); +typedef void (*on_external_file_ingested_cb)( + void*, rocksdb_t*, const rocksdb_externalfileingestioninfo_t*); +typedef void (*on_background_error_cb)(void*, uint32_t, rocksdb_status_ptr_t*); +typedef void (*on_stall_conditions_changed_cb)(void*, + const rocksdb_writestallinfo_t*); +typedef void (*rocksdb_logger_logv_cb)(void*, uint32_t log_level, const char*); +typedef void (*on_memtable_sealed_cb)(void*, const rocksdb_memtableinfo_t*); +extern ROCKSDB_LIBRARY_API rocksdb_eventlistener_t* +rocksdb_eventlistener_create( + void* state_, void (*destructor_)(void*), on_flush_begin_cb on_flush_begin, + on_flush_completed_cb on_flush_completed, + on_compaction_begin_cb on_compaction_begin, + on_compaction_completed_cb on_compaction_completed, + on_subcompaction_begin_cb on_subcompaction_begin, + on_subcompaction_completed_cb on_subcompaction_completed, + on_external_file_ingested_cb on_external_file_ingested, + on_background_error_cb on_background_error, + on_stall_conditions_changed_cb on_stall_conditions_changed, + on_memtable_sealed_cb on_memtable_sealed); +extern ROCKSDB_LIBRARY_API void rocksdb_eventlistener_destroy( + rocksdb_eventlistener_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_add_eventlistener( + rocksdb_options_t*, rocksdb_eventlistener_t*); + +/* Cuckoo table options */ + +extern ROCKSDB_LIBRARY_API rocksdb_cuckoo_table_options_t* +rocksdb_cuckoo_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_cuckoo_options_destroy( + rocksdb_cuckoo_table_options_t* options); +#include "c_api_gen/c_generated_cuckoo_options_subset.h.inc" +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_cuckoo_table_factory( + rocksdb_options_t* opt, rocksdb_cuckoo_table_options_t* table_options); + +/* Options */ +extern ROCKSDB_LIBRARY_API void rocksdb_set_options(rocksdb_t* db, int count, + const char* const keys[], + const char* const values[], + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_set_db_options( + rocksdb_t* db, int count, const char* const keys[], + const char* const values[], char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_set_options_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* handle, int count, + const char* const keys[], const char* const values[], char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_options_t* rocksdb_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_options_destroy(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API rocksdb_options_t* rocksdb_options_create_copy( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_increase_parallelism( + rocksdb_options_t* opt, int total_threads); +extern ROCKSDB_LIBRARY_API void rocksdb_options_optimize_for_point_lookup( + rocksdb_options_t* opt, uint64_t block_cache_size_mb); +extern ROCKSDB_LIBRARY_API void rocksdb_options_optimize_level_style_compaction( + rocksdb_options_t* opt, uint64_t memtable_memory_budget); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_optimize_universal_style_compaction( + rocksdb_options_t* opt, uint64_t memtable_memory_budget); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_ingest_behind( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_allow_ingest_behind(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compaction_filter( + rocksdb_options_t*, rocksdb_compactionfilter_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compaction_filter_factory( + rocksdb_options_t*, rocksdb_compactionfilterfactory_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_compaction_readahead_size( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_compaction_readahead_size(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_comparator( + rocksdb_options_t*, rocksdb_comparator_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_merge_operator( + rocksdb_options_t*, rocksdb_mergeoperator_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_wal_filter( + rocksdb_options_t*, rocksdb_walfilter_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_clear_wal_filter( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_uint64add_merge_operator( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compression_per_level( + rocksdb_options_t* opt, const int* level_values, size_t num_levels); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_create_if_missing( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_create_if_missing( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_create_missing_column_families(rocksdb_options_t*, + unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_create_missing_column_families(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_error_if_exists( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_error_if_exists( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_paranoid_checks( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_paranoid_checks( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_open_files_async( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_open_files_async( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_db_paths( + rocksdb_options_t*, const rocksdb_dbpath_t** path_values, size_t num_paths); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_cf_paths( + rocksdb_options_t*, const rocksdb_dbpath_t** path_values, size_t num_paths); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_env(rocksdb_options_t*, + rocksdb_env_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_info_log(rocksdb_options_t*, + rocksdb_logger_t*); +extern ROCKSDB_LIBRARY_API rocksdb_logger_t* rocksdb_options_get_info_log( + rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_info_log_level( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_info_log_level( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API rocksdb_logger_t* +rocksdb_logger_create_stderr_logger(int log_level, const char* prefix); +extern ROCKSDB_LIBRARY_API rocksdb_logger_t* +rocksdb_logger_create_callback_logger(int log_level, + void (*)(void* priv, unsigned lev, + char* msg, size_t len), + void* priv); +extern ROCKSDB_LIBRARY_API void rocksdb_logger_destroy( + rocksdb_logger_t* logger); + +/* File Checksum Gen Factory */ +extern ROCKSDB_LIBRARY_API rocksdb_file_checksum_gen_factory_t* +rocksdb_file_checksum_gen_crc32c_factory_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_file_checksum_gen_factory_destroy( + rocksdb_file_checksum_gen_factory_t* factory); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_file_checksum_gen_factory( + rocksdb_options_t*, rocksdb_file_checksum_gen_factory_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_checksum_handoff_file_types_clear(rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void rocksdb_options_checksum_handoff_file_types_add( + rocksdb_options_t* opt, int file_type); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_checksum_handoff_file_types_remove(rocksdb_options_t* opt, + int file_type); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_checksum_handoff_file_types_contains(rocksdb_options_t* opt, + int file_type); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_checksum_handoff_file_types_count(rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_calculate_sst_write_lifetime_hint_set_clear( + rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_calculate_sst_write_lifetime_hint_set_add( + rocksdb_options_t* opt, int compaction_style); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_calculate_sst_write_lifetime_hint_set_remove( + rocksdb_options_t* opt, int compaction_style); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_calculate_sst_write_lifetime_hint_set_contains( + rocksdb_options_t* opt, int compaction_style); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_calculate_sst_write_lifetime_hint_set_count( + rocksdb_options_t* opt); + +/* SST Partitioner Factory */ +extern ROCKSDB_LIBRARY_API rocksdb_sst_partitioner_factory_t* +rocksdb_sst_partitioner_fixed_prefix_factory_create(size_t prefix_len); +extern ROCKSDB_LIBRARY_API void rocksdb_sst_partitioner_factory_destroy( + rocksdb_sst_partitioner_factory_t* factory); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_sst_partitioner_factory( + rocksdb_options_t*, rocksdb_sst_partitioner_factory_t*); + +/* Table Properties Collector Factory */ +extern ROCKSDB_LIBRARY_API void +rocksdb_table_properties_collector_factory_destroy( + rocksdb_table_properties_collector_factory_t* factory); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_add_table_properties_collector_factory( + rocksdb_options_t*, rocksdb_table_properties_collector_factory_t*); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_buffer_size( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_write_buffer_size(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_db_write_buffer_size( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_db_write_buffer_size(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_open_files( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_max_open_files( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_file_opening_threads( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_max_file_opening_threads( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_total_wal_size( + rocksdb_options_t* opt, uint64_t n); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_max_total_wal_size(rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compression_options( + rocksdb_options_t*, int, int, int, int); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_compression_options_zstd_max_train_bytes(rocksdb_options_t*, + int); +extern ROCKSDB_LIBRARY_API int +rocksdb_options_get_compression_options_zstd_max_train_bytes( + rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_compression_options_use_zstd_dict_trainer( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_compression_options_parallel_threads(rocksdb_options_t*, + int); +extern ROCKSDB_LIBRARY_API int +rocksdb_options_get_compression_options_parallel_threads( + rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_compression_options_max_dict_buffer_bytes( + rocksdb_options_t*, uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_compression_options_max_dict_buffer_bytes( + rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_bottommost_compression_options(rocksdb_options_t*, int, int, + int, int, unsigned char); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_bottommost_compression_options_zstd_max_train_bytes( + rocksdb_options_t*, int, unsigned char); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_bottommost_compression_options_use_zstd_dict_trainer( + rocksdb_options_t*, unsigned char, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_bottommost_compression_options_use_zstd_dict_trainer( + rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_bottommost_compression_options_max_dict_buffer_bytes( + rocksdb_options_t*, uint64_t, unsigned char); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_prefix_extractor( + rocksdb_options_t*, rocksdb_slicetransform_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_num_levels( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_num_levels( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_level0_file_num_compaction_trigger(rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int +rocksdb_options_get_level0_file_num_compaction_trigger(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_level0_slowdown_writes_trigger(rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int +rocksdb_options_get_level0_slowdown_writes_trigger(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_level0_stop_writes_trigger( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_level0_stop_writes_trigger( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_target_file_size_base( + rocksdb_options_t*, uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_target_file_size_base(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_target_file_size_multiplier( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_target_file_size_multiplier( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_bytes_for_level_base( + rocksdb_options_t*, uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_max_bytes_for_level_base(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_level_compaction_dynamic_level_bytes(rocksdb_options_t*, + unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_level_compaction_dynamic_level_bytes(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_max_bytes_for_level_multiplier(rocksdb_options_t*, double); +extern ROCKSDB_LIBRARY_API double +rocksdb_options_get_max_bytes_for_level_multiplier(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_max_bytes_for_level_multiplier_additional( + rocksdb_options_t*, int* level_values, size_t num_levels); +extern ROCKSDB_LIBRARY_API void rocksdb_options_enable_statistics( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_ttl(rocksdb_options_t*, + uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_options_get_ttl(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_periodic_compaction_seconds( + rocksdb_options_t*, uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_periodic_compaction_seconds(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_op_scan_flush_trigger(rocksdb_options_t*, + uint32_t); +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_memtable_op_scan_flush_trigger(rocksdb_options_t*); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_avg_op_scan_flush_trigger(rocksdb_options_t*, + uint32_t); +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_memtable_avg_op_scan_flush_trigger(rocksdb_options_t*); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_min_tombstones_for_range_conversion(rocksdb_options_t*, + uint32_t); +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_min_tombstones_for_range_conversion(rocksdb_options_t*); + +enum { + rocksdb_statistics_level_disable_all = 0, + rocksdb_statistics_level_except_tickers = + rocksdb_statistics_level_disable_all, + rocksdb_statistics_level_except_histogram_or_timers = 1, + rocksdb_statistics_level_except_timers = 2, + rocksdb_statistics_level_except_detailed_timers = 3, + rocksdb_statistics_level_except_time_for_mutex = 4, + rocksdb_statistics_level_all = 5, +}; + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_statistics_level( + rocksdb_options_t*, int level); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_statistics_level( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_skip_stats_update_on_db_open(rocksdb_options_t* opt, + unsigned char val); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_skip_stats_update_on_db_open(rocksdb_options_t* opt); +/* Blob Options Settings */ +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_enable_blob_files( + rocksdb_options_t* opt, unsigned char val); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_enable_blob_files( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_min_blob_size( + rocksdb_options_t* opt, uint64_t val); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_min_blob_size(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_blob_file_size( + rocksdb_options_t* opt, uint64_t val); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_blob_file_size(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_blob_compression_type( + rocksdb_options_t* opt, int val); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_blob_compression_type( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_enable_blob_gc( + rocksdb_options_t* opt, unsigned char val); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_enable_blob_gc( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_blob_gc_age_cutoff( + rocksdb_options_t* opt, double val); +extern ROCKSDB_LIBRARY_API double rocksdb_options_get_blob_gc_age_cutoff( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_blob_gc_force_threshold( + rocksdb_options_t* opt, double val); +extern ROCKSDB_LIBRARY_API double rocksdb_options_get_blob_gc_force_threshold( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_read_triggered_compaction_threshold(rocksdb_options_t* opt, + double val); +extern ROCKSDB_LIBRARY_API double +rocksdb_options_get_read_triggered_compaction_threshold(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_max_compaction_trigger_wakeup_seconds( + rocksdb_options_t* opt, uint64_t val); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_max_compaction_trigger_wakeup_seconds( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_blob_compaction_readahead_size(rocksdb_options_t* opt, + uint64_t val); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_blob_compaction_readahead_size(rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_blob_file_starting_level( + rocksdb_options_t* opt, int val); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_blob_file_starting_level( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_blob_cache( + rocksdb_options_t* opt, rocksdb_cache_t* blob_cache); + +enum { + rocksdb_prepopulate_blob_disable = 0, + rocksdb_prepopulate_blob_flush_only = 1 +}; + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_prepopulate_blob_cache( + rocksdb_options_t* opt, int val); + +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_prepopulate_blob_cache( + rocksdb_options_t* opt); + +/* returns a pointer to a malloc()-ed, null terminated string */ +extern ROCKSDB_LIBRARY_API char* rocksdb_options_statistics_get_string( + rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_options_statistics_get_ticker_count( + rocksdb_options_t* opt, uint32_t ticker_type); +extern ROCKSDB_LIBRARY_API void rocksdb_options_statistics_get_histogram_data( + rocksdb_options_t* opt, uint32_t histogram_type, + rocksdb_statistics_histogram_data_t* const data); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_write_buffer_number( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_max_write_buffer_number( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_min_write_buffer_number_to_merge(rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int +rocksdb_options_get_min_write_buffer_number_to_merge(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_max_write_buffer_size_to_maintain(rocksdb_options_t*, + int64_t); +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_options_get_max_write_buffer_size_to_maintain(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_enable_pipelined_write( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_enable_pipelined_write(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_unordered_write( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_unordered_write( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_subcompactions( + rocksdb_options_t*, uint32_t); +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_max_subcompactions(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_background_jobs( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_max_background_jobs( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_background_compactions( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_max_background_compactions( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_background_flushes( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_max_background_flushes( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_log_file_size( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_max_log_file_size(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_log_file_time_to_roll( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_log_file_time_to_roll(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_keep_log_file_num( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_keep_log_file_num(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_recycle_log_file_num( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_recycle_log_file_num(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_soft_pending_compaction_bytes_limit(rocksdb_options_t* opt, + size_t v); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_soft_pending_compaction_bytes_limit(rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_hard_pending_compaction_bytes_limit(rocksdb_options_t* opt, + size_t v); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_hard_pending_compaction_bytes_limit(rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_manifest_file_size( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_max_manifest_file_size(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_table_cache_numshardbits( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_table_cache_numshardbits( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_arena_block_size( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_arena_block_size(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_use_fsync( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_use_fsync( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_db_log_dir( + rocksdb_options_t*, const char*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_wal_dir(rocksdb_options_t*, + const char*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_WAL_ttl_seconds( + rocksdb_options_t*, uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_WAL_ttl_seconds(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_WAL_size_limit_MB( + rocksdb_options_t*, uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_WAL_size_limit_MB(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_manifest_preallocation_size( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_manifest_preallocation_size(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_mmap_reads( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_allow_mmap_reads( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_allow_mmap_writes( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_allow_mmap_writes( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_use_direct_reads( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_use_direct_reads( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_use_direct_io_for_flush_and_compaction(rocksdb_options_t*, + unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_use_direct_io_for_flush_and_compaction(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_is_fd_close_on_exec( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_is_fd_close_on_exec(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_stats_dump_period_sec( + rocksdb_options_t*, unsigned int); +extern ROCKSDB_LIBRARY_API unsigned int +rocksdb_options_get_stats_dump_period_sec(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_stats_persist_period_sec( + rocksdb_options_t*, unsigned int); +extern ROCKSDB_LIBRARY_API unsigned int +rocksdb_options_get_stats_persist_period_sec(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_advise_random_on_open( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_advise_random_on_open(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_use_adaptive_mutex( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_use_adaptive_mutex( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_bytes_per_sync( + rocksdb_options_t*, uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_bytes_per_sync(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_wal_bytes_per_sync( + rocksdb_options_t*, uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_wal_bytes_per_sync(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_writable_file_max_buffer_size(rocksdb_options_t*, uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_writable_file_max_buffer_size(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t*, + unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_allow_concurrent_memtable_write(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_enable_write_thread_adaptive_yield(rocksdb_options_t*, + unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_enable_write_thread_adaptive_yield(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_max_sequential_skip_in_iterations(rocksdb_options_t*, + uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_max_sequential_skip_in_iterations(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_disable_auto_compactions( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_disable_auto_compactions(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_optimize_filters_for_hits( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_optimize_filters_for_hits(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_delete_obsolete_files_period_micros(rocksdb_options_t*, + uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_delete_obsolete_files_period_micros(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_prepare_for_bulk_load( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_memtable_vector_rep( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_prefix_bloom_size_ratio(rocksdb_options_t*, + double); +extern ROCKSDB_LIBRARY_API double +rocksdb_options_get_memtable_prefix_bloom_size_ratio(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_compaction_bytes( + rocksdb_options_t*, uint64_t); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_options_get_max_compaction_bytes(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_hash_skip_list_rep( + rocksdb_options_t*, size_t, int32_t, int32_t); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_hash_link_list_rep( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_plain_table_factory( + rocksdb_options_t*, uint32_t, int, double, size_t, size_t, char, + unsigned char, unsigned char); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_write_dbid_to_manifest(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_dbid_to_manifest( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_write_identity_file(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_identity_file( + rocksdb_options_t*, unsigned char); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_track_and_verify_wals_in_manifest(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_track_and_verify_wals_in_manifest(rocksdb_options_t*, + unsigned char); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_min_level_to_compress( + rocksdb_options_t* opt, int level); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_memtable_huge_page_size( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_memtable_huge_page_size(rocksdb_options_t*); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_successive_merges( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_max_successive_merges(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_bloom_locality( + rocksdb_options_t*, uint32_t); +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_options_get_bloom_locality(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_inplace_update_support( + rocksdb_options_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_inplace_update_support(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_inplace_update_num_locks( + rocksdb_options_t*, size_t); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_options_get_inplace_update_num_locks(rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_report_bg_io_stats( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_report_bg_io_stats( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_avoid_unnecessary_blocking_io(rocksdb_options_t*, + unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_options_get_avoid_unnecessary_blocking_io(rocksdb_options_t*); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_experimental_mempurge_threshold(rocksdb_options_t*, double); +extern ROCKSDB_LIBRARY_API double +rocksdb_options_get_experimental_mempurge_threshold(rocksdb_options_t*); + +enum { + rocksdb_tolerate_corrupted_tail_records_recovery = 0, + rocksdb_absolute_consistency_recovery = 1, + rocksdb_point_in_time_recovery = 2, + rocksdb_skip_any_corrupted_records_recovery = 3 +}; +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_wal_recovery_mode( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_wal_recovery_mode( + rocksdb_options_t*); + +enum { + rocksdb_no_compression = 0, + rocksdb_snappy_compression = 1, + rocksdb_zlib_compression = 2, + rocksdb_bz2_compression = 3, + rocksdb_lz4_compression = 4, + rocksdb_lz4hc_compression = 5, + rocksdb_xpress_compression = 6, + rocksdb_zstd_compression = 7 +}; +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compression( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_compression( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_bottommost_compression( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_bottommost_compression( + rocksdb_options_t*); + +enum { + rocksdb_level_compaction = 0, + rocksdb_universal_compaction = 1, + rocksdb_fifo_compaction = 2 +}; +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compaction_style( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_compaction_style( + rocksdb_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_universal_compaction_options( + rocksdb_options_t*, rocksdb_universal_compaction_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_fifo_compaction_options( + rocksdb_options_t* opt, rocksdb_fifo_compaction_options_t* fifo); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_ratelimiter( + rocksdb_options_t* opt, rocksdb_ratelimiter_t* limiter); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_atomic_flush( + rocksdb_options_t* opt, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_atomic_flush( + rocksdb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_row_cache( + rocksdb_options_t* opt, rocksdb_cache_t* cache); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_add_compact_on_deletion_collector_factory( + rocksdb_options_t*, size_t window_size, size_t num_dels_trigger); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_add_compact_on_deletion_collector_factory_del_ratio( + rocksdb_options_t*, size_t window_size, size_t num_dels_trigger, + double deletion_ratio); +extern ROCKSDB_LIBRARY_API void +rocksdb_options_add_compact_on_deletion_collector_factory_min_file_size( + rocksdb_options_t*, size_t window_size, size_t num_dels_trigger, + double deletion_ratio, uint64_t min_file_size); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_manual_wal_flush( + rocksdb_options_t* opt, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_manual_wal_flush( + rocksdb_options_t* opt); +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_wal_compression( + rocksdb_options_t* opt, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_wal_compression( + rocksdb_options_t* opt); + +enum { + rocksdb_k_by_compensated_size_compaction_pri = 0, + rocksdb_k_oldest_largest_seq_first_compaction_pri = 1, + rocksdb_k_oldest_smallest_seq_first_compaction_pri = 2, + rocksdb_k_min_overlapping_ratio_compaction_pri = 3, + rocksdb_k_round_robin_compaction_pri = 4 +}; +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compaction_pri( + rocksdb_options_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_options_get_compaction_pri( + rocksdb_options_t*); + +/* RateLimiter */ +extern ROCKSDB_LIBRARY_API rocksdb_ratelimiter_t* rocksdb_ratelimiter_create( + int64_t rate_bytes_per_sec, int64_t refill_period_us, int32_t fairness); +extern ROCKSDB_LIBRARY_API rocksdb_ratelimiter_t* +rocksdb_ratelimiter_create_auto_tuned(int64_t rate_bytes_per_sec, + int64_t refill_period_us, + int32_t fairness); +extern ROCKSDB_LIBRARY_API rocksdb_ratelimiter_t* +rocksdb_ratelimiter_create_with_mode(int64_t rate_bytes_per_sec, + int64_t refill_period_us, int32_t fairness, + int mode, bool auto_tuned); +extern ROCKSDB_LIBRARY_API void rocksdb_ratelimiter_destroy( + rocksdb_ratelimiter_t*); + +/* PerfContext */ +enum { + rocksdb_uninitialized = 0, + rocksdb_disable = 1, + rocksdb_enable_count = 2, + rocksdb_enable_time_except_for_mutex = 3, + rocksdb_enable_time = 4, + rocksdb_out_of_bounds = 5 +}; + +enum { + rocksdb_user_key_comparison_count = 0, + rocksdb_block_cache_hit_count, + rocksdb_block_read_count, + rocksdb_block_read_byte, + rocksdb_block_read_time, + rocksdb_block_checksum_time, + rocksdb_block_decompress_time, + rocksdb_get_read_bytes, + rocksdb_multiget_read_bytes, + rocksdb_iter_read_bytes, + rocksdb_internal_key_skipped_count, + rocksdb_internal_delete_skipped_count, + rocksdb_internal_recent_skipped_count, + rocksdb_internal_merge_count, + rocksdb_get_snapshot_time, + rocksdb_get_from_memtable_time, + rocksdb_get_from_memtable_count, + rocksdb_get_post_process_time, + rocksdb_get_from_output_files_time, + rocksdb_seek_on_memtable_time, + rocksdb_seek_on_memtable_count, + rocksdb_next_on_memtable_count, + rocksdb_prev_on_memtable_count, + rocksdb_seek_child_seek_time, + rocksdb_seek_child_seek_count, + rocksdb_seek_min_heap_time, + rocksdb_seek_max_heap_time, + rocksdb_seek_internal_seek_time, + rocksdb_find_next_user_entry_time, + rocksdb_write_wal_time, + rocksdb_write_memtable_time, + rocksdb_write_delay_time, + rocksdb_write_pre_and_post_process_time, + rocksdb_db_mutex_lock_nanos, + rocksdb_db_condition_wait_nanos, + rocksdb_merge_operator_time_nanos, + rocksdb_read_index_block_nanos, + rocksdb_read_filter_block_nanos, + rocksdb_new_table_block_iter_nanos, + rocksdb_new_table_iterator_nanos, + rocksdb_block_seek_nanos, + rocksdb_find_table_nanos, + rocksdb_bloom_memtable_hit_count, + rocksdb_bloom_memtable_miss_count, + rocksdb_bloom_sst_hit_count, + rocksdb_bloom_sst_miss_count, + rocksdb_key_lock_wait_time, + rocksdb_key_lock_wait_count, + rocksdb_env_new_sequential_file_nanos, + rocksdb_env_new_random_access_file_nanos, + rocksdb_env_new_writable_file_nanos, + rocksdb_env_reuse_writable_file_nanos, + rocksdb_env_new_random_rw_file_nanos, + rocksdb_env_new_directory_nanos, + rocksdb_env_file_exists_nanos, + rocksdb_env_get_children_nanos, + rocksdb_env_get_children_file_attributes_nanos, + rocksdb_env_delete_file_nanos, + rocksdb_env_create_dir_nanos, + rocksdb_env_create_dir_if_missing_nanos, + rocksdb_env_delete_dir_nanos, + rocksdb_env_get_file_size_nanos, + rocksdb_env_get_file_modification_time_nanos, + rocksdb_env_rename_file_nanos, + rocksdb_env_link_file_nanos, + rocksdb_env_lock_file_nanos, + rocksdb_env_unlock_file_nanos, + rocksdb_env_new_logger_nanos, + rocksdb_number_async_seek, + rocksdb_blob_cache_hit_count, + rocksdb_blob_read_count, + rocksdb_blob_read_byte, + rocksdb_blob_read_time, + rocksdb_blob_checksum_time, + rocksdb_blob_decompress_time, + rocksdb_internal_range_del_reseek_count, + rocksdb_block_read_cpu_time, + rocksdb_internal_merge_point_lookup_count, + rocksdb_data_block_read_byte, + rocksdb_index_block_read_byte, + rocksdb_filter_block_read_byte, + rocksdb_compression_dict_block_read_byte, + rocksdb_metadata_block_read_byte, + rocksdb_blob_cache_read_byte, + rocksdb_total_metric_count = 86 +}; + +extern ROCKSDB_LIBRARY_API void rocksdb_set_perf_level(int); +extern ROCKSDB_LIBRARY_API rocksdb_perfcontext_t* rocksdb_perfcontext_create( + void); +extern ROCKSDB_LIBRARY_API void rocksdb_perfcontext_reset( + rocksdb_perfcontext_t* context); +extern ROCKSDB_LIBRARY_API char* rocksdb_perfcontext_report( + rocksdb_perfcontext_t* context, unsigned char exclude_zero_counters); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_perfcontext_metric(rocksdb_perfcontext_t* context, int metric); +extern ROCKSDB_LIBRARY_API void rocksdb_perfcontext_destroy( + rocksdb_perfcontext_t* context); + +/* Compaction Filter */ + +extern ROCKSDB_LIBRARY_API rocksdb_compactionfilter_t* +rocksdb_compactionfilter_create( + void* state, void (*destructor)(void*), + unsigned char (*filter)(void*, int level, const char* key, + size_t key_length, const char* existing_value, + size_t value_length, char** new_value, + size_t* new_value_length, + unsigned char* value_changed), + const char* (*name)(void*)); +extern ROCKSDB_LIBRARY_API void rocksdb_compactionfilter_set_ignore_snapshots( + rocksdb_compactionfilter_t*, unsigned char); +extern ROCKSDB_LIBRARY_API void rocksdb_compactionfilter_destroy( + rocksdb_compactionfilter_t*); + +/* WAL Filter */ + +enum { + rocksdb_wal_filter_continue_processing = 0, + rocksdb_wal_filter_ignore_current_record = 1, + rocksdb_wal_filter_stop_replay = 2, + rocksdb_wal_filter_corrupted_record = 3, +}; + +extern ROCKSDB_LIBRARY_API rocksdb_walfilter_t* rocksdb_walfilter_create( + void* state, void (*destructor)(void*), + rocksdb_walfilter_column_family_log_number_map_cb + column_family_log_number_map, + rocksdb_walfilter_log_record_found_cb log_record_found, + const char* (*name)(void*)); +extern ROCKSDB_LIBRARY_API void rocksdb_walfilter_destroy(rocksdb_walfilter_t*); + +/* Compaction Filter Context */ + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compactionfiltercontext_is_full_compaction( + rocksdb_compactionfiltercontext_t* context); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compactionfiltercontext_is_manual_compaction( + rocksdb_compactionfiltercontext_t* context); + +/* Compaction Filter Factory */ + +extern ROCKSDB_LIBRARY_API rocksdb_compactionfilterfactory_t* +rocksdb_compactionfilterfactory_create( + void* state, void (*destructor)(void*), + rocksdb_compactionfilter_t* (*create_compaction_filter)( + void*, rocksdb_compactionfiltercontext_t* context), + const char* (*name)(void*)); +extern ROCKSDB_LIBRARY_API void rocksdb_compactionfilterfactory_destroy( + rocksdb_compactionfilterfactory_t*); + +/* Comparator */ + +extern ROCKSDB_LIBRARY_API rocksdb_comparator_t* rocksdb_comparator_create( + void* state, void (*destructor)(void*), + int (*compare)(void*, const char* a, size_t alen, const char* b, + size_t blen), + const char* (*name)(void*)); +extern ROCKSDB_LIBRARY_API void rocksdb_comparator_destroy( + rocksdb_comparator_t*); + +extern ROCKSDB_LIBRARY_API rocksdb_comparator_t* +rocksdb_comparator_with_ts_create( + void* state, void (*destructor)(void*), + int (*compare)(void*, const char* a, size_t alen, const char* b, + size_t blen), + int (*compare_ts)(void*, const char* a_ts, size_t a_tslen, const char* b_ts, + size_t b_tslen), + int (*compare_without_ts)(void*, const char* a, size_t alen, + unsigned char a_has_ts, const char* b, + size_t blen, unsigned char b_has_ts), + const char* (*name)(void*), size_t timestamp_size); + +/* Filter policy */ + +extern ROCKSDB_LIBRARY_API void rocksdb_filterpolicy_destroy( + rocksdb_filterpolicy_t*); + +extern ROCKSDB_LIBRARY_API rocksdb_filterpolicy_t* +rocksdb_filterpolicy_create_bloom(double bits_per_key); +extern ROCKSDB_LIBRARY_API rocksdb_filterpolicy_t* +rocksdb_filterpolicy_create_bloom_full(double bits_per_key); +extern ROCKSDB_LIBRARY_API rocksdb_filterpolicy_t* +rocksdb_filterpolicy_create_ribbon(double bloom_equivalent_bits_per_key); +extern ROCKSDB_LIBRARY_API rocksdb_filterpolicy_t* +rocksdb_filterpolicy_create_ribbon_hybrid(double bloom_equivalent_bits_per_key, + int bloom_before_level); + +/* Merge Operator */ + +extern ROCKSDB_LIBRARY_API rocksdb_mergeoperator_t* +rocksdb_mergeoperator_create( + void* state, void (*destructor)(void*), + char* (*full_merge)(void*, const char* key, size_t key_length, + const char* existing_value, + size_t existing_value_length, + const char* const* operands_list, + const size_t* operands_list_length, int num_operands, + unsigned char* success, size_t* new_value_length), + char* (*partial_merge)(void*, const char* key, size_t key_length, + const char* const* operands_list, + const size_t* operands_list_length, int num_operands, + unsigned char* success, size_t* new_value_length), + void (*delete_value)(void*, const char* value, size_t value_length), + const char* (*name)(void*)); +extern ROCKSDB_LIBRARY_API void rocksdb_mergeoperator_destroy( + rocksdb_mergeoperator_t*); + +/* Read options */ + +extern ROCKSDB_LIBRARY_API rocksdb_readoptions_t* rocksdb_readoptions_create( + void); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_destroy( + rocksdb_readoptions_t*); +#include "c_api_gen/c_generated_readoptions_auto.h.inc" +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_snapshot( + rocksdb_readoptions_t*, const rocksdb_snapshot_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_iterate_upper_bound( + rocksdb_readoptions_t*, const char* key, size_t keylen); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_iterate_lower_bound( + rocksdb_readoptions_t*, const char* key, size_t keylen); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_timestamp( + rocksdb_readoptions_t*, const char* ts, size_t tslen); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_iter_start_ts( + rocksdb_readoptions_t*, const char* ts, size_t tslen); +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_merge_operand_count_threshold(rocksdb_readoptions_t*, + size_t threshold); +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_clear_merge_operand_count_threshold(rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_readoptions_has_merge_operand_count_threshold(rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_readoptions_get_merge_operand_count_threshold(rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_request_id( + rocksdb_readoptions_t*, const char* request_id, size_t request_id_len); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_clear_request_id( + rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API const char* rocksdb_readoptions_get_request_id( + rocksdb_readoptions_t*, size_t* request_id_len); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_table_filter( + rocksdb_readoptions_t*, void* state, void (*destructor)(void*), + rocksdb_readoptions_table_filter_cb table_filter); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_clear_table_filter( + rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_has_table_filter( + const rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_readoptions_set_table_index_factory_from_string(rocksdb_readoptions_t*, + const char* value, + size_t value_len, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_clear_table_index_factory( + rocksdb_readoptions_t*); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_readoptions_get_table_index_factory_name(const rocksdb_readoptions_t*, + size_t* name_len); + +/* Write options */ + +extern ROCKSDB_LIBRARY_API rocksdb_writeoptions_t* rocksdb_writeoptions_create( + void); +extern ROCKSDB_LIBRARY_API void rocksdb_writeoptions_destroy( + rocksdb_writeoptions_t*); + +/* Compact range options */ + +extern ROCKSDB_LIBRARY_API rocksdb_compaction_options_t* +rocksdb_compaction_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_compaction_options_destroy( + rocksdb_compaction_options_t*); +extern ROCKSDB_LIBRARY_API unsigned char* +rocksdb_compaction_options_canceled_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_compaction_options_canceled_destroy( + unsigned char* canceled); +extern ROCKSDB_LIBRARY_API void rocksdb_compaction_options_canceled_set( + unsigned char* canceled, unsigned char value); +extern ROCKSDB_LIBRARY_API void rocksdb_compaction_options_set_canceled( + rocksdb_compaction_options_t* options, unsigned char* canceled); + +extern ROCKSDB_LIBRARY_API rocksdb_compactoptions_t* +rocksdb_compactoptions_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_destroy( + rocksdb_compactoptions_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_compactoptions_set_exclusive_manual_compaction( + rocksdb_compactoptions_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compactoptions_get_exclusive_manual_compaction( + rocksdb_compactoptions_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_compactoptions_set_bottommost_level_compaction( + rocksdb_compactoptions_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compactoptions_get_bottommost_level_compaction( + rocksdb_compactoptions_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_set_change_level( + rocksdb_compactoptions_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compactoptions_get_change_level(rocksdb_compactoptions_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_set_target_level( + rocksdb_compactoptions_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_compactoptions_get_target_level( + rocksdb_compactoptions_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_set_target_path_id( + rocksdb_compactoptions_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_compactoptions_get_target_path_id( + rocksdb_compactoptions_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_set_allow_write_stall( + rocksdb_compactoptions_t*, unsigned char); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compactoptions_get_allow_write_stall(rocksdb_compactoptions_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_set_max_subcompactions( + rocksdb_compactoptions_t*, int); +extern ROCKSDB_LIBRARY_API int rocksdb_compactoptions_get_max_subcompactions( + rocksdb_compactoptions_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_compactoptions_set_full_history_ts_low( + rocksdb_compactoptions_t*, char* ts, size_t tslen); + +/* Flush options */ + +extern ROCKSDB_LIBRARY_API rocksdb_flushoptions_t* rocksdb_flushoptions_create( + void); +extern ROCKSDB_LIBRARY_API void rocksdb_flushoptions_destroy( + rocksdb_flushoptions_t*); +extern ROCKSDB_LIBRARY_API rocksdb_flushwaloptions_t* +rocksdb_flushwaloptions_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_flushwaloptions_destroy( + rocksdb_flushwaloptions_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_flush_wal_with_options( + rocksdb_t* db, const rocksdb_flushwaloptions_t* options, char** errptr); + +/* Memory allocator */ + +extern ROCKSDB_LIBRARY_API rocksdb_memory_allocator_t* +rocksdb_jemalloc_nodump_allocator_create(char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_memory_allocator_destroy( + rocksdb_memory_allocator_t*); + +/* Cache */ + +extern ROCKSDB_LIBRARY_API rocksdb_lru_cache_options_t* +rocksdb_lru_cache_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_lru_cache_options_destroy( + rocksdb_lru_cache_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_lru_cache_options_set_capacity( + rocksdb_lru_cache_options_t*, size_t); +extern ROCKSDB_LIBRARY_API void rocksdb_lru_cache_options_set_num_shard_bits( + rocksdb_lru_cache_options_t*, int); +extern ROCKSDB_LIBRARY_API void rocksdb_lru_cache_options_set_memory_allocator( + rocksdb_lru_cache_options_t*, rocksdb_memory_allocator_t*); + +extern ROCKSDB_LIBRARY_API rocksdb_cache_t* rocksdb_cache_create_lru( + size_t capacity); +extern ROCKSDB_LIBRARY_API rocksdb_cache_t* +rocksdb_cache_create_lru_with_strict_capacity_limit(size_t capacity); +extern ROCKSDB_LIBRARY_API rocksdb_cache_t* rocksdb_cache_create_lru_opts( + const rocksdb_lru_cache_options_t*); + +extern ROCKSDB_LIBRARY_API void rocksdb_cache_destroy(rocksdb_cache_t* cache); +extern ROCKSDB_LIBRARY_API void rocksdb_cache_disown_data( + rocksdb_cache_t* cache); +extern ROCKSDB_LIBRARY_API void rocksdb_cache_set_capacity( + rocksdb_cache_t* cache, size_t capacity); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_cache_get_capacity(const rocksdb_cache_t* cache); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_cache_get_usage(const rocksdb_cache_t* cache); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_cache_get_pinned_usage(const rocksdb_cache_t* cache); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_cache_get_table_address_count(const rocksdb_cache_t* cache); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_cache_get_occupancy_count(const rocksdb_cache_t* cache); + +/* WriteBufferManager */ + +extern ROCKSDB_LIBRARY_API rocksdb_write_buffer_manager_t* +rocksdb_write_buffer_manager_create(size_t buffer_size, bool allow_stall); +extern ROCKSDB_LIBRARY_API rocksdb_write_buffer_manager_t* +rocksdb_write_buffer_manager_create_with_cache(size_t buffer_size, + const rocksdb_cache_t* cache, + bool allow_stall); + +extern ROCKSDB_LIBRARY_API void rocksdb_write_buffer_manager_destroy( + rocksdb_write_buffer_manager_t* wbm); +extern ROCKSDB_LIBRARY_API bool rocksdb_write_buffer_manager_enabled( + rocksdb_write_buffer_manager_t* wbm); +extern ROCKSDB_LIBRARY_API bool rocksdb_write_buffer_manager_cost_to_cache( + rocksdb_write_buffer_manager_t* wbm); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_write_buffer_manager_memory_usage(rocksdb_write_buffer_manager_t* wbm); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_write_buffer_manager_mutable_memtable_memory_usage( + rocksdb_write_buffer_manager_t* wbm); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_write_buffer_manager_dummy_entries_in_cache_usage( + rocksdb_write_buffer_manager_t* wbm); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_write_buffer_manager_buffer_size(rocksdb_write_buffer_manager_t* wbm); +extern ROCKSDB_LIBRARY_API void rocksdb_write_buffer_manager_set_buffer_size( + rocksdb_write_buffer_manager_t* wbm, size_t new_size); +extern ROCKSDB_LIBRARY_API void rocksdb_write_buffer_manager_set_allow_stall( + rocksdb_write_buffer_manager_t* wbm, bool new_allow_stall); + +/* SstFileManager */ + +extern ROCKSDB_LIBRARY_API rocksdb_sst_file_manager_t* +rocksdb_sst_file_manager_create(rocksdb_env_t* env); + +extern ROCKSDB_LIBRARY_API void rocksdb_sst_file_manager_destroy( + rocksdb_sst_file_manager_t* sfm); + +extern ROCKSDB_LIBRARY_API void +rocksdb_sst_file_manager_set_max_allowed_space_usage( + rocksdb_sst_file_manager_t* sfm, uint64_t max_allowed_space); + +extern ROCKSDB_LIBRARY_API void +rocksdb_sst_file_manager_set_compaction_buffer_size( + rocksdb_sst_file_manager_t* sfm, uint64_t compaction_buffer_size); + +extern ROCKSDB_LIBRARY_API bool +rocksdb_sst_file_manager_is_max_allowed_space_reached( + rocksdb_sst_file_manager_t* sfm); + +extern ROCKSDB_LIBRARY_API bool +rocksdb_sst_file_manager_is_max_allowed_space_reached_including_compactions( + rocksdb_sst_file_manager_t* sfm); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_sst_file_manager_get_total_size(rocksdb_sst_file_manager_t* sfm); + +extern ROCKSDB_LIBRARY_API int64_t +rocksdb_sst_file_manager_get_delete_rate_bytes_per_second( + rocksdb_sst_file_manager_t* sfm); + +extern ROCKSDB_LIBRARY_API void +rocksdb_sst_file_manager_set_delete_rate_bytes_per_second( + rocksdb_sst_file_manager_t* sfm, int64_t delete_rate); + +extern ROCKSDB_LIBRARY_API double +rocksdb_sst_file_manager_get_max_trash_db_ratio( + rocksdb_sst_file_manager_t* sfm); + +extern ROCKSDB_LIBRARY_API void rocksdb_sst_file_manager_set_max_trash_db_ratio( + rocksdb_sst_file_manager_t* sfm, double ratio); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_sst_file_manager_get_total_trash_size(rocksdb_sst_file_manager_t* sfm); + +/* HyperClockCache */ + +extern ROCKSDB_LIBRARY_API rocksdb_hyper_clock_cache_options_t* +rocksdb_hyper_clock_cache_options_create(size_t capacity, + size_t estimated_entry_charge); +extern ROCKSDB_LIBRARY_API void rocksdb_hyper_clock_cache_options_destroy( + rocksdb_hyper_clock_cache_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_hyper_clock_cache_options_set_capacity( + rocksdb_hyper_clock_cache_options_t*, size_t); +extern ROCKSDB_LIBRARY_API void +rocksdb_hyper_clock_cache_options_set_estimated_entry_charge( + rocksdb_hyper_clock_cache_options_t*, size_t); +extern ROCKSDB_LIBRARY_API void +rocksdb_hyper_clock_cache_options_set_num_shard_bits( + rocksdb_hyper_clock_cache_options_t*, int); +extern ROCKSDB_LIBRARY_API void +rocksdb_hyper_clock_cache_options_set_memory_allocator( + rocksdb_hyper_clock_cache_options_t*, rocksdb_memory_allocator_t*); + +extern ROCKSDB_LIBRARY_API rocksdb_cache_t* rocksdb_cache_create_hyper_clock( + size_t capacity, size_t estimated_entry_charge); +extern ROCKSDB_LIBRARY_API rocksdb_cache_t* +rocksdb_cache_create_hyper_clock_opts( + const rocksdb_hyper_clock_cache_options_t*); + +/* DBPath */ + +extern ROCKSDB_LIBRARY_API rocksdb_dbpath_t* rocksdb_dbpath_create( + const char* path, uint64_t target_size); +extern ROCKSDB_LIBRARY_API void rocksdb_dbpath_destroy(rocksdb_dbpath_t*); + +/* Env */ + +extern ROCKSDB_LIBRARY_API rocksdb_env_t* rocksdb_create_default_env(void); +extern ROCKSDB_LIBRARY_API rocksdb_env_t* rocksdb_create_mem_env(void); +extern ROCKSDB_LIBRARY_API void rocksdb_env_set_background_threads( + rocksdb_env_t* env, int n); +extern ROCKSDB_LIBRARY_API int rocksdb_env_get_background_threads( + rocksdb_env_t* env); +extern ROCKSDB_LIBRARY_API void +rocksdb_env_set_high_priority_background_threads(rocksdb_env_t* env, int n); +extern ROCKSDB_LIBRARY_API int rocksdb_env_get_high_priority_background_threads( + rocksdb_env_t* env); +extern ROCKSDB_LIBRARY_API void rocksdb_env_set_low_priority_background_threads( + rocksdb_env_t* env, int n); +extern ROCKSDB_LIBRARY_API int rocksdb_env_get_low_priority_background_threads( + rocksdb_env_t* env); +extern ROCKSDB_LIBRARY_API void +rocksdb_env_set_bottom_priority_background_threads(rocksdb_env_t* env, int n); +extern ROCKSDB_LIBRARY_API int +rocksdb_env_get_bottom_priority_background_threads(rocksdb_env_t* env); +extern ROCKSDB_LIBRARY_API void rocksdb_env_join_all_threads( + rocksdb_env_t* env); +extern ROCKSDB_LIBRARY_API void rocksdb_env_lower_thread_pool_io_priority( + rocksdb_env_t* env); +extern ROCKSDB_LIBRARY_API void +rocksdb_env_lower_high_priority_thread_pool_io_priority(rocksdb_env_t* env); +extern ROCKSDB_LIBRARY_API void rocksdb_env_lower_thread_pool_cpu_priority( + rocksdb_env_t* env); +extern ROCKSDB_LIBRARY_API void +rocksdb_env_lower_high_priority_thread_pool_cpu_priority(rocksdb_env_t* env); + +extern ROCKSDB_LIBRARY_API void rocksdb_env_destroy(rocksdb_env_t*); + +extern ROCKSDB_LIBRARY_API rocksdb_envoptions_t* rocksdb_envoptions_create( + void); +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_destroy( + rocksdb_envoptions_t* opt); +extern ROCKSDB_LIBRARY_API void rocksdb_envoptions_set_rate_limiter( + rocksdb_envoptions_t* opt, rocksdb_ratelimiter_t* rate_limiter); +extern ROCKSDB_LIBRARY_API void rocksdb_create_dir_if_missing( + rocksdb_env_t* env, const char* path, char** errptr); + +/* Tracing */ + +extern ROCKSDB_LIBRARY_API rocksdb_trace_options_t* +rocksdb_trace_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_trace_options_destroy( + rocksdb_trace_options_t* options); +extern ROCKSDB_LIBRARY_API rocksdb_trace_reader_t* rocksdb_trace_reader_create( + rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const char* trace_path, char** errptr); +extern ROCKSDB_LIBRARY_API char* rocksdb_trace_reader_read( + rocksdb_trace_reader_t* reader, size_t* size, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_trace_reader_reset( + rocksdb_trace_reader_t* reader, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_trace_reader_close( + rocksdb_trace_reader_t* reader, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_trace_reader_destroy( + rocksdb_trace_reader_t* reader); +extern ROCKSDB_LIBRARY_API rocksdb_replay_options_t* +rocksdb_replay_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_replay_options_destroy( + rocksdb_replay_options_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_replay_options_set_num_threads( + rocksdb_replay_options_t* options, uint32_t num_threads); +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_replay_options_get_num_threads(rocksdb_replay_options_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_replay_options_set_fast_forward( + rocksdb_replay_options_t* options, double fast_forward); +extern ROCKSDB_LIBRARY_API double rocksdb_replay_options_get_fast_forward( + rocksdb_replay_options_t* options); +extern ROCKSDB_LIBRARY_API rocksdb_replayer_t* rocksdb_new_default_replayer( + rocksdb_t* db, rocksdb_column_family_handle_t** column_families, + size_t num_column_families, rocksdb_env_t* env, + const rocksdb_envoptions_t* env_options, const char* trace_path, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_replayer_prepare( + rocksdb_replayer_t* replayer, char** errptr); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_replayer_get_header_timestamp(const rocksdb_replayer_t* replayer); +extern ROCKSDB_LIBRARY_API void rocksdb_replayer_replay( + rocksdb_replayer_t* replayer, const rocksdb_replay_options_t* options, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_replayer_destroy( + rocksdb_replayer_t* replayer); +enum { + rocksdb_trace_filter_none = 0x0, + rocksdb_trace_filter_get = 0x1 << 0, + rocksdb_trace_filter_write = 0x1 << 1, + rocksdb_trace_filter_iterator_seek = 0x1 << 2, + rocksdb_trace_filter_iterator_seek_for_prev = 0x1 << 3, + rocksdb_trace_filter_multi_get = 0x1 << 4, +}; +extern ROCKSDB_LIBRARY_API rocksdb_block_cache_trace_options_t* +rocksdb_block_cache_trace_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_block_cache_trace_options_destroy( + rocksdb_block_cache_trace_options_t* options); +extern ROCKSDB_LIBRARY_API rocksdb_block_cache_trace_writer_options_t* +rocksdb_block_cache_trace_writer_options_create(void); +extern ROCKSDB_LIBRARY_API void +rocksdb_block_cache_trace_writer_options_destroy( + rocksdb_block_cache_trace_writer_options_t* options); +extern ROCKSDB_LIBRARY_API void rocksdb_start_trace( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, const char* trace_path, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_end_trace(rocksdb_t* db, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_start_io_trace( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, const char* trace_path, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_end_io_trace(rocksdb_t* db, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_start_block_cache_trace( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const rocksdb_trace_options_t* options, const char* trace_path, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_start_block_cache_trace_with_options( + rocksdb_t* db, rocksdb_env_t* env, const rocksdb_envoptions_t* env_options, + const rocksdb_block_cache_trace_options_t* options, + const rocksdb_block_cache_trace_writer_options_t* writer_options, + const char* trace_path, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_end_block_cache_trace(rocksdb_t* db, + char** errptr); + +/* SstFile */ + +extern ROCKSDB_LIBRARY_API rocksdb_sstfilewriter_t* +rocksdb_sstfilewriter_create(const rocksdb_envoptions_t* env, + const rocksdb_options_t* io_options); +extern ROCKSDB_LIBRARY_API rocksdb_sstfilewriter_t* +rocksdb_sstfilewriter_create_with_comparator( + const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options, + const rocksdb_comparator_t* comparator); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_open( + rocksdb_sstfilewriter_t* writer, const char* name, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_add( + rocksdb_sstfilewriter_t* writer, const char* key, size_t keylen, + const char* val, size_t vallen, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_put( + rocksdb_sstfilewriter_t* writer, const char* key, size_t keylen, + const char* val, size_t vallen, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_put_with_ts( + rocksdb_sstfilewriter_t* writer, const char* key, size_t keylen, + const char* ts, size_t tslen, const char* val, size_t vallen, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_merge( + rocksdb_sstfilewriter_t* writer, const char* key, size_t keylen, + const char* val, size_t vallen, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_delete( + rocksdb_sstfilewriter_t* writer, const char* key, size_t keylen, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_delete_with_ts( + rocksdb_sstfilewriter_t* writer, const char* key, size_t keylen, + const char* ts, size_t tslen, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_delete_range( + rocksdb_sstfilewriter_t* writer, const char* begin_key, size_t begin_keylen, + const char* end_key, size_t end_keylen, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_finish( + rocksdb_sstfilewriter_t* writer, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_file_size( + rocksdb_sstfilewriter_t* writer, uint64_t* file_size); +extern ROCKSDB_LIBRARY_API void rocksdb_sstfilewriter_destroy( + rocksdb_sstfilewriter_t* writer); +extern ROCKSDB_LIBRARY_API rocksdb_ingestexternalfileoptions_t* +rocksdb_ingestexternalfileoptions_create(void); +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_move_files( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char move_files); +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_snapshot_consistency( + rocksdb_ingestexternalfileoptions_t* opt, + unsigned char snapshot_consistency); +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_allow_global_seqno( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char allow_global_seqno); +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_allow_blocking_flush( + rocksdb_ingestexternalfileoptions_t* opt, + unsigned char allow_blocking_flush); +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_ingest_behind( + rocksdb_ingestexternalfileoptions_t* opt, unsigned char ingest_behind); +extern ROCKSDB_LIBRARY_API void +rocksdb_ingestexternalfileoptions_set_fail_if_not_bottommost_level( + rocksdb_ingestexternalfileoptions_t* opt, + unsigned char fail_if_not_bottommost_level); + +extern ROCKSDB_LIBRARY_API void rocksdb_ingestexternalfileoptions_destroy( + rocksdb_ingestexternalfileoptions_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_ingest_external_file( + rocksdb_t* db, const char* const* file_list, const size_t list_len, + const rocksdb_ingestexternalfileoptions_t* opt, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_ingest_external_file_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* handle, + const char* const* file_list, const size_t list_len, + const rocksdb_ingestexternalfileoptions_t* opt, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_try_catch_up_with_primary( + rocksdb_t* db, char** errptr); + +/* SliceTransform */ + +extern ROCKSDB_LIBRARY_API rocksdb_slicetransform_t* +rocksdb_slicetransform_create(void* state, void (*destructor)(void*), + char* (*transform)(void*, const char* key, + size_t length, + size_t* dst_length), + unsigned char (*in_domain)(void*, const char* key, + size_t length), + const char* (*name)(void*)); +extern ROCKSDB_LIBRARY_API rocksdb_slicetransform_t* +rocksdb_slicetransform_create_fixed_prefix(size_t); +extern ROCKSDB_LIBRARY_API rocksdb_slicetransform_t* +rocksdb_slicetransform_create_noop(void); +extern ROCKSDB_LIBRARY_API void rocksdb_slicetransform_destroy( + rocksdb_slicetransform_t*); + +/* Universal Compaction options */ + +enum { + rocksdb_similar_size_compaction_stop_style = 0, + rocksdb_total_size_compaction_stop_style = 1 +}; + +extern ROCKSDB_LIBRARY_API rocksdb_universal_compaction_options_t* +rocksdb_universal_compaction_options_create(void); +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_size_ratio( + rocksdb_universal_compaction_options_t*, int); +extern ROCKSDB_LIBRARY_API int +rocksdb_universal_compaction_options_get_size_ratio( + rocksdb_universal_compaction_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_min_merge_width( + rocksdb_universal_compaction_options_t*, int); +extern ROCKSDB_LIBRARY_API int +rocksdb_universal_compaction_options_get_min_merge_width( + rocksdb_universal_compaction_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_max_merge_width( + rocksdb_universal_compaction_options_t*, int); +extern ROCKSDB_LIBRARY_API int +rocksdb_universal_compaction_options_get_max_merge_width( + rocksdb_universal_compaction_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_max_size_amplification_percent( + rocksdb_universal_compaction_options_t*, int); +extern ROCKSDB_LIBRARY_API int +rocksdb_universal_compaction_options_get_max_size_amplification_percent( + rocksdb_universal_compaction_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_compression_size_percent( + rocksdb_universal_compaction_options_t*, int); +extern ROCKSDB_LIBRARY_API int +rocksdb_universal_compaction_options_get_compression_size_percent( + rocksdb_universal_compaction_options_t*); +extern ROCKSDB_LIBRARY_API void +rocksdb_universal_compaction_options_set_stop_style( + rocksdb_universal_compaction_options_t*, int); +extern ROCKSDB_LIBRARY_API int +rocksdb_universal_compaction_options_get_stop_style( + rocksdb_universal_compaction_options_t*); +extern ROCKSDB_LIBRARY_API void rocksdb_universal_compaction_options_destroy( + rocksdb_universal_compaction_options_t*); + +extern ROCKSDB_LIBRARY_API rocksdb_fifo_compaction_options_t* +rocksdb_fifo_compaction_options_create(void); +extern ROCKSDB_LIBRARY_API void +rocksdb_fifo_compaction_options_set_allow_compaction( + rocksdb_fifo_compaction_options_t* fifo_opts, + unsigned char allow_compaction); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_fifo_compaction_options_get_allow_compaction( + rocksdb_fifo_compaction_options_t* fifo_opts); +extern ROCKSDB_LIBRARY_API void +rocksdb_fifo_compaction_options_set_max_table_files_size( + rocksdb_fifo_compaction_options_t* fifo_opts, uint64_t size); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_fifo_compaction_options_get_max_table_files_size( + rocksdb_fifo_compaction_options_t* fifo_opts); +extern ROCKSDB_LIBRARY_API void +rocksdb_fifo_compaction_options_set_max_data_files_size( + rocksdb_fifo_compaction_options_t* fifo_opts, uint64_t size); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_fifo_compaction_options_get_max_data_files_size( + rocksdb_fifo_compaction_options_t* fifo_opts); +extern ROCKSDB_LIBRARY_API void +rocksdb_fifo_compaction_options_set_use_kv_ratio_compaction( + rocksdb_fifo_compaction_options_t* fifo_opts, + unsigned char use_kv_ratio_compaction); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_fifo_compaction_options_get_use_kv_ratio_compaction( + rocksdb_fifo_compaction_options_t* fifo_opts); +extern ROCKSDB_LIBRARY_API void rocksdb_fifo_compaction_options_destroy( + rocksdb_fifo_compaction_options_t* fifo_opts); + +extern ROCKSDB_LIBRARY_API rocksdb_livefiles_t* rocksdb_livefiles_create(void); + +extern ROCKSDB_LIBRARY_API int rocksdb_livefiles_count( + const rocksdb_livefiles_t*); +extern ROCKSDB_LIBRARY_API const char* rocksdb_livefiles_column_family_name( + const rocksdb_livefiles_t*, int index); +extern ROCKSDB_LIBRARY_API const char* rocksdb_livefiles_name( + const rocksdb_livefiles_t*, int index); +extern ROCKSDB_LIBRARY_API const char* rocksdb_livefiles_directory( + const rocksdb_livefiles_t*, int index); +extern ROCKSDB_LIBRARY_API int rocksdb_livefiles_level( + const rocksdb_livefiles_t*, int index); +extern ROCKSDB_LIBRARY_API size_t +rocksdb_livefiles_size(const rocksdb_livefiles_t*, int index); +extern ROCKSDB_LIBRARY_API const char* rocksdb_livefiles_smallestkey( + const rocksdb_livefiles_t*, int index, size_t* size); +extern ROCKSDB_LIBRARY_API const char* rocksdb_livefiles_largestkey( + const rocksdb_livefiles_t*, int index, size_t* size); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_livefiles_smallest_seqno(const rocksdb_livefiles_t*, int index); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_livefiles_largest_seqno(const rocksdb_livefiles_t*, int index); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_livefiles_entries(const rocksdb_livefiles_t*, int index); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_livefiles_deletions(const rocksdb_livefiles_t*, int index); +extern ROCKSDB_LIBRARY_API void rocksdb_livefiles_destroy( + const rocksdb_livefiles_t*); + +extern ROCKSDB_LIBRARY_API rocksdb_livefiles_storage_info_options_t* +rocksdb_livefiles_storage_info_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_livefiles_storage_info_options_destroy( + rocksdb_livefiles_storage_info_options_t* options); +extern ROCKSDB_LIBRARY_API rocksdb_livefiles_storage_info_t* +rocksdb_get_livefiles_storage_info( + rocksdb_t* db, const rocksdb_livefiles_storage_info_options_t* options, + char** errptr); +extern ROCKSDB_LIBRARY_API size_t rocksdb_livefiles_storage_info_count( + const rocksdb_livefiles_storage_info_t* info); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_livefiles_storage_info_relative_filename( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API const char* rocksdb_livefiles_storage_info_directory( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_livefiles_storage_info_file_number( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API int rocksdb_livefiles_storage_info_file_type( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_livefiles_storage_info_size( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API int rocksdb_livefiles_storage_info_temperature( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_livefiles_storage_info_file_checksum( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_livefiles_storage_info_file_checksum_func_name( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_livefiles_storage_info_replacement_contents( + const rocksdb_livefiles_storage_info_t* info, size_t index, size_t* size); +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_livefiles_storage_info_trim_to_size( + const rocksdb_livefiles_storage_info_t* info, size_t index); +extern ROCKSDB_LIBRARY_API void rocksdb_livefiles_storage_info_destroy( + rocksdb_livefiles_storage_info_t* info); + +extern ROCKSDB_LIBRARY_API rocksdb_livefile_t* rocksdb_livefile_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_column_family_name( + rocksdb_livefile_t*, const char*); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_level(rocksdb_livefile_t*, + int); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_name(rocksdb_livefile_t*, + const char*); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_directory( + rocksdb_livefile_t*, const char*); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_size(rocksdb_livefile_t*, + size_t); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_smallest_key( + rocksdb_livefile_t*, const char*, size_t); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_largest_key( + rocksdb_livefile_t*, const char*, size_t); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_smallest_seqno( + rocksdb_livefile_t*, uint64_t); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_largest_seqno( + rocksdb_livefile_t*, uint64_t); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_num_entries( + rocksdb_livefile_t*, uint64_t); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_set_num_deletions( + rocksdb_livefile_t*, uint64_t); +extern ROCKSDB_LIBRARY_API void rocksdb_livefile_destroy(rocksdb_livefile_t*); + +extern ROCKSDB_LIBRARY_API void rocksdb_livefiles_add(rocksdb_livefiles_t*, + rocksdb_livefile_t*); + +/* Utility Helpers */ + +extern ROCKSDB_LIBRARY_API void rocksdb_get_options_from_string( + const rocksdb_options_t* base_options, const char* opts_str, + rocksdb_options_t* new_options, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_file_in_range( + rocksdb_t* db, const char* start_key, size_t start_key_len, + const char* limit_key, size_t limit_key_len, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_delete_file_in_range_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const char* start_key, size_t start_key_len, const char* limit_key, + size_t limit_key_len, char** errptr); + +/* MetaData */ + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_metadata_t* +rocksdb_get_column_family_metadata(rocksdb_t* db); + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_metadata_t* +rocksdb_get_column_family_metadata_with_options( + rocksdb_t* db, const rocksdb_column_family_metadata_options_t* options); + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_metadata_options_t* +rocksdb_column_family_metadata_options_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_column_family_metadata_options_destroy( + rocksdb_column_family_metadata_options_t* options); +extern ROCKSDB_LIBRARY_API void +rocksdb_column_family_metadata_options_set_start_key( + rocksdb_column_family_metadata_options_t* options, const char* key, + size_t key_len); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_column_family_metadata_options_get_start_key( + const rocksdb_column_family_metadata_options_t* options, size_t* key_len); +extern ROCKSDB_LIBRARY_API void +rocksdb_column_family_metadata_options_set_end_key( + rocksdb_column_family_metadata_options_t* options, const char* key, + size_t key_len); +extern ROCKSDB_LIBRARY_API const char* +rocksdb_column_family_metadata_options_get_end_key( + const rocksdb_column_family_metadata_options_t* options, size_t* key_len); + +extern ROCKSDB_LIBRARY_API rocksdb_import_column_family_options_t* +rocksdb_import_column_family_options_create(void); + +extern ROCKSDB_LIBRARY_API void +rocksdb_import_column_family_options_set_move_files( + rocksdb_import_column_family_options_t*, unsigned char); + +extern ROCKSDB_LIBRARY_API void rocksdb_import_column_family_options_destroy( + rocksdb_import_column_family_options_t*); + +extern ROCKSDB_LIBRARY_API rocksdb_export_import_files_metadata_t* +rocksdb_export_import_files_metadata_create(void); + +extern ROCKSDB_LIBRARY_API char* +rocksdb_export_import_files_metadata_get_db_comparator_name( + rocksdb_export_import_files_metadata_t*); + +extern ROCKSDB_LIBRARY_API void +rocksdb_export_import_files_metadata_set_db_comparator_name( + rocksdb_export_import_files_metadata_t*, const char*); + +extern ROCKSDB_LIBRARY_API rocksdb_livefiles_t* +rocksdb_export_import_files_metadata_get_files( + rocksdb_export_import_files_metadata_t*); + +extern ROCKSDB_LIBRARY_API void rocksdb_export_import_files_metadata_set_files( + rocksdb_export_import_files_metadata_t*, rocksdb_livefiles_t*); + +extern ROCKSDB_LIBRARY_API void rocksdb_export_import_files_metadata_destroy( + rocksdb_export_import_files_metadata_t*); + +/** + * Returns the rocksdb_column_family_metadata_t of the specified + * column family. + * + * Note that the caller is responsible to release the returned memory + * using rocksdb_column_family_metadata_destroy. + */ +extern ROCKSDB_LIBRARY_API rocksdb_column_family_metadata_t* +rocksdb_get_column_family_metadata_cf( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family); + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_metadata_t* +rocksdb_get_column_family_metadata_cf_with_options( + rocksdb_t* db, rocksdb_column_family_handle_t* column_family, + const rocksdb_column_family_metadata_options_t* options); + +extern ROCKSDB_LIBRARY_API void rocksdb_column_family_metadata_destroy( + rocksdb_column_family_metadata_t* cf_meta); + +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_column_family_metadata_get_size( + rocksdb_column_family_metadata_t* cf_meta); + +extern ROCKSDB_LIBRARY_API size_t rocksdb_column_family_metadata_get_file_count( + rocksdb_column_family_metadata_t* cf_meta); + +extern ROCKSDB_LIBRARY_API char* rocksdb_column_family_metadata_get_name( + rocksdb_column_family_metadata_t* cf_meta); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_column_family_metadata_get_level_count( + rocksdb_column_family_metadata_t* cf_meta); + +/** + * Returns the rocksdb_level_metadata_t of the ith level from the specified + * column family metadata. + * + * If the specified i is greater than or equal to the number of levels + * in the specified column family, then NULL will be returned. + * + * Note that the caller is responsible to release the returned memory + * using rocksdb_level_metadata_destroy before releasing its parent + * rocksdb_column_family_metadata_t. + */ +extern ROCKSDB_LIBRARY_API rocksdb_level_metadata_t* +rocksdb_column_family_metadata_get_level_metadata( + rocksdb_column_family_metadata_t* cf_meta, size_t i); + +/** + * Releases the specified rocksdb_level_metadata_t. + * + * Note that the specified rocksdb_level_metadata_t must be released + * before the release of its parent rocksdb_column_family_metadata_t. + */ +extern ROCKSDB_LIBRARY_API void rocksdb_level_metadata_destroy( + rocksdb_level_metadata_t* level_meta); + +extern ROCKSDB_LIBRARY_API int rocksdb_level_metadata_get_level( + rocksdb_level_metadata_t* level_meta); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_level_metadata_get_size(rocksdb_level_metadata_t* level_meta); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_level_metadata_get_file_count(rocksdb_level_metadata_t* level_meta); + +/** + * Returns the sst_file_metadata_t of the ith file from the specified level + * metadata. + * + * If the specified i is greater than or equal to the number of files + * in the specified level, then NULL will be returned. + * + * Note that the caller is responsible to release the returned memory + * using rocksdb_sst_file_metadata_destroy before releasing its + * parent rocksdb_level_metadata_t. + */ +extern ROCKSDB_LIBRARY_API rocksdb_sst_file_metadata_t* +rocksdb_level_metadata_get_sst_file_metadata( + rocksdb_level_metadata_t* level_meta, size_t i); + +/** + * Releases the specified rocksdb_sst_file_metadata_t. + * + * Note that the specified rocksdb_sst_file_metadata_t must be released + * before the release of its parent rocksdb_level_metadata_t. + */ +extern ROCKSDB_LIBRARY_API void rocksdb_sst_file_metadata_destroy( + rocksdb_sst_file_metadata_t* file_meta); + +extern ROCKSDB_LIBRARY_API char* +rocksdb_sst_file_metadata_get_relative_filename( + rocksdb_sst_file_metadata_t* file_meta); + +extern ROCKSDB_LIBRARY_API char* rocksdb_sst_file_metadata_get_directory( + rocksdb_sst_file_metadata_t* file_meta); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_sst_file_metadata_get_size(rocksdb_sst_file_metadata_t* file_meta); + +/** + * Returns the smallest key of the specified sst file. + * The caller is responsible for releasing the returned memory. + * + * @param file_meta the metadata of an SST file to obtain its smallest key. + * @param len the out value which will contain the length of the returned key + * after the function call. + */ +extern ROCKSDB_LIBRARY_API char* rocksdb_sst_file_metadata_get_smallestkey( + rocksdb_sst_file_metadata_t* file_meta, size_t* len); + +/** + * Returns the smallest key of the specified sst file. + * The caller is responsible for releasing the returned memory. + * + * @param file_meta the metadata of an SST file to obtain its smallest key. + * @param len the out value which will contain the length of the returned key + * after the function call. + */ +extern ROCKSDB_LIBRARY_API char* rocksdb_sst_file_metadata_get_largestkey( + rocksdb_sst_file_metadata_t* file_meta, size_t* len); + +/* Transactions */ + +extern ROCKSDB_LIBRARY_API rocksdb_column_family_handle_t* +rocksdb_transactiondb_create_column_family( + rocksdb_transactiondb_t* txn_db, + const rocksdb_options_t* column_family_options, + const char* column_family_name, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_transactiondb_t* rocksdb_transactiondb_open( + const rocksdb_options_t* options, + const rocksdb_transactiondb_options_t* txn_db_options, const char* name, + char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_transactiondb_t* +rocksdb_transactiondb_open_column_families( + const rocksdb_options_t* options, + const rocksdb_transactiondb_options_t* txn_db_options, const char* name, + int num_column_families, const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr); + +extern ROCKSDB_LIBRARY_API const rocksdb_snapshot_t* +rocksdb_transactiondb_create_snapshot(rocksdb_transactiondb_t* txn_db); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_release_snapshot( + rocksdb_transactiondb_t* txn_db, const rocksdb_snapshot_t* snapshot); + +extern ROCKSDB_LIBRARY_API char* rocksdb_transactiondb_property_value( + rocksdb_transactiondb_t* db, const char* propname); + +extern ROCKSDB_LIBRARY_API int rocksdb_transactiondb_property_int( + rocksdb_transactiondb_t* db, const char* propname, uint64_t* out_val); + +extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_transactiondb_get_base_db( + rocksdb_transactiondb_t* txn_db); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_close_base_db( + rocksdb_t* base_db); + +extern ROCKSDB_LIBRARY_API rocksdb_transaction_t* rocksdb_transaction_begin( + rocksdb_transactiondb_t* txn_db, + const rocksdb_writeoptions_t* write_options, + const rocksdb_transaction_options_t* txn_options, + rocksdb_transaction_t* old_txn); + +extern ROCKSDB_LIBRARY_API rocksdb_transaction_t** +rocksdb_transactiondb_get_prepared_transactions(rocksdb_transactiondb_t* txn_db, + size_t* cnt); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_set_name( + rocksdb_transaction_t* txn, const char* name, size_t name_len, + char** errptr); + +extern ROCKSDB_LIBRARY_API char* rocksdb_transaction_get_name( + rocksdb_transaction_t* txn, size_t* name_len); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_prepare( + rocksdb_transaction_t* txn, char** errptr); +#include "c_api_gen/c_generated_transaction_subset.h.inc" + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_destroy( + rocksdb_transaction_t* txn); + +extern ROCKSDB_LIBRARY_API rocksdb_writebatch_wi_t* +rocksdb_transaction_get_writebatch_wi(rocksdb_transaction_t* txn); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rebuild_from_writebatch( + rocksdb_transaction_t* txn, rocksdb_writebatch_t* writebatch, + char** errptr); + +// This rocksdb_writebatch_wi_t should be freed with rocksdb_free +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_rebuild_from_writebatch_wi( + rocksdb_transaction_t* txn, rocksdb_writebatch_wi_t* wi, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_set_commit_timestamp( + rocksdb_transaction_t* txn, uint64_t commit_timestamp); + +extern ROCKSDB_LIBRARY_API void +rocksdb_transaction_set_read_timestamp_for_validation( + rocksdb_transaction_t* txn, uint64_t read_timestamp); + +// This snapshot should be freed using rocksdb_free +extern ROCKSDB_LIBRARY_API const rocksdb_snapshot_t* +rocksdb_transaction_get_snapshot(rocksdb_transaction_t* txn); + +extern ROCKSDB_LIBRARY_API char* rocksdb_transaction_get( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + const char* key, size_t klen, size_t* vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_pinnableslice_t* +rocksdb_transaction_get_pinned(rocksdb_transaction_t* txn, + const rocksdb_readoptions_t* options, + const char* key, size_t klen, char** errptr); + +extern ROCKSDB_LIBRARY_API char* rocksdb_transaction_get_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, + size_t* vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_pinnableslice_t* +rocksdb_transaction_get_pinned_cf(rocksdb_transaction_t* txn, + const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, + const char* key, size_t klen, char** errptr); + +extern ROCKSDB_LIBRARY_API char* rocksdb_transaction_get_for_update( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + const char* key, size_t klen, size_t* vlen, unsigned char exclusive, + char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_pinnableslice_t* +rocksdb_transaction_get_pinned_for_update(rocksdb_transaction_t* txn, + const rocksdb_readoptions_t* options, + const char* key, size_t klen, + unsigned char exclusive, + char** errptr); + +extern ROCKSDB_LIBRARY_API char* rocksdb_transaction_get_for_update_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, + size_t* vlen, unsigned char exclusive, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_pinnableslice_t* +rocksdb_transaction_get_pinned_for_update_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, size_t klen, + unsigned char exclusive, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_multi_get( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_multi_get_for_update( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_multi_get_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + const rocksdb_column_family_handle_t* const* column_families, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_multi_get_for_update_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + const rocksdb_column_family_handle_t* const* column_families, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs); + +extern ROCKSDB_LIBRARY_API char* rocksdb_transactiondb_get( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + const char* key, size_t klen, size_t* vlen, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_pinnableslice_t* +rocksdb_transactiondb_get_pinned(rocksdb_transactiondb_t* txn_db, + const rocksdb_readoptions_t* options, + const char* key, size_t klen, char** errptr); + +extern ROCKSDB_LIBRARY_API char* rocksdb_transactiondb_get_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, size_t* vallen, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_pinnableslice_t* +rocksdb_transactiondb_get_pinned_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_multi_get( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_multi_get_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + const rocksdb_column_family_handle_t* const* column_families, + size_t num_keys, const char* const* keys_list, + const size_t* keys_list_sizes, char** values_list, + size_t* values_list_sizes, char** errs); +#include "c_api_gen/c_generated_transactiondb_subset.h.inc" + +extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* +rocksdb_transaction_create_iterator(rocksdb_transaction_t* txn, + const rocksdb_readoptions_t* options); + +extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* +rocksdb_transaction_create_iterator_cf( + rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family); + +extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* +rocksdb_transactiondb_create_iterator(rocksdb_transactiondb_t* txn_db, + const rocksdb_readoptions_t* options); + +extern ROCKSDB_LIBRARY_API rocksdb_iterator_t* +rocksdb_transactiondb_create_iterator_cf( + rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_close( + rocksdb_transactiondb_t* txn_db); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_cfs( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options, + rocksdb_column_family_handle_t** column_families, int num_column_families, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_wal_with_options( + rocksdb_transactiondb_t* txn_db, const rocksdb_flushwaloptions_t* options, + char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_checkpoint_t* +rocksdb_transactiondb_checkpoint_object_create(rocksdb_transactiondb_t* txn_db, + char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open(const rocksdb_options_t* options, + const char* name, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open_with_otxn_db_options( + const rocksdb_options_t* options, + const rocksdb_optimistictransactiondb_options_t* otxn_db_options, + const char* name, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open_column_families( + const rocksdb_options_t* options, const char* name, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_t* +rocksdb_optimistictransactiondb_open_column_families_with_otxn_db_options( + const rocksdb_options_t* options, + const rocksdb_optimistictransactiondb_options_t* otxn_db_options, + const char* name, int num_column_families, + const char* const* column_family_names, + const rocksdb_options_t* const* column_family_options, + rocksdb_column_family_handle_t** column_family_handles, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_t* +rocksdb_optimistictransactiondb_get_base_db( + rocksdb_optimistictransactiondb_t* otxn_db); + +extern ROCKSDB_LIBRARY_API void rocksdb_optimistictransactiondb_close_base_db( + rocksdb_t* base_db); + +extern ROCKSDB_LIBRARY_API rocksdb_transaction_t* +rocksdb_optimistictransaction_begin( + rocksdb_optimistictransactiondb_t* otxn_db, + const rocksdb_writeoptions_t* write_options, + const rocksdb_optimistictransaction_options_t* otxn_options, + rocksdb_transaction_t* old_txn); + +extern ROCKSDB_LIBRARY_API void rocksdb_optimistictransactiondb_write( + rocksdb_optimistictransactiondb_t* otxn_db, + const rocksdb_writeoptions_t* options, rocksdb_writebatch_t* batch, + char** errptr); + +extern ROCKSDB_LIBRARY_API void rocksdb_optimistictransactiondb_close( + rocksdb_optimistictransactiondb_t* otxn_db); + +extern ROCKSDB_LIBRARY_API rocksdb_checkpoint_t* +rocksdb_optimistictransactiondb_checkpoint_object_create( + rocksdb_optimistictransactiondb_t* otxn_db, char** errptr); + +/* Transaction Options */ + +enum { + rocksdb_txndb_write_policy_write_committed = 0, + rocksdb_txndb_write_policy_write_prepared = 1, + rocksdb_txndb_write_policy_write_unprepared = 2 +}; + +extern ROCKSDB_LIBRARY_API rocksdb_transactiondb_options_t* +rocksdb_transactiondb_options_create(void); + +extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_options_destroy( + rocksdb_transactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API rocksdb_transaction_options_t* +rocksdb_transaction_options_create(void); + +extern ROCKSDB_LIBRARY_API void rocksdb_transaction_options_destroy( + rocksdb_transaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransaction_options_t* +rocksdb_optimistictransaction_options_create(void); + +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_lock_buckets_t* +rocksdb_optimistictransactiondb_lock_buckets_create( + size_t bucket_count, unsigned char cache_aligned); + +extern ROCKSDB_LIBRARY_API size_t +rocksdb_optimistictransactiondb_lock_buckets_approximate_memory_usage( + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets); + +extern ROCKSDB_LIBRARY_API void +rocksdb_optimistictransactiondb_lock_buckets_destroy( + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets); + +extern ROCKSDB_LIBRARY_API rocksdb_optimistictransactiondb_options_t* +rocksdb_optimistictransactiondb_options_create(void); + +extern ROCKSDB_LIBRARY_API void rocksdb_optimistictransactiondb_options_destroy( + rocksdb_optimistictransactiondb_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_optimistictransactiondb_options_set_shared_lock_buckets( + rocksdb_optimistictransactiondb_options_t* opt, + rocksdb_optimistictransactiondb_lock_buckets_t* lock_buckets); + +extern ROCKSDB_LIBRARY_API void rocksdb_optimistictransaction_options_destroy( + rocksdb_optimistictransaction_options_t* opt); + +extern ROCKSDB_LIBRARY_API char* rocksdb_optimistictransactiondb_property_value( + rocksdb_optimistictransactiondb_t* db, const char* propname); + +extern ROCKSDB_LIBRARY_API int rocksdb_optimistictransactiondb_property_int( + rocksdb_optimistictransactiondb_t* db, const char* propname, + uint64_t* out_val); + +// referring to convention (3), this should be used by client +// to free memory that was malloc()ed +extern ROCKSDB_LIBRARY_API void rocksdb_free(void* ptr); + +extern ROCKSDB_LIBRARY_API rocksdb_pinnableslice_t* rocksdb_get_pinned( + rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key, + size_t keylen, char** errptr); +extern ROCKSDB_LIBRARY_API rocksdb_pinnableslice_t* rocksdb_get_pinned_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_pinnableslice_destroy( + rocksdb_pinnableslice_t* v); +extern ROCKSDB_LIBRARY_API const char* rocksdb_pinnableslice_value( + const rocksdb_pinnableslice_t* t, size_t* vlen); + +extern ROCKSDB_LIBRARY_API rocksdb_memory_consumers_t* +rocksdb_memory_consumers_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_memory_consumers_add_db( + rocksdb_memory_consumers_t* consumers, rocksdb_t* db); +extern ROCKSDB_LIBRARY_API void rocksdb_memory_consumers_add_cache( + rocksdb_memory_consumers_t* consumers, rocksdb_cache_t* cache); +extern ROCKSDB_LIBRARY_API void rocksdb_memory_consumers_destroy( + rocksdb_memory_consumers_t* consumers); +extern ROCKSDB_LIBRARY_API rocksdb_memory_usage_t* +rocksdb_approximate_memory_usage_create(rocksdb_memory_consumers_t* consumers, + char** errptr); +extern ROCKSDB_LIBRARY_API void rocksdb_approximate_memory_usage_destroy( + rocksdb_memory_usage_t* usage); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_approximate_memory_usage_get_mem_table_total( + rocksdb_memory_usage_t* memory_usage); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_approximate_memory_usage_get_mem_table_unflushed( + rocksdb_memory_usage_t* memory_usage); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_approximate_memory_usage_get_mem_table_readers_total( + rocksdb_memory_usage_t* memory_usage); +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_approximate_memory_usage_get_cache_total( + rocksdb_memory_usage_t* memory_usage); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_dump_malloc_stats( + rocksdb_options_t*, unsigned char); + +extern ROCKSDB_LIBRARY_API void +rocksdb_options_set_memtable_whole_key_filtering(rocksdb_options_t*, + unsigned char); + +extern ROCKSDB_LIBRARY_API void rocksdb_cancel_all_background_work( + rocksdb_t* db, unsigned char wait); + +extern ROCKSDB_LIBRARY_API void rocksdb_disable_manual_compaction( + rocksdb_t* db); + +extern ROCKSDB_LIBRARY_API void rocksdb_enable_manual_compaction(rocksdb_t* db); + +extern ROCKSDB_LIBRARY_API rocksdb_statistics_histogram_data_t* +rocksdb_statistics_histogram_data_create(void); +extern ROCKSDB_LIBRARY_API void rocksdb_statistics_histogram_data_destroy( + rocksdb_statistics_histogram_data_t* data); +extern ROCKSDB_LIBRARY_API double rocksdb_statistics_histogram_data_get_median( + rocksdb_statistics_histogram_data_t* data); +extern ROCKSDB_LIBRARY_API double rocksdb_statistics_histogram_data_get_p95( + rocksdb_statistics_histogram_data_t* data); +extern ROCKSDB_LIBRARY_API double rocksdb_statistics_histogram_data_get_p99( + rocksdb_statistics_histogram_data_t* data); +extern ROCKSDB_LIBRARY_API double rocksdb_statistics_histogram_data_get_average( + rocksdb_statistics_histogram_data_t* data); +extern ROCKSDB_LIBRARY_API double rocksdb_statistics_histogram_data_get_std_dev( + rocksdb_statistics_histogram_data_t* data); +extern ROCKSDB_LIBRARY_API double rocksdb_statistics_histogram_data_get_max( + rocksdb_statistics_histogram_data_t* data); +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_statistics_histogram_data_get_count( + rocksdb_statistics_histogram_data_t* data); +extern ROCKSDB_LIBRARY_API uint64_t rocksdb_statistics_histogram_data_get_sum( + rocksdb_statistics_histogram_data_t* data); +extern ROCKSDB_LIBRARY_API double rocksdb_statistics_histogram_data_get_min( + rocksdb_statistics_histogram_data_t* data); + +extern ROCKSDB_LIBRARY_API void rocksdb_wait_for_compact( + rocksdb_t* db, rocksdb_wait_for_compact_options_t* options, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_wait_for_compact_options_t* +rocksdb_wait_for_compact_options_create(void); + +extern ROCKSDB_LIBRARY_API void rocksdb_wait_for_compact_options_destroy( + rocksdb_wait_for_compact_options_t* opt); + +extern ROCKSDB_LIBRARY_API void +rocksdb_wait_for_compact_options_set_abort_on_pause( + rocksdb_wait_for_compact_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_wait_for_compact_options_get_abort_on_pause( + rocksdb_wait_for_compact_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_wait_for_compact_options_set_flush( + rocksdb_wait_for_compact_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_wait_for_compact_options_get_flush( + rocksdb_wait_for_compact_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_wait_for_compact_options_set_close_db( + rocksdb_wait_for_compact_options_t* opt, unsigned char v); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_wait_for_compact_options_get_close_db( + rocksdb_wait_for_compact_options_t* opt); + +extern ROCKSDB_LIBRARY_API void rocksdb_wait_for_compact_options_set_timeout( + rocksdb_wait_for_compact_options_t* opt, uint64_t microseconds); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_wait_for_compact_options_get_timeout( + rocksdb_wait_for_compact_options_t* opt); + +/* High-performance zero-copy Get variants + These functions avoid unnecessary memory allocations and copies. + The returned buffer is valid until the handle is destroyed. + Bindings should migrate to these for better performance. */ + +/* Zero-copy get that returns a handle to pinned data. + The data remains valid until rocksdb_pinnable_handle_destroy is called. + Returns NULL on error or not found. Check errptr to distinguish. */ +typedef struct rocksdb_pinnable_handle_t rocksdb_pinnable_handle_t; + +extern ROCKSDB_LIBRARY_API rocksdb_pinnable_handle_t* rocksdb_get_pinned_v2( + rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key, + size_t keylen, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_pinnable_handle_t* rocksdb_get_pinned_cf_v2( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char** errptr); + +/* Get the data pointer and size from a pinnable handle. + The data pointer is valid until the handle is destroyed. */ +extern ROCKSDB_LIBRARY_API const char* rocksdb_pinnable_handle_get_value( + const rocksdb_pinnable_handle_t* handle, size_t* vallen); + +extern ROCKSDB_LIBRARY_API void rocksdb_pinnable_handle_destroy( + rocksdb_pinnable_handle_t* handle); + +/* Direct get into caller-provided buffer. + Returns 1 if value fits in buffer, 0 if buffer too small. + Sets *vallen to actual value size. + If buffer is too small, no data is copied but *vallen is set. */ +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_get_into_buffer( + rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key, + size_t keylen, char* buffer, size_t buffer_size, size_t* vallen, + unsigned char* found, char** errptr); + +extern ROCKSDB_LIBRARY_API unsigned char rocksdb_get_into_buffer_cf( + rocksdb_t* db, const rocksdb_readoptions_t* options, + rocksdb_column_family_handle_t* column_family, const char* key, + size_t keylen, char* buffer, size_t buffer_size, size_t* vallen, + unsigned char* found, char** errptr); + +// Remote compaction +enum { + rocksdb_compactionservice_jobstatus_success = 0, + rocksdb_compactionservice_jobstatus_failure = 1, + rocksdb_compactionservice_jobstatus_aborted = 2, + rocksdb_compactionservice_jobstatus_use_local = 3, +}; + +extern ROCKSDB_LIBRARY_API rocksdb_compactionservice_scheduleresponse_t* +rocksdb_compactionservice_scheduleresponse_create(const char* scheduled_job_id, + int status, char** errptr); + +extern ROCKSDB_LIBRARY_API rocksdb_compactionservice_scheduleresponse_t* +rocksdb_compactionservice_scheduleresponse_create_with_status(int status, + char** errptr); + +extern ROCKSDB_LIBRARY_API int +rocksdb_compactionservice_scheduleresponse_getstatus( + const rocksdb_compactionservice_scheduleresponse_t* response); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compactionservice_scheduleresponse_get_scheduled_job_id( + const rocksdb_compactionservice_scheduleresponse_t* response, size_t* len); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compactionservice_scheduleresponse_t_destroy( + rocksdb_compactionservice_scheduleresponse_t* response); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compactionservice_jobinfo_t_get_db_name( + const rocksdb_compactionservice_jobinfo_t* info, size_t* len); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compactionservice_jobinfo_t_get_db_id( + const rocksdb_compactionservice_jobinfo_t* info, size_t* len); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compactionservice_jobinfo_t_get_db_session_id( + const rocksdb_compactionservice_jobinfo_t* info, size_t* len); + +extern ROCKSDB_LIBRARY_API const char* +rocksdb_compactionservice_jobinfo_t_get_cf_name( + const rocksdb_compactionservice_jobinfo_t* info, size_t* len); + +extern ROCKSDB_LIBRARY_API uint32_t +rocksdb_compactionservice_jobinfo_t_get_cf_id( + const rocksdb_compactionservice_jobinfo_t* info); + +extern ROCKSDB_LIBRARY_API uint64_t +rocksdb_compactionservice_jobinfo_t_get_job_id( + const rocksdb_compactionservice_jobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int rocksdb_compactionservice_jobinfo_t_get_priority( + const rocksdb_compactionservice_jobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int +rocksdb_compactionservice_jobinfo_t_get_compaction_reason( + const rocksdb_compactionservice_jobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int +rocksdb_compactionservice_jobinfo_t_get_base_input_level( + const rocksdb_compactionservice_jobinfo_t* info); + +extern ROCKSDB_LIBRARY_API int +rocksdb_compactionservice_jobinfo_t_get_output_level( + const rocksdb_compactionservice_jobinfo_t* info); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compactionservice_jobinfo_t_is_full_compaction( + const rocksdb_compactionservice_jobinfo_t* info); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compactionservice_jobinfo_t_is_manual_compaction( + const rocksdb_compactionservice_jobinfo_t* info); + +extern ROCKSDB_LIBRARY_API unsigned char +rocksdb_compactionservice_jobinfo_t_is_bottommost_level( + const rocksdb_compactionservice_jobinfo_t* info); + +extern ROCKSDB_LIBRARY_API rocksdb_compactionservice_t* +rocksdb_compactionservice_create( + void* state, void (*destructor)(void*), + rocksdb_compaction_service_schedule_cb schedule, const char* name, + rocksdb_compaction_service_wait_cb wait, + rocksdb_compaction_service_cancel_awaiting_jobs_cb cancel_awaiting_jobs, + rocksdb_compaction_service_on_installation_cb on_installation); + +extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compaction_service( + rocksdb_options_t* options, rocksdb_compactionservice_t* service); + +// CompactionServiceOptionsOverride +extern ROCKSDB_LIBRARY_API rocksdb_compaction_service_options_override_t* +rocksdb_compaction_service_options_override_create(void); + +extern ROCKSDB_LIBRARY_API rocksdb_compaction_service_options_override_t* +rocksdb_compaction_service_options_override_create_from_options( + rocksdb_options_t* option); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_destroy( + rocksdb_compaction_service_options_override_t* override_options); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_env( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_env_t* env); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_comparator( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_comparator_t* comparator); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_merge_operator( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_mergeoperator_t* merge_operator); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_compaction_filter( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_compactionfilter_t* compaction_filter); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_compaction_filter_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_compactionfilterfactory_t* compaction_filter_factory); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_prefix_extractor( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_slicetransform_t* prefix_extractor); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_block_based_table_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_block_based_table_options_t* table_options); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_cuckoo_table_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_cuckoo_table_options_t* table_options); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_add_event_listener( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_eventlistener_t* event_listener); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_statistics( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_options_t* options); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_info_log( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_logger_t* logger); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_option( + rocksdb_compaction_service_options_override_t* override_options, + const char* key, const char* value); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_file_checksum_gen_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_file_checksum_gen_factory_t* factory); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_set_sst_partitioner_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_sst_partitioner_factory_t* factory); + +extern ROCKSDB_LIBRARY_API void +rocksdb_compaction_service_options_override_add_table_properties_collector_factory( + rocksdb_compaction_service_options_override_t* override_options, + rocksdb_table_properties_collector_factory_t* factory); + +// Atomic bool management for cancellation +// Creates an atomic bool that can be used for cancellation. +// User must call rocksdb_open_and_compact_canceled_destroy() to free it. +extern ROCKSDB_LIBRARY_API unsigned char* +rocksdb_open_and_compact_canceled_create(void); + +extern ROCKSDB_LIBRARY_API void rocksdb_open_and_compact_canceled_destroy( + unsigned char* canceled); + +extern ROCKSDB_LIBRARY_API void rocksdb_open_and_compact_canceled_set( + unsigned char* canceled, unsigned char value); + +// OpenAndCompactOptions +extern ROCKSDB_LIBRARY_API rocksdb_open_and_compact_options_t* +rocksdb_open_and_compact_options_create(void); + +extern ROCKSDB_LIBRARY_API void rocksdb_open_and_compact_options_destroy( + rocksdb_open_and_compact_options_t* options); + +extern ROCKSDB_LIBRARY_API void rocksdb_open_and_compact_options_set_canceled( + rocksdb_open_and_compact_options_t* options, unsigned char* canceled); + +extern ROCKSDB_LIBRARY_API void +rocksdb_open_and_compact_options_set_allow_resumption( + rocksdb_open_and_compact_options_t* options, + unsigned char allow_resumption); + +// OpenAndCompact - main functions +extern ROCKSDB_LIBRARY_API char* rocksdb_open_and_compact( + const char* db_path, const char* output_directory, const char* input, + size_t input_len, size_t* output_len, + const rocksdb_compaction_service_options_override_t* override_options, + char** errptr); + +extern ROCKSDB_LIBRARY_API char* rocksdb_open_and_compact_with_options( + const rocksdb_open_and_compact_options_t* options, const char* db_path, + const char* output_directory, const char* input, size_t input_len, + size_t* output_len, + const rocksdb_compaction_service_options_override_t* override_options, + char** errptr); + +#include "c_api_gen/c_generated_option_structs_auto.h.inc" + +#ifdef __cplusplus +} /* end extern "C" */ +#endif diff --git a/tools/c_api_gen/check_api_compatibility.py b/tools/c_api_gen/check_api_compatibility.py new file mode 100644 index 0000000000..f7c8eeaa97 --- /dev/null +++ b/tools/c_api_gen/check_api_compatibility.py @@ -0,0 +1,237 @@ +# 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 the Apache 2.0 License (found in the Apache file in the root directory). + +#!/usr/bin/env python3 +"""Check the public C API for backward-incompatible changes vs a reference. + +RocksDB's C API (include/rocksdb/c.h) has a strong backward-compatibility +guarantee. Because most wrappers are now code-generated from the C++ headers, a +careless C++ change (renamed/removed field, changed field type) or a generator +change can silently remove a public C function or change its signature -- an +ABI/API break for every downstream language binding. + +This is a robust, signature-level gate (it compares declared function +signatures, not function bodies, so it has no false positives from formatting +or body-token differences). For every function present in the reference +revision's c.h it requires that the current c.h still declares it with an +identical signature (parameter names are ignored; they do not affect the C +ABI). New functions are reported but never fail the check. + +Intentional, reviewed incompatibilities (e.g. removing a function that was +declared but never implemented) must be recorded in +api_compatibility_allowlist.json with a reason. + +Usage: + python3 tools/c_api_gen/check_api_compatibility.py [--ref main] +""" + +from __future__ import annotations + +import argparse +import json +import re +import subprocess +import sys +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +C_HEADER_REL = "include/rocksdb/c.h" +C_HEADER = ROOT / C_HEADER_REL +ALLOWLIST_PATH = ROOT / "tools/c_api_gen/api_compatibility_allowlist.json" + +# C type-name tokens that are never a parameter *name*. Used to tell +# "unsigned char" (type, no name) apart from "rocksdb_t db" (type + name). +_TYPE_KEYWORDS = frozenset( + { + "void", + "char", + "short", + "int", + "long", + "float", + "double", + "unsigned", + "signed", + "bool", + "const", + "size_t", + "ssize_t", + "intptr_t", + "uintptr_t", + "ptrdiff_t", + } +) + +DECL_RE = re.compile( + r"extern\s+ROCKSDB_LIBRARY_API\s+([\s\S]*?)\b(rocksdb_[A-Za-z0-9_]+)\s*\(" + r"([^;]*?)\)\s*;", +) + + +def _strip_param_name(param: str) -> str: + """Return the parameter type with any trailing parameter name removed.""" + param = " ".join(param.replace("[]", " []").split()) + if not param: + return param + tokens = param.split() + last = tokens[-1] + if ( + last in _TYPE_KEYWORDS + or last.endswith("_t") + or "*" in last + or last == "[]" + ): + return param # unnamed parameter; nothing to strip + if len(tokens) > 1 and re.fullmatch(r"[A-Za-z_]\w*", last): + return " ".join(tokens[:-1]) + return param + + +def parse_signatures(header_text: str) -> dict[str, str]: + """Map function name -> normalized signature string (param names removed).""" + sigs: dict[str, str] = {} + for match in DECL_RE.finditer(header_text): + ret = " ".join(match.group(1).split()) + name = match.group(2) + params = [ + _strip_param_name(p) for p in match.group(3).split(",") if p.strip() + ] + sigs[name] = f"{ret} {name}({', '.join(params)})" + return sigs + + +def parse_symbols(header_text: str) -> set[str]: + """Non-function public identifiers: enum constants and typedef names. + + These are part of the C API contract too (e.g. rocksdb_txndb_write_policy_*, + the rocksdb tickers enum). A rocksdb_* token followed by '=', ',' or '}' is + an enum constant; one introduced/closed by typedef is a type name. Anything + followed by '(' is a function (handled by parse_signatures) and excluded. + """ + functions = {m.group(2) for m in DECL_RE.finditer(header_text)} + functions |= set(re.findall(r"\b(rocksdb_[A-Za-z0-9_]+)\s*\(", header_text)) + symbols: set[str] = set() + for m in re.finditer(r"\b(rocksdb_[A-Za-z0-9_]+)\s*(?:=|,|\}|;)", header_text): + symbols.add(m.group(1)) + symbols |= set( + re.findall(r"typedef\s+struct\s+(rocksdb_[A-Za-z0-9_]+)", header_text) + ) + return symbols - functions + + +def git_show(ref: str, path: str) -> str | None: + proc = subprocess.run( + ["git", "show", f"{ref}:{path}"], + cwd=ROOT, + text=True, + capture_output=True, + check=False, + ) + if proc.returncode != 0: + return None + return proc.stdout + + +def load_allowlist() -> dict[str, set[str]]: + """Allowed incompatibilities keyed by kind: removed / changed / removed_symbol.""" + allowed = {"removed": set(), "changed": set(), "removed_symbol": set()} + if not ALLOWLIST_PATH.exists(): + return allowed + data = json.loads(ALLOWLIST_PATH.read_text()) + for entry in data.get("allow", []): + kind = entry.get("kind") + name = entry.get("function") or entry.get("symbol") + if kind in allowed and name: + allowed[kind].add(name) + return allowed + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--ref", + default="main", + help=( + "git revision to treat as the compatibility baseline (default: " + "main). The current working-tree c.h must stay compatible with it." + ), + ) + args = parser.parse_args() + + ref_text = git_show(args.ref, C_HEADER_REL) + if ref_text is None: + sys.stderr.write( + f"error: could not read {C_HEADER_REL} at revision '{args.ref}'. " + "Pass an existing revision via --ref (e.g. --ref origin/main).\n" + ) + return 2 + + cur_text = C_HEADER.read_text() + ref = parse_signatures(ref_text) + cur = parse_signatures(cur_text) + allowed = load_allowlist() + + removed = sorted(n for n in ref if n not in cur and n not in allowed["removed"]) + changed = sorted( + n + for n in ref + if n in cur and ref[n] != cur[n] and n not in allowed["changed"] + ) + new = sorted(n for n in cur if n not in ref) + + ref_symbols = parse_symbols(ref_text) + cur_symbols = parse_symbols(cur_text) + removed_symbols = sorted( + s + for s in ref_symbols + if s not in cur_symbols and s not in allowed["removed_symbol"] + ) + + status = 0 + if removed: + status = 1 + sys.stderr.write( + f"error: {len(removed)} public C API function(s) present at " + f"'{args.ref}' are missing now (backward-incompatible removal):\n" + ) + for name in removed: + sys.stderr.write(f" - {name}\n") + if changed: + status = 1 + sys.stderr.write( + f"error: {len(changed)} public C API function(s) changed signature " + f"(backward-incompatible ABI change):\n" + ) + for name in changed: + sys.stderr.write(f" - {name}\n") + sys.stderr.write(f" was: {ref[name]}\n") + sys.stderr.write(f" now: {cur[name]}\n") + if removed_symbols: + status = 1 + sys.stderr.write( + f"error: {len(removed_symbols)} public C API symbol(s) (enum " + f"constants / typedefs) present at '{args.ref}' are missing now " + "(backward-incompatible removal):\n" + ) + for name in removed_symbols: + sys.stderr.write(f" - {name}\n") + if status != 0: + sys.stderr.write( + "\nIf a change is intentional and reviewed, record it in\n" + f"{ALLOWLIST_PATH.relative_to(ROOT)} with a reason; otherwise restore " + "the original declaration (see tools/c_api_gen/abi_type_overrides.json " + "for pinning a generated C type).\n" + ) + else: + print( + f"C API is backward-compatible with '{args.ref}': " + f"{len(ref)} reference functions preserved, {len(new)} new; " + f"{len(ref_symbols)} enum/typedef symbols preserved." + ) + return status + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/c_api_gen/check_api_completeness.py b/tools/c_api_gen/check_api_completeness.py new file mode 100644 index 0000000000..1d9adff525 --- /dev/null +++ b/tools/c_api_gen/check_api_completeness.py @@ -0,0 +1,117 @@ +# 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 the Apache 2.0 License (found in the LICENSE.Apache file in the root directory). + +#!/usr/bin/env python3 +"""Check that the public C API is link-complete and free of duplicate symbols. + +Every function declared in ``include/rocksdb/c.h`` with +``extern ROCKSDB_LIBRARY_API`` must have exactly one definition in ``db/c.cc``. + +This is a cheap, dependency-free safety net (no clang/libclang required) that +guards against a whole class of code-generation migration bugs: a wrapper whose +declaration is kept while its hand-written implementation is removed and never +regenerated. Such a function compiles fine into ``librocksdb`` (the missing +symbol is simply absent from the archive) and is invisible to RocksDB's own C +test unless that test happens to call it -- but it breaks every downstream +language binding (Rust, Go, Python, ...) that links against the symbol. + +It also flags duplicate definitions, which would otherwise fail only at link +time with a less obvious error. + +Run: + python3 tools/c_api_gen/check_api_completeness.py +""" + +from __future__ import annotations + +import re +import sys +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +C_HEADER = ROOT / "include/rocksdb/c.h" +C_SOURCE = ROOT / "db/c.cc" + +# A public C API declaration looks like: +# extern ROCKSDB_LIBRARY_API rocksdb_foo(...); +# The return type may be on the same line or the following one, so anchor on +# the export macro and capture the first rocksdb_* identifier that is +# immediately followed by '('. +DECL_RE = re.compile( + r"extern\s+ROCKSDB_LIBRARY_API\b[\s\S]*?\b(rocksdb_[A-Za-z0-9_]+)\s*\(", +) + +# A definition in c.cc is a top-level (column 0) function whose name is a +# rocksdb_* identifier immediately followed by '('. Return types/pointers may +# precede the name on the same line (e.g. "rocksdb_t* rocksdb_open("). +DEF_RE = re.compile( + r"^(?:[A-Za-z_][\w:<>,\s\*&]*?\s[\*&]*)?(rocksdb_[A-Za-z0-9_]+)\s*\(", + re.MULTILINE, +) + +# Function-pointer typedefs etc. are not function definitions; the patterns +# above already exclude lines containing "(*name)" because the identifier must +# be directly followed by '('. + + +def declared_functions(header_text: str) -> set[str]: + return set(DECL_RE.findall(header_text)) + + +def defined_functions(source_text: str) -> dict[str, int]: + counts: dict[str, int] = {} + for name in DEF_RE.findall(source_text): + counts[name] = counts.get(name, 0) + 1 + return counts + + +def main() -> int: + if not C_HEADER.is_file() or not C_SOURCE.is_file(): + sys.stderr.write( + f"error: expected {C_HEADER} and {C_SOURCE} to exist\n" + ) + return 2 + + declared = declared_functions(C_HEADER.read_text()) + defined = defined_functions(C_SOURCE.read_text()) + + missing = sorted(name for name in declared if name not in defined) + duplicated = sorted(name for name, n in defined.items() if n > 1) + + status = 0 + if missing: + status = 1 + sys.stderr.write( + f"error: {len(missing)} C API function(s) are declared in " + f"{C_HEADER.relative_to(ROOT)} but have no definition in " + f"{C_SOURCE.relative_to(ROOT)}:\n" + ) + for name in missing: + sys.stderr.write(f" - {name}\n") + sys.stderr.write( + "\nEach such function breaks downstream bindings at link time.\n" + "Add the implementation to tools/c_api_gen/c_base.cc (or via the\n" + "generators) and rerun python3 tools/c_api_gen/regen_all.py.\n" + ) + + if duplicated: + status = 1 + sys.stderr.write( + f"error: {len(duplicated)} C API function(s) are defined more than " + f"once in {C_SOURCE.relative_to(ROOT)}:\n" + ) + for name in duplicated: + sys.stderr.write(f" - {name} ({defined[name]} definitions)\n") + + if status == 0: + print( + f"C API is link-complete: all {len(declared)} declared functions " + "have exactly one definition." + ) + return status + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/c_api_gen/equivalence_allowlist.json b/tools/c_api_gen/equivalence_allowlist.json new file mode 100644 index 0000000000..5f84b5c494 --- /dev/null +++ b/tools/c_api_gen/equivalence_allowlist.json @@ -0,0 +1,8 @@ +{ + "allowlist": [ + { + "name": "rocksdb_transactiondb_options_set_use_per_key_point_lock_mgr", + "reason": "The old handwritten implementation existed in db/c.cc but was not declared in include/rocksdb/c.h. The generated declaration intentionally fixes that historical inconsistency." + } + ] +} diff --git a/tools/c_api_gen/gen_roundtrip_tests.py b/tools/c_api_gen/gen_roundtrip_tests.py new file mode 100644 index 0000000000..d409031233 --- /dev/null +++ b/tools/c_api_gen/gen_roundtrip_tests.py @@ -0,0 +1,206 @@ +# 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 the Apache 2.0 License (found in the LICENSE.Apache file in the root directory). + +#!/usr/bin/env python3 +"""Generate round-trip (set -> get -> assert) C tests for the generated C API. + +A large share of the auto-generated option getters/setters had no test +coverage. Rather than hand-writing hundreds of set/get assertions (and letting +coverage drift as the API grows), this tool derives the tests from the same +checked-in generated fragments that define the wrappers. + +It parses the generated declaration fragments (c_api_gen/*.h.inc), pairs every +``rocksdb__set_`` with its ``rocksdb__get_``, +and emits, for each option object with a parameterless ``_create`` / +``_destroy``, a test that creates the object, sets a sentinel value, asserts +the getter returns it, and destroys the object. + +Because the generated setters/getters are direct field assignments, a sentinel +round-trips reliably: + - string getters (``const char*`` + ``size_t*``) -> set "test", compare bytes + - everything else -> set 1 then 0 and assert the getter returns each. + +1 and 0 are used (rather than a larger sentinel) because a bool field whose C +getter has the legacy ``int`` shape -- indistinguishable from a real scalar by +the C signature alone -- would collapse any value > 1 to 1. Using both 1 and 0 +also exercises the setter in both directions. + +No clang/libclang is required (it only reads the committed .inc files). The +output, c_api_gen/c_generated_roundtrip_tests.c.inc, is included by db/c_test.c. +""" + +from __future__ import annotations + +import re +import sys +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +GENERATED_ROOT = ROOT / "c_api_gen" +C_HEADER = ROOT / "include/rocksdb/c.h" +OUT = GENERATED_ROOT / "c_generated_roundtrip_tests.c.inc" + +DECL_RE = re.compile( + r"extern\s+ROCKSDB_LIBRARY_API\s+(.+?)\s*\b(rocksdb_[A-Za-z0-9_]+)\s*\(([^;]*?)\)\s*;", + re.S, +) + + +class Pair: + __slots__ = ("prefix", "field", "receiver", "getter", "setter", "ret", "is_string") + + def __init__(self, prefix: str, field: str, receiver: str) -> None: + self.prefix = prefix + self.field = field + self.receiver = receiver + self.getter: str | None = None + self.setter: str | None = None + self.ret: str | None = None + self.is_string = False + + +def _params(param_str: str) -> list[str]: + return [p.strip() for p in param_str.split(",") if p.strip()] + + +def _first_param_type(param: str) -> str: + # "rocksdb_options_t* opt" -> "rocksdb_options_t*" + param = " ".join(param.split()) + return re.sub(r"\b[A-Za-z_]\w*$", "", param).strip() + + +def _split_role(name: str) -> tuple[str, str, str] | None: + for role in ("_set_", "_get_"): + idx = name.find(role) + if idx != -1: + return name[:idx], role.strip("_"), name[idx + len(role) :] + return None + + +def collect_pairs() -> list[Pair]: + pairs: dict[tuple[str, str], Pair] = {} + for inc in sorted(GENERATED_ROOT.glob("*.h.inc")): + text = inc.read_text() + for m in DECL_RE.finditer(text): + ret = " ".join(m.group(1).split()) + name = m.group(2) + params = _params(m.group(3)) + split = _split_role(name) + if split is None or not params: + continue + prefix, role, field = split + receiver = _first_param_type(params[0]) + key = (prefix, field) + pair = pairs.get(key) + if pair is None: + pair = Pair(prefix, field, receiver) + pairs[key] = pair + if role == "set": + # Only simple scalar/string setters: (receiver, value). + if len(params) == 2: + pair.setter = name + else: # get + if len(params) == 1 and ret != "void": + pair.getter = name + pair.ret = ret + elif len(params) == 2 and ret == "const char*": + pair.getter = name + pair.ret = ret + pair.is_string = True + return [p for p in pairs.values() if p.getter and p.setter] + + +def parameterless_creators(header_text: str) -> set[str]: + """Prefixes whose _create() takes no args and _destroy exists.""" + creators: set[str] = set() + for m in re.finditer( + r"\b(rocksdb_[A-Za-z0-9_]+)_create\s*\(\s*(void)?\s*\)\s*;", header_text + ): + creators.add(m.group(1)) + destroyers = set( + re.findall(r"\b(rocksdb_[A-Za-z0-9_]+)_destroy\s*\(", header_text) + ) + return {p for p in creators if p in destroyers} + + +def emit() -> str: + header_text = C_HEADER.read_text() + declared = set(re.findall(r"\b(rocksdb_[A-Za-z0-9_]+)\s*\(", header_text)) + creators = parameterless_creators(header_text) + + by_prefix: dict[str, list[Pair]] = {} + for pair in collect_pairs(): + if pair.prefix not in creators: + continue + if pair.getter not in declared or pair.setter not in declared: + continue + by_prefix.setdefault(pair.prefix, []).append(pair) + + lines: list[str] = [] + lines.append("// @generated") + lines.append( + "// -----------------------------------------------------------------------------" + ) + lines.append("// Auto-generated by tools/c_api_gen/gen_roundtrip_tests.py.") + lines.append("// DO NOT EDIT THIS FILE DIRECTLY.") + lines.append( + "// Round-trip (set -> get -> assert) coverage for generated option wrappers." + ) + lines.append("// Rerun: python3 tools/c_api_gen/regen_all.py") + lines.append( + "// -----------------------------------------------------------------------------" + ) + lines.append("") + + test_fns: list[str] = [] + for prefix in sorted(by_prefix): + pairs = sorted(by_prefix[prefix], key=lambda p: p.field) + receiver = pairs[0].receiver + fn = f"rocksdb_roundtrip_test_{prefix}" + test_fns.append(fn) + lines.append(f"static void {fn}(void) {{") + lines.append(f" {receiver} obj = {prefix}_create();") + for pair in pairs: + if pair.is_string: + lines.append(f' {pair.setter}(obj, "test");') + lines.append(" {") + lines.append(" size_t rt_len = 0;") + lines.append(f" const char* rt_v = {pair.getter}(obj, &rt_len);") + lines.append( + " CheckCondition(rt_len == 4 && rt_v != NULL && " + 'memcmp(rt_v, "test", 4) == 0);' + ) + lines.append(" }") + else: + # Use 1 and 0 (both directions). These round-trip through any + # numeric/enum field AND through bool fields -- a larger value + # would be collapsed to 1 by a bool field whose C getter is the + # legacy `int` shape (e.g. rocksdb_options_get_use_fsync), so we + # cannot tell bool from a plain scalar by the C signature alone. + for value in ("1", "0"): + lines.append(f" {pair.setter}(obj, {value});") + lines.append( + f" CheckCondition({pair.getter}(obj) == {value});" + ) + lines.append(f" {prefix}_destroy(obj);") + lines.append("}") + lines.append("") + + lines.append("static void rocksdb_run_generated_roundtrip_tests(void) {") + for fn in test_fns: + lines.append(f" {fn}();") + lines.append("}") + lines.append("") + return "\n".join(lines) + + +def main() -> int: + OUT.write_text(emit()) + print(f"Generated {OUT.relative_to(ROOT)}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/c_api_gen/generate_c_api.py b/tools/c_api_gen/generate_c_api.py new file mode 100644 index 0000000000..10a3584445 --- /dev/null +++ b/tools/c_api_gen/generate_c_api.py @@ -0,0 +1,304 @@ +# 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 the Apache 2.0 License (found in the LICENSE.Apache file in the root directory). + +#!/usr/bin/env python3 +"""Generate preview C API wrapper fragments from a declarative spec. + +This prototype intentionally targets a constrained subset of RocksDB's C API: + +- plain field setters/getters +- simple method forwarding wrappers +- Status -> char** errptr wrappers +- simple string metadata accessors + +It does not attempt to infer wrappers from arbitrary C++ headers. +""" + +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +from typing import Iterable + + +HEADER_BANNER = [ + "// @generated", + "// -----------------------------------------------------------------------------", + "// Auto-generated by tools/c_api_gen/generate_c_api.py.", + "// DO NOT EDIT THIS FILE DIRECTLY.", + "// Source: tools/c_api_gen/spec.json", + "// -----------------------------------------------------------------------------", + "", +] + + +def format_signature(prefix: str, params: list[str], suffix: str) -> list[str]: + one_line = f"{prefix}{', '.join(params)}{suffix}" + if len(one_line) <= 80: + return [one_line] + + lines = [prefix] + for i, param in enumerate(params): + trailing = "," if i + 1 < len(params) else "" + lines.append(f" {param}{trailing}") + lines[-1] = f"{lines[-1]}{suffix}" + return lines + + +def c_param_decl(param: dict) -> list[str]: + kind = param["kind"] + if kind == "scalar": + return [f'{param["c_type"]} {param["name"]}'] + if kind == "slice": + return [f'const char* {param["name"]}', f'size_t {param["len_name"]}'] + raise ValueError(f"Unsupported parameter kind: {kind}") + + +def flatten_params(params: Iterable[dict], include_errptr: bool = False) -> list[str]: + result: list[str] = [] + for param in params: + result.extend(c_param_decl(param)) + if include_errptr: + result.append("char** errptr") + return result + + +def render_decl(fn: dict) -> list[str]: + kind = fn["kind"] + if kind == "field_setter": + params = [ + f'{fn["receiver_type"]} {fn["receiver_name"]}', + f'{fn["value_type"]} {fn["value_name"]}', + ] + return format_signature( + f'extern ROCKSDB_LIBRARY_API void {fn["name"]}(', + params, + ");", + ) + if kind == "field_getter": + params = [f'{fn["receiver_type"]} {fn["receiver_name"]}'] + return format_signature( + f'extern ROCKSDB_LIBRARY_API {fn["return_type"]} {fn["name"]}(', + params, + ");", + ) + if kind == "string_field_getter": + params = [ + f'{fn["receiver_type"]} {fn["receiver_name"]}', + f'{fn["len_type"]} {fn["len_name"]}', + ] + return format_signature( + f'extern ROCKSDB_LIBRARY_API const char* {fn["name"]}(', + params, + ");", + ) + if kind == "status_getter": + params = [ + f'{fn["receiver_type"]} {fn["receiver_name"]}', + "char** errptr", + ] + return format_signature( + f'extern ROCKSDB_LIBRARY_API void {fn["name"]}(', + params, + ");", + ) + if kind == "void_method": + return format_signature( + f'extern ROCKSDB_LIBRARY_API void {fn["name"]}(', + flatten_params(fn["params"]), + ");", + ) + if kind == "status_method": + return format_signature( + f'extern ROCKSDB_LIBRARY_API void {fn["name"]}(', + flatten_params(fn["params"], include_errptr=True), + ");", + ) + raise ValueError(f"Unsupported function kind: {kind}") + + +def render_impl(fn: dict) -> list[str]: + kind = fn["kind"] + if kind == "field_setter": + params = [ + f'{fn["receiver_type"]} {fn["receiver_name"]}', + f'{fn["value_type"]} {fn["value_name"]}', + ] + lines = format_signature(f'void {fn["name"]}(', params, ") {") + value_expr = fn.get("value_expr", fn["value_name"]) + lines.append(f' {fn["field"]} = {value_expr};') + lines.append("}") + return lines + if kind == "field_getter": + params = [f'{fn["receiver_type"]} {fn["receiver_name"]}'] + lines = format_signature( + f'{fn["return_type"]} {fn["name"]}(', params, ") {" + ) + lines.append(f' return {fn["expr"]};') + lines.append("}") + return lines + if kind == "string_field_getter": + params = [ + f'{fn["receiver_type"]} {fn["receiver_name"]}', + f'{fn["len_type"]} {fn["len_name"]}', + ] + lines = format_signature(f'const char* {fn["name"]}(', params, ") {") + lines.append(f' *{fn["len_name"]} = {fn["expr"]}.size();') + lines.append(f' return {fn["expr"]}.data();') + lines.append("}") + return lines + if kind == "status_getter": + params = [ + f'{fn["receiver_type"]} {fn["receiver_name"]}', + "char** errptr", + ] + lines = format_signature(f'void {fn["name"]}(', params, ") {") + lines.append(f' SaveError(errptr, {fn["expr"]});') + lines.append("}") + return lines + if kind in ("void_method", "status_method"): + params = flatten_params(fn["params"], include_errptr=(kind == "status_method")) + lines = format_signature(f'void {fn["name"]}(', params, ") {") + call = f'{fn["call_expr"]}({", ".join(fn["method_args"])})' + if kind == "void_method": + lines.append(f" {call};") + else: + lines.append(f" SaveError(errptr, {call});") + lines.append("}") + return lines + raise ValueError(f"Unsupported function kind: {kind}") + + +def regen_comment_lines(mode: str) -> list[str]: + if mode == "header": + return [ + "// To regenerate this file:", + "// python3 tools/c_api_gen/generate_c_api.py", + "// --spec tools/c_api_gen/spec.json", + "// --header-out c_api_gen/c_generated_subset.h.inc", + "// --source-out c_api_gen/c_generated_subset.cc.inc", + "", + ] + return [ + "// To regenerate this file:", + "// python3 tools/c_api_gen/generate_c_api.py", + "// --spec tools/c_api_gen/spec.json", + "// --header-out c_api_gen/c_generated_subset.h.inc", + "// --source-out c_api_gen/c_generated_subset.cc.inc", + "", + ] + + +def section_comment_lines( + sections: list[str], header_out: Path, source_out: Path +) -> list[str]: + lines = [ + "// To regenerate this file:", + "// python3 tools/c_api_gen/generate_c_api.py", + ] + current = "// --spec tools/c_api_gen/spec.json" + for section in sections: + addition = f" --section {section!r}" + if len(current) + len(addition) > 78: + lines.append(current) + current = f"// --section {section!r}" + else: + current += addition + lines.append(current) + try: + rel_header = header_out.relative_to(ROOT) + except ValueError: + rel_header = header_out + try: + rel_source = source_out.relative_to(ROOT) + except ValueError: + rel_source = source_out + lines.append("// --header-out") + lines.append(f"// {rel_header}") + lines.append("// --source-out") + lines.append(f"// {rel_source}") + lines.append("") + return lines + + +def render_sections(spec: dict, mode: str, cmd_comment: list[str] | None = None) -> str: + lines: list[str] = [] + lines.extend(HEADER_BANNER) + lines.extend(cmd_comment if cmd_comment is not None else regen_comment_lines(mode)) + for section in spec["sections"]: + lines.append(f'/* {section["name"]} */') + lines.append("") + for fn in section["functions"]: + render = render_decl if mode == "header" else render_impl + lines.extend(render(fn)) + lines.append("") + return "\n".join(lines).rstrip() + "\n" + + +def write_if_changed(path: Path, content: str) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + if not path.exists() or path.read_text() != content: + path.write_text(content) + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--spec", required=True, type=Path) + parser.add_argument("--header-out", required=True, type=Path) + parser.add_argument("--source-out", required=True, type=Path) + parser.add_argument( + "--section", + action="append", + default=[], + help="Only emit the named section(s) from the spec. May be repeated.", + ) + parser.add_argument( + "--check", + action="store_true", + help="fail instead of writing if outputs are stale", + ) + args = parser.parse_args() + + spec = json.loads(args.spec.read_text()) + if args.section: + allowed = set(args.section) + spec = { + **spec, + "sections": [ + section for section in spec["sections"] if section["name"] in allowed + ], + } + comment = regen_comment_lines("header") + if args.section: + comment = section_comment_lines( + args.section, args.header_out, args.source_out + ) + header = render_sections(spec, "header", cmd_comment=comment) + source = render_sections(spec, "source", cmd_comment=comment) + + if args.check: + expected = { + args.header_out: header, + args.source_out: source, + } + stale: list[str] = [] + for path, content in expected.items(): + if not path.exists() or path.read_text() != content: + stale.append(str(path)) + if stale: + for path in stale: + print(f"stale: {path}") + return 1 + return 0 + + write_if_changed(args.header_out, header) + write_if_changed(args.source_out, source) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/c_api_gen/regen_all.py b/tools/c_api_gen/regen_all.py new file mode 100644 index 0000000000..af60b8c673 --- /dev/null +++ b/tools/c_api_gen/regen_all.py @@ -0,0 +1,266 @@ +# 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 the Apache 2.0 License (found in the LICENSE.Apache file in the root directory). + +#!/usr/bin/env python3 +"""Regenerate all checked-in RocksDB C API generated fragments.""" + +from __future__ import annotations + +import argparse +import shutil +import subprocess +import sys +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +GEN = ROOT / "tools/c_api_gen/generate_c_api.py" +AUTO_GEN = ROOT / "tools/c_api_gen/auto_simple_bindings.py" +ROUNDTRIP_GEN = ROOT / "tools/c_api_gen/gen_roundtrip_tests.py" +SPEC = ROOT / "tools/c_api_gen/spec.json" +GENERATED_ROOT = ROOT / "c_api_gen" +CLANG_FORMAT_STYLE_FILE = ROOT / ".clang-format" + + +JOBS = [ + ( + ["DB data operations", "WriteBatch", "Transaction", "TransactionDB simple"], + GENERATED_ROOT / "c_generated_subset.h.inc", + GENERATED_ROOT / "c_generated_subset.cc.inc", + ), + ( + ["DB data operations"], + GENERATED_ROOT / "c_generated_db_simple_subset.h.inc", + GENERATED_ROOT / "c_generated_db_simple_subset.cc.inc", + ), + ( + ["WriteBatch"], + GENERATED_ROOT / "c_generated_writebatch_subset.h.inc", + GENERATED_ROOT / "c_generated_writebatch_subset.cc.inc", + ), + ( + ["Transaction"], + GENERATED_ROOT / "c_generated_transaction_subset.h.inc", + GENERATED_ROOT / "c_generated_transaction_subset.cc.inc", + ), + ( + ["TransactionDB simple"], + GENERATED_ROOT / "c_generated_transactiondb_subset.h.inc", + GENERATED_ROOT / "c_generated_transactiondb_subset.cc.inc", + ), + ( + ["BlockBasedOptions simple"], + GENERATED_ROOT / "c_generated_block_based_options_subset.h.inc", + GENERATED_ROOT / "c_generated_block_based_options_subset.cc.inc", + ), + ( + ["JobInfo metadata simple"], + GENERATED_ROOT / "c_generated_jobinfo_metadata_subset.h.inc", + GENERATED_ROOT / "c_generated_jobinfo_metadata_subset.cc.inc", + ), + ( + ["CuckooOptions simple"], + GENERATED_ROOT / "c_generated_cuckoo_options_subset.h.inc", + GENERATED_ROOT / "c_generated_cuckoo_options_subset.cc.inc", + ), + ( + ["Options simple"], + GENERATED_ROOT / "c_generated_options_subset.h.inc", + GENERATED_ROOT / "c_generated_options_subset.cc.inc", + ), +] + + +def run_job(sections: list[str], header_out: Path, source_out: Path) -> None: + cmd = [ + sys.executable, + str(GEN), + "--spec", + str(SPEC), + ] + for section in sections: + cmd.extend(["--section", section]) + cmd.extend( + [ + "--header-out", + str(header_out), + "--source-out", + str(source_out), + ] + ) + subprocess.run(cmd, cwd=ROOT, check=True) + + +def format_generated_outputs(clang_format: str | None) -> None: + # The checked-in .inc fragments (and therefore the inlined c.h/c.cc) are + # clang-format-canonicalized. Pin the formatter (e.g. clang-format-21) to + # match CI so regeneration is byte-reproducible across environments; see + # tools/c_api_gen/README.md for the required version. + resolved = shutil.which(clang_format) if clang_format else None + if resolved is None: + print( + f"warning: clang-format binary '{clang_format}' not found in PATH; " + "skipping formatting (generated output may not be byte-reproducible)", + file=sys.stderr, + ) + return + + generated_paths = sorted(GENERATED_ROOT.glob("*.inc")) + subprocess.run( + [ + resolved, + f"--style=file:{CLANG_FORMAT_STYLE_FILE}", + "-i", + *(str(path) for path in generated_paths), + ], + cwd=ROOT, + check=True, + ) + + +C_BASE_H = ROOT / "tools/c_api_gen/c_base.h" +C_H = ROOT / "include/rocksdb/c.h" +C_BASE_CC = ROOT / "tools/c_api_gen/c_base.cc" +C_CC = ROOT / "db/c.cc" + + +def _generated_banner(edit_target: str) -> str: + return ( + "// @generated\n" + "// -----------------------------------------------------------------------------\n" + "// Auto-generated by tools/c_api_gen/regen_all.py.\n" + "// DO NOT EDIT THIS FILE DIRECTLY.\n" + f"// Edit {edit_target} or the inputs under tools/c_api_gen/,\n" + "// then rerun: python3 tools/c_api_gen/regen_all.py\n" + "// -----------------------------------------------------------------------------\n\n" + ) + + +def _strip_source_template_notice(base: str) -> str: + import re + + return re.sub( + r"(?ms)^// SOURCE TEMPLATE -- DO NOT .*?^//\s*$\n?", + "", + base, + count=1, + ) + + +def _split_leading_line_comment_header(base: str) -> tuple[str, str]: + lines = base.splitlines(keepends=True) + idx = 0 + + while idx < len(lines): + stripped = lines[idx].lstrip() + if stripped.startswith("//"): + idx += 1 + continue + break + + return "".join(lines[:idx]), "".join(lines[idx:]) + + +def _inline_fragments( + base_path: Path, + out_path: Path, + inc_pattern: str, + search_root: Path, + main_include: str | None = None, + generated_banner: str | None = None, +) -> None: + """Inline generated .inc fragments into out_path from base_path.""" + import re + from pathlib import Path as _Path + + base = _strip_source_template_notice(base_path.read_text()) + if generated_banner is not None: + header, rest = _split_leading_line_comment_header(base) + if header: + base = header.rstrip("\n") + "\n" + generated_banner + rest.lstrip("\n") + else: + base = generated_banner + base.lstrip("\n") + # Prepend main include as a separate group (own line + blank line) + if main_include is not None: + first_include = re.search(r'^#include ', base, re.MULTILINE) + if first_include: + pos = first_include.start() + base = base[:pos] + main_include + "\n\n" + base[pos:] + + def inline_include(m: re.Match) -> str: + inc_path = search_root / m.group(1) + inc_content = inc_path.read_text().strip("\n") + filename = _Path(m.group(1)).name + return ( + f"// BEGIN generated: {filename}\n" + + inc_content + + f"\n// END generated: {filename}" + ) + + result = re.sub(inc_pattern, inline_include, base) + out_path.write_text(result) + print(f"Generated {out_path.relative_to(ROOT)}") + + +def generate_c_h() -> None: + """Inline all generated .h.inc fragments into c.h from c_base.h.""" + _inline_fragments( + C_BASE_H, + C_H, + r'#include ["<](c_api_gen/[^">]+)[">]', + ROOT, + generated_banner=_generated_banner("tools/c_api_gen/c_base.h"), + ) + + +def generate_c_cc() -> None: + """Inline all generated .cc.inc fragments into c.cc from c_base.cc.""" + _inline_fragments( + C_BASE_CC, + C_CC, + r'#include "(c_api_gen/[^"]+)"', + ROOT, + main_include='#include "rocksdb/c.h"', + generated_banner=_generated_banner("tools/c_api_gen/c_base.cc"), + ) + + +def main() -> int: + parser = argparse.ArgumentParser( + description="Regenerate all checked-in RocksDB C API generated fragments." + ) + parser.add_argument( + "--clang-format", + default="clang-format", + help=( + "clang-format binary used to canonicalize the generated .inc " + "fragments (default: clang-format). Pin to the version CI uses " + "(e.g. clang-format-21) for byte-reproducible output." + ), + ) + args = parser.parse_args() + + for sections, header_out, source_out in JOBS: + run_job(sections, header_out, source_out) + subprocess.run([sys.executable, str(AUTO_GEN)], cwd=ROOT, check=True) + format_generated_outputs(args.clang_format) + generate_c_h() + generate_c_cc() + # c.h and c.cc are assembled from already-formatted .inc fragments. + # We do NOT re-run clang-format on them after inlining -- the .inc content + # is formatted above, and reformatting the inlined result would produce + # different line-wrapping since clang-format sees more context. + # + # Generate the round-trip C tests last: they read the (now generated) + # c.h to discover which option objects have a parameterless create/destroy + # and the .h.inc fragments to pair setters with getters. Re-run formatting + # so the new test fragment is canonicalized like the rest. This does not + # affect c.h/c.cc, which are not assembled from the test fragment. + subprocess.run([sys.executable, str(ROUNDTRIP_GEN)], cwd=ROOT, check=True) + format_generated_outputs(args.clang_format) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/c_api_gen/spec.json b/tools/c_api_gen/spec.json new file mode 100644 index 0000000000..1e842cbab5 --- /dev/null +++ b/tools/c_api_gen/spec.json @@ -0,0 +1,1734 @@ +{ + "sections": [ + { + "name": "DB data operations", + "functions": [ + { + "kind": "status_method", + "name": "rocksdb_put", + "call_expr": "db->rep->Put", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vallen" + } + ], + "method_args": [ + "options->rep", + "Slice(key, keylen)", + "Slice(val, vallen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_put_cf", + "call_expr": "db->rep->Put", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vallen" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(key, keylen)", + "Slice(val, vallen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_delete", + "call_expr": "db->rep->Delete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + } + ], + "method_args": [ + "options->rep", + "Slice(key, keylen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_delete_cf", + "call_expr": "db->rep->Delete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(key, keylen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_merge", + "call_expr": "db->rep->Merge", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vallen" + } + ], + "method_args": [ + "options->rep", + "Slice(key, keylen)", + "Slice(val, vallen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_merge_cf", + "call_expr": "db->rep->Merge", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vallen" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(key, keylen)", + "Slice(val, vallen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_write", + "call_expr": "db->rep->Write", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "batch" + } + ], + "method_args": [ + "options->rep", + "&batch->rep" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_put_with_ts", + "call_expr": "db->rep->Put", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "ts", + "len_name": "tslen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vallen" + } + ], + "method_args": [ + "options->rep", + "Slice(key, keylen)", + "Slice(ts, tslen)", + "Slice(val, vallen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_put_cf_with_ts", + "call_expr": "db->rep->Put", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "ts", + "len_name": "tslen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vallen" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(key, keylen)", + "Slice(ts, tslen)", + "Slice(val, vallen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_delete_with_ts", + "call_expr": "db->rep->Delete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "ts", + "len_name": "tslen" + } + ], + "method_args": [ + "options->rep", + "Slice(key, keylen)", + "Slice(ts, tslen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_delete_cf_with_ts", + "call_expr": "db->rep->Delete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "ts", + "len_name": "tslen" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(key, keylen)", + "Slice(ts, tslen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_singledelete", + "call_expr": "db->rep->SingleDelete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + } + ], + "method_args": [ + "options->rep", + "Slice(key, keylen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_singledelete_cf", + "call_expr": "db->rep->SingleDelete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(key, keylen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_singledelete_with_ts", + "call_expr": "db->rep->SingleDelete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "ts", + "len_name": "tslen" + } + ], + "method_args": [ + "options->rep", + "Slice(key, keylen)", + "Slice(ts, tslen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_singledelete_cf_with_ts", + "call_expr": "db->rep->SingleDelete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "ts", + "len_name": "tslen" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(key, keylen)", + "Slice(ts, tslen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_delete_range_cf", + "call_expr": "db->rep->DeleteRange", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "start_key", + "len_name": "start_key_len" + }, + { + "kind": "slice", + "name": "end_key", + "len_name": "end_key_len" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(start_key, start_key_len)", + "Slice(end_key, end_key_len)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_flush", + "call_expr": "db->rep->Flush", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_flushoptions_t*", + "name": "options" + } + ], + "method_args": [ + "options->rep" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_flush_cf", + "call_expr": "db->rep->Flush", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_flushoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + } + ], + "method_args": [ + "options->rep", + "column_family->rep" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_flush_wal", + "call_expr": "db->rep->FlushWAL", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "unsigned char", + "name": "sync" + } + ], + "method_args": [ + "sync" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_pause_background_work", + "call_expr": "db->rep->PauseBackgroundWork", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + } + ], + "method_args": [] + }, + { + "kind": "status_method", + "name": "rocksdb_continue_background_work", + "call_expr": "db->rep->ContinueBackgroundWork", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + } + ], + "method_args": [] + }, + { + "kind": "status_method", + "name": "rocksdb_disable_file_deletions", + "call_expr": "db->rep->DisableFileDeletions", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + } + ], + "method_args": [] + }, + { + "kind": "status_method", + "name": "rocksdb_enable_file_deletions", + "call_expr": "db->rep->EnableFileDeletions", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + } + ], + "method_args": [] + }, + { + "kind": "status_method", + "name": "rocksdb_verify_checksum", + "call_expr": "db->rep->VerifyChecksum", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + } + ], + "method_args": [] + }, + { + "kind": "status_method", + "name": "rocksdb_verify_file_checksums", + "call_expr": "db->rep->VerifyFileChecksums", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_t*", + "name": "db" + } + ], + "method_args": [ + "ReadOptions()" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_destroy_db", + "call_expr": "DestroyDB", + "params": [ + { + "kind": "scalar", + "c_type": "const rocksdb_options_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "const char*", + "name": "name" + } + ], + "method_args": [ + "name", + "options->rep" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_repair_db", + "call_expr": "RepairDB", + "params": [ + { + "kind": "scalar", + "c_type": "const rocksdb_options_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "const char*", + "name": "name" + } + ], + "method_args": [ + "name", + "options->rep" + ] + } + ] + }, + { + "name": "WriteBatch", + "functions": [ + { + "kind": "void_method", + "name": "rocksdb_writebatch_clear", + "call_expr": "b->rep.Clear", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "b" + } + ], + "method_args": [] + }, + { + "kind": "void_method", + "name": "rocksdb_writebatch_put", + "call_expr": "b->rep.Put", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "b" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vlen" + } + ], + "method_args": [ + "Slice(key, klen)", + "Slice(val, vlen)" + ] + }, + { + "kind": "void_method", + "name": "rocksdb_writebatch_put_cf", + "call_expr": "b->rep.Put", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "b" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vlen" + } + ], + "method_args": [ + "column_family->rep", + "Slice(key, klen)", + "Slice(val, vlen)" + ] + }, + { + "kind": "void_method", + "name": "rocksdb_writebatch_delete", + "call_expr": "b->rep.Delete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "b" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + } + ], + "method_args": [ + "Slice(key, klen)" + ] + }, + { + "kind": "void_method", + "name": "rocksdb_writebatch_put_log_data", + "call_expr": "b->rep.PutLogData", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "b" + }, + { + "kind": "slice", + "name": "blob", + "len_name": "len" + } + ], + "method_args": [ + "Slice(blob, len)" + ] + }, + { + "kind": "void_method", + "name": "rocksdb_writebatch_set_save_point", + "call_expr": "b->rep.SetSavePoint", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "b" + } + ], + "method_args": [] + }, + { + "kind": "status_method", + "name": "rocksdb_writebatch_rollback_to_save_point", + "call_expr": "b->rep.RollbackToSavePoint", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "b" + } + ], + "method_args": [] + }, + { + "kind": "status_method", + "name": "rocksdb_writebatch_pop_save_point", + "call_expr": "b->rep.PopSavePoint", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "b" + } + ], + "method_args": [] + }, + { + "kind": "status_method", + "name": "rocksdb_writebatch_verify_checksum", + "call_expr": "b->rep.VerifyChecksum", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "b" + } + ], + "method_args": [] + } + ] + }, + { + "name": "Transaction", + "functions": [ + { + "kind": "status_method", + "name": "rocksdb_transaction_put", + "call_expr": "txn->rep->Put", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vlen" + } + ], + "method_args": [ + "Slice(key, klen)", + "Slice(val, vlen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transaction_put_cf", + "call_expr": "txn->rep->Put", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vlen" + } + ], + "method_args": [ + "column_family->rep", + "Slice(key, klen)", + "Slice(val, vlen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transaction_merge", + "call_expr": "txn->rep->Merge", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vlen" + } + ], + "method_args": [ + "Slice(key, klen)", + "Slice(val, vlen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transaction_merge_cf", + "call_expr": "txn->rep->Merge", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vlen" + } + ], + "method_args": [ + "column_family->rep", + "Slice(key, klen)", + "Slice(val, vlen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transaction_delete", + "call_expr": "txn->rep->Delete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + } + ], + "method_args": [ + "Slice(key, klen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transaction_delete_cf", + "call_expr": "txn->rep->Delete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + } + ], + "method_args": [ + "column_family->rep", + "Slice(key, klen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transaction_commit", + "call_expr": "txn->rep->Commit", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + } + ], + "method_args": [] + }, + { + "kind": "status_method", + "name": "rocksdb_transaction_rollback", + "call_expr": "txn->rep->Rollback", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + } + ], + "method_args": [] + }, + { + "kind": "void_method", + "name": "rocksdb_transaction_put_log_data", + "call_expr": "txn->rep->PutLogData", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + }, + { + "kind": "slice", + "name": "blob", + "len_name": "len" + } + ], + "method_args": [ + "Slice(blob, len)" + ] + }, + { + "kind": "void_method", + "name": "rocksdb_transaction_set_savepoint", + "call_expr": "txn->rep->SetSavePoint", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + } + ], + "method_args": [] + }, + { + "kind": "status_method", + "name": "rocksdb_transaction_rollback_to_savepoint", + "call_expr": "txn->rep->RollbackToSavePoint", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transaction_t*", + "name": "txn" + } + ], + "method_args": [] + } + ] + }, + { + "name": "TransactionDB simple", + "functions": [ + { + "kind": "status_method", + "name": "rocksdb_transactiondb_put", + "call_expr": "txn_db->rep->Put", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transactiondb_t*", + "name": "txn_db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vlen" + } + ], + "method_args": [ + "options->rep", + "Slice(key, klen)", + "Slice(val, vlen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transactiondb_put_cf", + "call_expr": "txn_db->rep->Put", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transactiondb_t*", + "name": "txn_db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vallen" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(key, keylen)", + "Slice(val, vallen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transactiondb_write", + "call_expr": "db->rep->Write", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transactiondb_t*", + "name": "db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_writebatch_t*", + "name": "batch" + } + ], + "method_args": [ + "options->rep", + "&batch->rep" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transactiondb_merge", + "call_expr": "txn_db->rep->Merge", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transactiondb_t*", + "name": "txn_db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vlen" + } + ], + "method_args": [ + "options->rep", + "Slice(key, klen)", + "Slice(val, vlen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transactiondb_merge_cf", + "call_expr": "txn_db->rep->Merge", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transactiondb_t*", + "name": "txn_db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + }, + { + "kind": "slice", + "name": "val", + "len_name": "vlen" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(key, klen)", + "Slice(val, vlen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transactiondb_delete", + "call_expr": "txn_db->rep->Delete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transactiondb_t*", + "name": "txn_db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "slice", + "name": "key", + "len_name": "klen" + } + ], + "method_args": [ + "options->rep", + "Slice(key, klen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transactiondb_delete_cf", + "call_expr": "txn_db->rep->Delete", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transactiondb_t*", + "name": "txn_db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_writeoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + }, + { + "kind": "slice", + "name": "key", + "len_name": "keylen" + } + ], + "method_args": [ + "options->rep", + "column_family->rep", + "Slice(key, keylen)" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transactiondb_flush_wal", + "call_expr": "txn_db->rep->FlushWAL", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transactiondb_t*", + "name": "txn_db" + }, + { + "kind": "scalar", + "c_type": "unsigned char", + "name": "sync" + } + ], + "method_args": [ + "sync" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transactiondb_flush", + "call_expr": "txn_db->rep->Flush", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transactiondb_t*", + "name": "txn_db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_flushoptions_t*", + "name": "options" + } + ], + "method_args": [ + "options->rep" + ] + }, + { + "kind": "status_method", + "name": "rocksdb_transactiondb_flush_cf", + "call_expr": "txn_db->rep->Flush", + "params": [ + { + "kind": "scalar", + "c_type": "rocksdb_transactiondb_t*", + "name": "txn_db" + }, + { + "kind": "scalar", + "c_type": "const rocksdb_flushoptions_t*", + "name": "options" + }, + { + "kind": "scalar", + "c_type": "rocksdb_column_family_handle_t*", + "name": "column_family" + } + ], + "method_args": [ + "options->rep", + "column_family->rep" + ] + } + ] + }, + { + "name": "BlockBasedOptions simple", + "functions": [ + { + "kind": "field_setter", + "name": "rocksdb_block_based_options_set_data_block_hash_ratio", + "receiver_type": "rocksdb_block_based_table_options_t*", + "receiver_name": "options", + "value_type": "double", + "value_name": "v", + "field": "options->rep.data_block_hash_table_util_ratio" + }, + { + "kind": "field_setter", + "name": "rocksdb_block_based_options_set_top_level_index_pinning_tier", + "receiver_type": "rocksdb_block_based_table_options_t*", + "receiver_name": "options", + "value_type": "int", + "value_name": "v", + "field": "options->rep.metadata_cache_options.top_level_index_pinning", + "value_expr": "static_cast(v)" + }, + { + "kind": "field_setter", + "name": "rocksdb_block_based_options_set_partition_pinning_tier", + "receiver_type": "rocksdb_block_based_table_options_t*", + "receiver_name": "options", + "value_type": "int", + "value_name": "v", + "field": "options->rep.metadata_cache_options.partition_pinning", + "value_expr": "static_cast(v)" + }, + { + "kind": "field_setter", + "name": "rocksdb_block_based_options_set_unpartitioned_pinning_tier", + "receiver_type": "rocksdb_block_based_table_options_t*", + "receiver_name": "options", + "value_type": "int", + "value_name": "v", + "field": "options->rep.metadata_cache_options.unpartitioned_pinning", + "value_expr": "static_cast(v)" + } + ] + }, + { + "name": "JobInfo metadata simple", + "functions": [ + { + "kind": "field_getter", + "name": "rocksdb_compactionjobinfo_input_files_count", + "receiver_type": "const rocksdb_compactionjobinfo_t*", + "receiver_name": "info", + "return_type": "size_t", + "expr": "info->rep.input_files.size()" + }, + { + "kind": "field_getter", + "name": "rocksdb_compactionjobinfo_output_files_count", + "receiver_type": "const rocksdb_compactionjobinfo_t*", + "receiver_name": "info", + "return_type": "size_t", + "expr": "info->rep.output_files.size()" + }, + { + "kind": "field_getter", + "name": "rocksdb_compactionjobinfo_elapsed_micros", + "receiver_type": "const rocksdb_compactionjobinfo_t*", + "receiver_name": "info", + "return_type": "uint64_t", + "expr": "info->rep.stats.elapsed_micros" + }, + { + "kind": "field_getter", + "name": "rocksdb_compactionjobinfo_num_corrupt_keys", + "receiver_type": "const rocksdb_compactionjobinfo_t*", + "receiver_name": "info", + "return_type": "uint64_t", + "expr": "info->rep.stats.num_corrupt_keys" + }, + { + "kind": "field_getter", + "name": "rocksdb_compactionjobinfo_input_records", + "receiver_type": "const rocksdb_compactionjobinfo_t*", + "receiver_name": "info", + "return_type": "uint64_t", + "expr": "info->rep.stats.num_input_records" + }, + { + "kind": "field_getter", + "name": "rocksdb_compactionjobinfo_output_records", + "receiver_type": "const rocksdb_compactionjobinfo_t*", + "receiver_name": "info", + "return_type": "uint64_t", + "expr": "info->rep.stats.num_output_records" + }, + { + "kind": "field_getter", + "name": "rocksdb_compactionjobinfo_total_input_bytes", + "receiver_type": "const rocksdb_compactionjobinfo_t*", + "receiver_name": "info", + "return_type": "uint64_t", + "expr": "info->rep.stats.total_input_bytes" + }, + { + "kind": "field_getter", + "name": "rocksdb_compactionjobinfo_total_output_bytes", + "receiver_type": "const rocksdb_compactionjobinfo_t*", + "receiver_name": "info", + "return_type": "uint64_t", + "expr": "info->rep.stats.total_output_bytes" + }, + { + "kind": "field_getter", + "name": "rocksdb_compactionjobinfo_num_input_files", + "receiver_type": "const rocksdb_compactionjobinfo_t*", + "receiver_name": "info", + "return_type": "size_t", + "expr": "info->rep.stats.num_input_files" + }, + { + "kind": "field_getter", + "name": "rocksdb_compactionjobinfo_num_input_files_at_output_level", + "receiver_type": "const rocksdb_compactionjobinfo_t*", + "receiver_name": "info", + "return_type": "size_t", + "expr": "info->rep.stats.num_input_files_at_output_level" + }, + { + "kind": "string_field_getter", + "name": "rocksdb_writestallinfo_cf_name", + "receiver_type": "const rocksdb_writestallinfo_t*", + "receiver_name": "info", + "len_type": "size_t*", + "len_name": "size", + "expr": "info->rep.cf_name" + }, + { + "kind": "field_getter", + "name": "rocksdb_writestallinfo_cur", + "receiver_type": "const rocksdb_writestallinfo_t*", + "receiver_name": "info", + "return_type": "const rocksdb_writestallcondition_t*", + "expr": "reinterpret_cast(&info->rep.condition.cur)" + }, + { + "kind": "field_getter", + "name": "rocksdb_writestallinfo_prev", + "receiver_type": "const rocksdb_writestallinfo_t*", + "receiver_name": "info", + "return_type": "const rocksdb_writestallcondition_t*", + "expr": "reinterpret_cast(&info->rep.condition.prev)" + } + ] + }, + { + "name": "CuckooOptions simple", + "functions": [ + { + "kind": "field_setter", + "name": "rocksdb_cuckoo_options_set_hash_ratio", + "receiver_type": "rocksdb_cuckoo_table_options_t*", + "receiver_name": "options", + "value_type": "double", + "value_name": "v", + "field": "options->rep.hash_table_ratio" + } + ] + }, + { + "name": "Options simple", + "functions": [ + { + "kind": "field_setter", + "name": "rocksdb_options_set_compression_options_zstd_max_train_bytes", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "value_type": "int", + "value_name": "zstd_max_train_bytes", + "field": "opt->rep.compression_opts.zstd_max_train_bytes" + }, + { + "kind": "field_getter", + "name": "rocksdb_options_get_compression_options_zstd_max_train_bytes", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "return_type": "int", + "expr": "opt->rep.compression_opts.zstd_max_train_bytes" + }, + { + "kind": "field_setter", + "name": "rocksdb_options_set_compression_options_use_zstd_dict_trainer", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "value_type": "unsigned char", + "value_name": "use_zstd_dict_trainer", + "field": "opt->rep.compression_opts.use_zstd_dict_trainer" + }, + { + "kind": "field_getter", + "name": "rocksdb_options_get_compression_options_use_zstd_dict_trainer", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "return_type": "unsigned char", + "expr": "opt->rep.compression_opts.use_zstd_dict_trainer" + }, + { + "kind": "field_setter", + "name": "rocksdb_options_set_compression_options_parallel_threads", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "value_type": "int", + "value_name": "value", + "field": "opt->rep.compression_opts.parallel_threads" + }, + { + "kind": "field_getter", + "name": "rocksdb_options_get_compression_options_parallel_threads", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "return_type": "int", + "expr": "opt->rep.compression_opts.parallel_threads" + }, + { + "kind": "field_setter", + "name": "rocksdb_options_set_compression_options_max_dict_buffer_bytes", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "value_type": "uint64_t", + "value_name": "max_dict_buffer_bytes", + "field": "opt->rep.compression_opts.max_dict_buffer_bytes" + }, + { + "kind": "field_getter", + "name": "rocksdb_options_get_compression_options_max_dict_buffer_bytes", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "return_type": "uint64_t", + "expr": "opt->rep.compression_opts.max_dict_buffer_bytes" + }, + { + "kind": "field_getter", + "name": "rocksdb_options_get_bottommost_compression_options_use_zstd_dict_trainer", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "return_type": "unsigned char", + "expr": "opt->rep.bottommost_compression_opts.use_zstd_dict_trainer" + }, + { + "kind": "field_setter", + "name": "rocksdb_options_set_use_fsync", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "value_type": "int", + "value_name": "use_fsync", + "field": "opt->rep.use_fsync" + }, + { + "kind": "field_getter", + "name": "rocksdb_options_get_use_fsync", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "return_type": "int", + "expr": "opt->rep.use_fsync" + }, + { + "kind": "field_setter", + "name": "rocksdb_options_set_disable_auto_compactions", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "value_type": "int", + "value_name": "disable", + "field": "opt->rep.disable_auto_compactions" + }, + { + "kind": "field_setter", + "name": "rocksdb_options_set_optimize_filters_for_hits", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "value_type": "int", + "value_name": "v", + "field": "opt->rep.optimize_filters_for_hits" + }, + { + "kind": "field_setter", + "name": "rocksdb_options_set_report_bg_io_stats", + "receiver_type": "rocksdb_options_t*", + "receiver_name": "opt", + "value_type": "int", + "value_name": "v", + "field": "opt->rep.report_bg_io_stats" + } + ] + } + ] +} diff --git a/tools/c_api_gen/validate_generated_equivalence.py b/tools/c_api_gen/validate_generated_equivalence.py new file mode 100644 index 0000000000..294ea596e8 --- /dev/null +++ b/tools/c_api_gen/validate_generated_equivalence.py @@ -0,0 +1,487 @@ +# 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 the Apache 2.0 License (found in the LICENSE.Apache file in the root directory). + +#!/usr/bin/env python3 +"""Validate generated C API wrappers against a reference handwritten revision. + +This script compares the generated wrapper fragments currently included by +`include/rocksdb/c.h` and `db/c.cc` against the declarations/definitions in a +reference git revision, which defaults to `HEAD`. + +The intent is to provide a guardrail when migrating handwritten wrappers to the +code generator: + +- the generated declaration should match the old declaration shape +- the generated definition should match the old implementation shape +- known historical inconsistencies can be allowlisted with an explanation +""" + +from __future__ import annotations + +import argparse +import json +import re +import subprocess +import sys +from dataclasses import dataclass +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] + + +@dataclass +class FunctionDecl: + name: str + text: str + return_type: str + param_types: list[str] + + +@dataclass +class FunctionDef: + name: str + signature: str + return_type: str + param_types: list[str] + param_names: list[str] + body: str + + +def strip_comments(text: str) -> str: + text = re.sub(r"//.*", "", text) + text = re.sub(r"/\*.*?\*/", "", text, flags=re.S) + return text + + +def normalize_space(text: str) -> str: + return " ".join(strip_comments(text).split()) + + +TOKEN_RE = re.compile( + r'"(?:\\.|[^"\\])*"' + r"|'(?:\\.|[^'\\])*'" + r"|->|::|==|!=|<=|>=|&&|\|\|" + r"|[A-Za-z_][A-Za-z0-9_]*" + r"|[0-9]+" + r"|[{}()[\];,.*&<>!=+\-/%:?]" +) + +TYPE_WORD_PREFIXES = { + "const", + "volatile", + "unsigned", + "signed", + "short", + "long", +} + + +def tokenize(text: str) -> list[str]: + return TOKEN_RE.findall(strip_comments(text)) + + +def map_identifiers(tokens: list[str], mapping: dict[str, str]) -> list[str]: + return [mapping.get(tok, tok) for tok in tokens] + + +def normalize_return_casts(body: str, return_type: str) -> str: + escaped_type = re.escape(normalize_space(return_type)).replace(r"\ ", r"\s+") + pattern = re.compile( + rf"return\s+static_cast\s*<\s*{escaped_type}\s*>\s*\((.*?)\)\s*;", + re.S, + ) + return pattern.sub(lambda m: f"return {m.group(1).strip()};", body) + + +def find_matching(text: str, start: int, open_ch: str, close_ch: str) -> int: + assert text[start] == open_ch + depth = 0 + i = start + in_string = False + string_quote = "" + while i < len(text): + ch = text[i] + if in_string: + if ch == "\\": + i += 2 + continue + if ch == string_quote: + in_string = False + i += 1 + continue + if ch in ("'", '"'): + in_string = True + string_quote = ch + i += 1 + continue + if ch == open_ch: + depth += 1 + elif ch == close_ch: + depth -= 1 + if depth == 0: + return i + i += 1 + raise ValueError(f"Unmatched {open_ch} in text") + + +def find_signature_start(text: str, pos: int) -> int: + start = text.rfind("\n", 0, pos) + start = 0 if start < 0 else start + 1 + while start > 0: + prev_end = start - 1 + prev_start = text.rfind("\n", 0, prev_end) + prev_start = 0 if prev_start < 0 else prev_start + 1 + prev_line = text[prev_start:prev_end].strip() + if not prev_line: + break + if prev_line.startswith("//"): + break + if prev_line.endswith(";") or prev_line.endswith("}") or prev_line.endswith("{"): + break + start = prev_start + return start + + +def split_top_level(text: str, delimiter: str) -> list[str]: + parts: list[str] = [] + depth_paren = depth_angle = depth_bracket = 0 + start = 0 + i = 0 + while i < len(text): + ch = text[i] + if ch == "(": + depth_paren += 1 + elif ch == ")": + depth_paren -= 1 + elif ch == "<": + depth_angle += 1 + elif ch == ">": + depth_angle -= 1 + elif ch == "[": + depth_bracket += 1 + elif ch == "]": + depth_bracket -= 1 + elif ( + ch == delimiter + and depth_paren == 0 + and depth_angle == 0 + and depth_bracket == 0 + ): + parts.append(text[start:i].strip()) + start = i + 1 + i += 1 + tail = text[start:].strip() + if tail: + parts.append(tail) + return parts + + +def parse_param_decl(param: str) -> tuple[str, str]: + param = normalize_space(param) + if not param or param == "void": + return "", "" + if "(" in param and "*" in param: + raise ValueError(f"Unsupported function pointer parameter: {param}") + m = re.match(r"^(.*?)([A-Za-z_][A-Za-z0-9_]*)$", param) + if not m: + return param, "" + type_part = m.group(1).strip() + name = m.group(2) + return normalize_space(type_part), name + + +def parse_param_type_only(param: str) -> str: + param = normalize_space(param) + if not param or param == "void": + return "" + if "(" in param and "*" in param: + raise ValueError(f"Unsupported function pointer parameter: {param}") + tokens = re.findall(r"[A-Za-z_][A-Za-z0-9_]*|[&*\[\]]", param) + if not tokens: + return param + if tokens[-1] in {"*", "&", "[", "]"}: + return param + if len(tokens) == 1: + return param + if len(tokens) == 2 and tokens[0] in TYPE_WORD_PREFIXES: + return param + # Treat the trailing identifier as the parameter name. + m = re.match(r"^(.*?)([A-Za-z_][A-Za-z0-9_]*)$", param) + if not m: + return param + return normalize_space(m.group(1).strip()) + + +def parse_signature_shape( + signature: str, name: str, require_param_names: bool +) -> tuple[str, list[str], list[str]]: + signature = normalize_space(signature) + signature = re.sub(r"\bextern\b", "", signature) + signature = re.sub(r"\bROCKSDB_LIBRARY_API\b", "", signature) + signature = normalize_space(signature) + marker = f"{name}(" + pos = signature.find(marker) + if pos < 0: + raise ValueError(f"Could not find function name {name} in signature") + return_type = normalize_space(signature[:pos].strip()) + params_start = pos + len(name) + assert signature[params_start] == "(" + params_end = find_matching(signature, params_start, "(", ")") + params_text = signature[params_start + 1 : params_end] + param_types: list[str] = [] + param_names: list[str] = [] + if params_text.strip(): + for raw_param in split_top_level(params_text, ","): + if require_param_names: + ptype, pname = parse_param_decl(raw_param) + else: + ptype, pname = parse_param_type_only(raw_param), "" + if ptype: + param_types.append(ptype) + param_names.append(pname) + return return_type, param_types, param_names + + +def extract_function_decls(text: str) -> dict[str, FunctionDecl]: + result: dict[str, FunctionDecl] = {} + pos = 0 + while True: + start = text.find("extern ROCKSDB_LIBRARY_API", pos) + if start < 0: + break + semi = text.find(";", start) + if semi < 0: + break + snippet = text[start : semi + 1] + m = re.search(r"\b(rocksdb_[A-Za-z0-9_]+)\s*\(", snippet) + if m: + name = m.group(1) + try: + return_type, param_types, _ = parse_signature_shape( + snippet[:-1], name, require_param_names=False + ) + result[name] = FunctionDecl( + name=name, + text=snippet, + return_type=return_type, + param_types=param_types, + ) + except ValueError: + pass + pos = semi + 1 + return result + + +def extract_function_defs(text: str) -> dict[str, FunctionDef]: + result: dict[str, FunctionDef] = {} + pattern = re.compile(r"\b(rocksdb_[A-Za-z0-9_]+)\s*\(") + pos = 0 + while True: + m = pattern.search(text, pos) + if not m: + break + name = m.group(1) + paren_start = text.find("(", m.start(1)) + paren_end = find_matching(text, paren_start, "(", ")") + body_start = paren_end + 1 + while body_start < len(text) and text[body_start].isspace(): + body_start += 1 + if body_start >= len(text) or text[body_start] != "{": + pos = m.end(1) + continue + sig_start = find_signature_start(text, m.start(1)) + signature = text[sig_start:paren_end + 1] + body_end = find_matching(text, body_start, "{", "}") + body = text[body_start : body_end + 1] + try: + return_type, param_types, param_names = parse_signature_shape( + signature, name, require_param_names=True + ) + result[name] = FunctionDef( + name=name, + signature=signature, + return_type=return_type, + param_types=param_types, + param_names=param_names, + body=body, + ) + except ValueError: + pass + pos = body_end + 1 + return result + + +def git_show(rev: str, path: str) -> str: + return subprocess.check_output( + ["git", "show", f"{rev}:{path}"], cwd=ROOT, text=True + ) + + +def active_generated_paths( + path: Path, include_prefix: str, root_prefix: str +) -> list[Path]: + text = path.read_text() + pattern = re.compile(rf'#include "{re.escape(include_prefix)}/(c_generated_[^"]+)"') + return [ROOT / root_prefix / m.group(1) for m in pattern.finditer(text)] + + +def load_allowlist(path: Path | None) -> dict[str, str]: + if path is None or not path.exists(): + return {} + data = json.loads(path.read_text()) + return {entry["name"]: entry["reason"] for entry in data.get("allowlist", [])} + + +def compare_headers( + generated_headers: list[Path], + ref_header_text: str, + allowlist: dict[str, str], +) -> list[str]: + ref = extract_function_decls(ref_header_text) + failures: list[str] = [] + for path in generated_headers: + for name, generated in extract_function_decls(path.read_text()).items(): + if name in allowlist: + continue + ref_decl = ref.get(name) + if ref_decl is None: + failures.append( + f"[header missing] {name}: not declared in reference include/rocksdb/c.h" + ) + continue + if ( + generated.return_type != ref_decl.return_type + or generated.param_types != ref_decl.param_types + ): + failures.append( + f"[header mismatch] {name}: generated " + f"{generated.return_type}({', '.join(generated.param_types)}) " + f"!= reference {ref_decl.return_type}" + f"({', '.join(ref_decl.param_types)})" + ) + return failures + + +def compare_sources( + generated_sources: list[Path], + ref_source_text: str, + allowlist: dict[str, str], +) -> list[str]: + ref = extract_function_defs(ref_source_text) + failures: list[str] = [] + for path in generated_sources: + for name, generated in extract_function_defs(path.read_text()).items(): + if name in allowlist: + continue + ref_def = ref.get(name) + if ref_def is None: + failures.append( + f"[source missing] {name}: not defined in reference db/c.cc" + ) + continue + if ( + generated.return_type != ref_def.return_type + or generated.param_types != ref_def.param_types + ): + failures.append( + f"[source signature mismatch] {name}: generated " + f"{generated.return_type}({', '.join(generated.param_types)}) " + f"!= reference {ref_def.return_type}" + f"({', '.join(ref_def.param_types)})" + ) + continue + mapping = { + ref_name: gen_name + for ref_name, gen_name in zip(ref_def.param_names, generated.param_names) + if ref_name and gen_name + } + ref_body = normalize_return_casts(ref_def.body, generated.return_type) + gen_body = normalize_return_casts(generated.body, generated.return_type) + ref_tokens = map_identifiers(tokenize(ref_body), mapping) + gen_tokens = tokenize(gen_body) + if ref_tokens != gen_tokens: + failures.append(f"[source body mismatch] {name}") + return failures + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument( + "--ref", + required=True, + help=( + "Reference git revision to compare the generated wrappers against. " + "This must be a PRE-migration revision that still had the " + "hand-written wrappers (e.g. a release tag from before codegen " + "landed); comparing against a post-migration revision is a " + "tautology because the reference is itself generated. This is a " + "best-effort body-equivalence aid; the authoritative, ongoing " + "backward-compatibility gate is check_api_compatibility.py." + ), + ) + parser.add_argument( + "--allowlist", + type=Path, + default=ROOT / "tools/c_api_gen/equivalence_allowlist.json", + help="JSON allowlist for intentional historical differences", + ) + parser.add_argument( + "--generated-header", + action="append", + type=Path, + default=[], + help="Generated header fragment(s) to validate. Defaults to active includes.", + ) + parser.add_argument( + "--generated-source", + action="append", + type=Path, + default=[], + help="Generated source fragment(s) to validate. Defaults to active includes.", + ) + args = parser.parse_args() + + generated_headers = ( + args.generated_header + if args.generated_header + else active_generated_paths( + ROOT / "tools/c_api_gen/c_base.h", "c_api_gen", "c_api_gen" + ) + ) + generated_sources = ( + args.generated_source + if args.generated_source + else active_generated_paths( + ROOT / "tools/c_api_gen/c_base.cc", "c_api_gen", "c_api_gen" + ) + ) + allowlist = load_allowlist(args.allowlist) + + ref_header_text = git_show(args.ref, "include/rocksdb/c.h") + ref_source_text = git_show(args.ref, "db/c.cc") + + failures = [] + failures.extend(compare_headers(generated_headers, ref_header_text, allowlist)) + failures.extend(compare_sources(generated_sources, ref_source_text, allowlist)) + + if failures: + for name, reason in sorted(allowlist.items()): + print(f"[allowlist] {name}: {reason}") + for failure in failures: + print(failure) + return 1 + + print( + "Validated generated wrappers against " + f"{args.ref}: {len(generated_headers)} header fragments, " + f"{len(generated_sources)} source fragments." + ) + if allowlist: + print(f"Applied allowlist entries: {len(allowlist)}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/c_api_gen/verify_generated_up_to_date.py b/tools/c_api_gen/verify_generated_up_to_date.py new file mode 100644 index 0000000000..30b3fad81b --- /dev/null +++ b/tools/c_api_gen/verify_generated_up_to_date.py @@ -0,0 +1,166 @@ +# 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 the Apache 2.0 License (found in the LICENSE.Apache file in the root directory). + +#!/usr/bin/env python3 +"""Verify checked-in C API generated fragments are up to date without Git.""" + +from __future__ import annotations + +import argparse +import shutil +import subprocess +import sys +import tempfile +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +REGEN_ALL = ROOT / "tools/c_api_gen/regen_all.py" +CLANG_FORMAT_STYLE_FILE = ROOT / ".clang-format" +GENERATED_DIRS = ( + Path("c_api_gen"), +) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description=( + "Regenerate the checked-in C API fragments and compare them against " + "a pre-regen snapshot without relying on git diff." + ) + ) + parser.add_argument( + "--clang-format", + default="clang-format", + help=( + "clang-format binary to canonicalize both the pre-regen snapshot " + "and regenerated output before comparison (default: clang-format)" + ), + ) + return parser.parse_args() + + +def resolve_executable(command: str) -> str: + if Path(command).parent != Path(): + if Path(command).exists(): + return str(Path(command)) + raise FileNotFoundError(f"Executable not found: {command}") + + resolved = shutil.which(command) + if resolved is None: + raise FileNotFoundError( + f"{command} not found in PATH. Install it or pass --clang-format." + ) + return resolved + + +# c.h and c.cc are also generated artifacts inlined from c_base.* + .inc fragments +GENERATED_FILES = ( + Path("include/rocksdb/c.h"), + Path("db/c.cc"), +) + + +def copy_generated_dirs(destination_root: Path) -> None: + for rel_dir in GENERATED_DIRS: + source = ROOT / rel_dir + if not source.is_dir(): + raise FileNotFoundError(f"Generated directory missing: {source}") + + destination = destination_root / rel_dir + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copytree(source, destination) + for rel_file in GENERATED_FILES: + source = ROOT / rel_file + if not source.is_file(): + raise FileNotFoundError(f"Generated file missing: {source}") + destination = destination_root / rel_file + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(source, destination) + + +def collect_inc_files(root: Path) -> list[str]: + inc_files: list[str] = [] + for rel_dir in GENERATED_DIRS: + directory = root / rel_dir + if not directory.is_dir(): + raise FileNotFoundError(f"Generated directory missing: {directory}") + inc_files.extend(str(path) for path in sorted(directory.rglob("*.inc"))) + return inc_files + + +def format_generated_dirs(root: Path, clang_format: str) -> None: + inc_files = collect_inc_files(root) + if not inc_files: + raise RuntimeError(f"No generated .inc files found under {root}") + subprocess.run( + [ + clang_format, + f"--style=file:{CLANG_FORMAT_STYLE_FILE}", + "-i", + *inc_files, + ], + cwd=root, + check=True, + ) + + +def compare_snapshots(work_root: Path) -> int: + proc = subprocess.run( + ["diff", "-ruN", "checked_in", "regenerated"], + cwd=work_root, + text=True, + capture_output=True, + check=False, + ) + if proc.returncode == 0: + print("C API generated files are up to date.") + return 0 + + if proc.returncode == 1: + sys.stderr.write( + "C API generated files are out of date. Re-run " + "`python3 tools/c_api_gen/regen_all.py` and commit the updated " + "files under c_api_gen/, " + "include/rocksdb/c.h, and db/c.cc.\n" + ) + if proc.stdout: + sys.stderr.write(proc.stdout) + return 1 + + if proc.stdout: + sys.stderr.write(proc.stdout) + if proc.stderr: + sys.stderr.write(proc.stderr) + raise RuntimeError(f"diff failed with exit code {proc.returncode}") + + +def main() -> int: + args = parse_args() + clang_format = resolve_executable(args.clang_format) + + with tempfile.TemporaryDirectory(prefix="rocksdb-c-api-gen-verify-") as tmp: + work_root = Path(tmp) + checked_in_root = work_root / "checked_in" + regenerated_root = work_root / "regenerated" + + copy_generated_dirs(checked_in_root) + format_generated_dirs(checked_in_root, clang_format) + + # Pass the pinned formatter down so the regenerated .inc fragments (and + # thus the inlined c.h/c.cc) are canonicalized with the same clang-format + # version on both sides of the comparison. + subprocess.run( + [sys.executable, str(REGEN_ALL), "--clang-format", args.clang_format], + cwd=ROOT, + check=True, + ) + format_generated_dirs(ROOT, clang_format) + + copy_generated_dirs(regenerated_root) + return compare_snapshots(work_root) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/db_crashtest_test.py b/tools/db_crashtest_test.py index ad92621eb5..0e17b559eb 100644 --- a/tools/db_crashtest_test.py +++ b/tools/db_crashtest_test.py @@ -1,10 +1,8 @@ +#!/usr/bin/env python3 # 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 the Apache 2.0 License (found in the LICENSE.Apache file in the root directory). -#!/usr/bin/env python3 -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. - import importlib.util import io import os @@ -130,7 +128,13 @@ class DBCrashTestTest(unittest.TestCase): db_crashtest = self.load_db_crashtest() params = self.build_params( db_crashtest.default_params, - {"disable_wal": 1, "test_batches_snapshots": 1}, + { + "disable_wal": 1, + "test_batches_snapshots": 1, + # finalize_and_sanitize() intentionally forces disable_wal=0 + # when inplace_update_support=1. + "inplace_update_support": 0, + }, ) finalized = db_crashtest.finalize_and_sanitize(params) diff --git a/unreleased_history/public_api_changes/c_api_codegen_bindings.md b/unreleased_history/public_api_changes/c_api_codegen_bindings.md new file mode 100644 index 0000000000..d148596116 --- /dev/null +++ b/unreleased_history/public_api_changes/c_api_codegen_bindings.md @@ -0,0 +1 @@ +Expanded the C API (`include/rocksdb/c.h`) with a large set of new `rocksdb_*` functions, mostly option getters/setters plus table-properties, job/event-listener, and metadata accessors, a WAL filter, a ReadOptions table filter, and a backup exclude-files callback. Many are now produced by a new semi-automated generator (`tools/c_api_gen/`) from the C++ headers; `include/rocksdb/c.h` remains a single self-contained header and the signatures of pre-existing functions are unchanged. diff --git a/utilities/trie_index/trie_index_factory.cc b/utilities/trie_index/trie_index_factory.cc index 01002b5de6..1fd6b411fa 100644 --- a/utilities/trie_index/trie_index_factory.cc +++ b/utilities/trie_index/trie_index_factory.cc @@ -11,11 +11,26 @@ #include "db/dbformat.h" #include "rocksdb/comparator.h" +#include "rocksdb/utilities/object_registry.h" #include "util/coding.h" namespace ROCKSDB_NAMESPACE { namespace trie_index { +int RegisterBuiltinTrieIndexFactory(ObjectLibrary& library, + const std::string& /*arg*/) { + library.AddFactory( + TrieIndexFactory::kClassName(), + [](const std::string& /*uri*/, + std::unique_ptr* guard, + std::string* /*errmsg*/) { + guard->reset(new TrieIndexFactory()); + return guard->get(); + }); + size_t num_types; + return static_cast(library.GetFactoryCount(&num_types)); +} + // ============================================================================ // TrieIndexBuilder // ============================================================================ diff --git a/utilities/trie_index/trie_index_factory.h b/utilities/trie_index/trie_index_factory.h index 61d5c9a6fc..f257c4fbfb 100644 --- a/utilities/trie_index/trie_index_factory.h +++ b/utilities/trie_index/trie_index_factory.h @@ -39,8 +39,14 @@ #include "utilities/trie_index/louds_trie.h" namespace ROCKSDB_NAMESPACE { +class ObjectLibrary; + namespace trie_index { +// Registers the built-in trie UDI in the supplied object library. +int RegisterBuiltinTrieIndexFactory(ObjectLibrary& library, + const std::string& arg); + // ============================================================================ // TrieIndexBuilder: Implements UserDefinedIndexBuilder using LoudsTrieBuilder. //