rust-librocksdb-sys 0.43.0+11.0.4

Native bindings to librocksdb
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
//  This source code is licensed under both the GPLv2 (found in the
//  COPYING file in the root directory) and Apache 2.0 License
//  (found in the LICENSE.Apache file in the root directory).
//
// This file implements the "bridge" between Java and C++ for
// ROCKSDB_NAMESPACE::Options.

#include "rocksdb/table.h"

#include <jni.h>

#include "include/org_rocksdb_BlockBasedTableConfig.h"
#include "include/org_rocksdb_PlainTableConfig.h"
#include "portal.h"
#include "rocksdb/cache.h"
#include "rocksdb/filter_policy.h"
#include "rocksjni/cplusplus_to_java_convert.h"

/*
 * Class:     org_rocksdb_PlainTableConfig
 * Method:    newTableFactoryHandle
 * Signature: (IIDIIBZZ)J
 */
jlong Java_org_rocksdb_PlainTableConfig_newTableFactoryHandle(
    JNIEnv* /*env*/, jclass /*jcls*/, jint jkey_size, jint jbloom_bits_per_key,
    jdouble jhash_table_ratio, jint jindex_sparseness, jint jhuge_page_tlb_size,
    jbyte jencoding_type, jboolean jfull_scan_mode,
    jboolean jstore_index_in_file) {
  ROCKSDB_NAMESPACE::PlainTableOptions options =
      ROCKSDB_NAMESPACE::PlainTableOptions();
  options.user_key_len = jkey_size;
  options.bloom_bits_per_key = jbloom_bits_per_key;
  options.hash_table_ratio = jhash_table_ratio;
  options.index_sparseness = jindex_sparseness;
  options.huge_page_tlb_size = jhuge_page_tlb_size;
  options.encoding_type =
      static_cast<ROCKSDB_NAMESPACE::EncodingType>(jencoding_type);
  options.full_scan_mode = jfull_scan_mode;
  options.store_index_in_file = jstore_index_in_file;
  return GET_CPLUSPLUS_POINTER(
      ROCKSDB_NAMESPACE::NewPlainTableFactory(options));
}

/*
 * Class:     org_rocksdb_BlockBasedTableConfig
 * Method:    newTableFactoryHandle
 * Signature: (ZZZZBBDBZJJJIIIJZZZJZZIIZZJJBBJI)J
 */
jlong Java_org_rocksdb_BlockBasedTableConfig_newTableFactoryHandle(
    JNIEnv*, jclass, jboolean jcache_index_and_filter_blocks,
    jboolean jcache_index_and_filter_blocks_with_high_priority,
    jboolean jpin_l0_filter_and_index_blocks_in_cache,
    jboolean jpin_top_level_index_and_filter, jbyte jindex_type_value,
    jbyte jdata_block_index_type_value,
    jdouble jdata_block_hash_table_util_ratio, jbyte jchecksum_type_value,
    jboolean jno_block_cache, jlong jblock_cache_handle,
    jlong jpersistent_cache_handle, jlong jblock_size,
    jint jblock_size_deviation, jint jblock_restart_interval,
    jint jindex_block_restart_interval, jlong jmetadata_block_size,
    jboolean jpartition_filters, jboolean joptimize_filters_for_memory,
    jboolean juse_delta_encoding, jlong jfilter_policy_handle,
    jboolean jwhole_key_filtering, jboolean jverify_compression,
    jint jread_amp_bytes_per_bit, jint jformat_version,
    jboolean jseparate_key_value_in_data_block,
    jboolean jenable_index_compression, jboolean jblock_align,
    jlong jsuper_block_alignment_size,
    jlong jsuper_block_alignment_space_overhead_ratio, jbyte jindex_shortening,
    jbyte jindex_search_type, jlong jblock_cache_size,
    jint jblock_cache_num_shard_bits) {
  ROCKSDB_NAMESPACE::BlockBasedTableOptions options;
  options.cache_index_and_filter_blocks =
      static_cast<bool>(jcache_index_and_filter_blocks);
  options.cache_index_and_filter_blocks_with_high_priority =
      static_cast<bool>(jcache_index_and_filter_blocks_with_high_priority);
  options.pin_l0_filter_and_index_blocks_in_cache =
      static_cast<bool>(jpin_l0_filter_and_index_blocks_in_cache);
  options.pin_top_level_index_and_filter =
      static_cast<bool>(jpin_top_level_index_and_filter);
  options.index_type =
      ROCKSDB_NAMESPACE::IndexTypeJni::toCppIndexType(jindex_type_value);
  options.data_block_index_type =
      ROCKSDB_NAMESPACE::DataBlockIndexTypeJni::toCppDataBlockIndexType(
          jdata_block_index_type_value);
  options.data_block_hash_table_util_ratio =
      static_cast<double>(jdata_block_hash_table_util_ratio);
  options.checksum = ROCKSDB_NAMESPACE::ChecksumTypeJni::toCppChecksumType(
      jchecksum_type_value);
  options.no_block_cache = static_cast<bool>(jno_block_cache);
  if (options.no_block_cache) {
    options.block_cache = nullptr;
  } else {
    if (jblock_cache_handle > 0) {
      std::shared_ptr<ROCKSDB_NAMESPACE::Cache>* pCache =
          reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::Cache>*>(
              jblock_cache_handle);
      options.block_cache = *pCache;
    } else if (jblock_cache_size >= 0) {
      if (jblock_cache_num_shard_bits > 0) {
        options.block_cache = ROCKSDB_NAMESPACE::NewLRUCache(
            static_cast<size_t>(jblock_cache_size),
            static_cast<int>(jblock_cache_num_shard_bits));
      } else {
        options.block_cache = ROCKSDB_NAMESPACE::NewLRUCache(
            static_cast<size_t>(jblock_cache_size));
      }
    } else {
      options.no_block_cache = true;
      options.block_cache = nullptr;
    }
  }
  if (jpersistent_cache_handle > 0) {
    std::shared_ptr<ROCKSDB_NAMESPACE::PersistentCache>* pCache =
        reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::PersistentCache>*>(
            jpersistent_cache_handle);
    options.persistent_cache = *pCache;
  }
  options.block_size = static_cast<size_t>(jblock_size);
  options.block_size_deviation = static_cast<int>(jblock_size_deviation);
  options.block_restart_interval = static_cast<int>(jblock_restart_interval);
  options.index_block_restart_interval =
      static_cast<int>(jindex_block_restart_interval);
  options.metadata_block_size = static_cast<uint64_t>(jmetadata_block_size);
  options.partition_filters = static_cast<bool>(jpartition_filters);
  options.optimize_filters_for_memory =
      static_cast<bool>(joptimize_filters_for_memory);
  options.use_delta_encoding = static_cast<bool>(juse_delta_encoding);
  if (jfilter_policy_handle > 0) {
    std::shared_ptr<ROCKSDB_NAMESPACE::FilterPolicy>* pFilterPolicy =
        reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::FilterPolicy>*>(
            jfilter_policy_handle);
    options.filter_policy = *pFilterPolicy;
  }
  options.whole_key_filtering = static_cast<bool>(jwhole_key_filtering);
  options.verify_compression = static_cast<bool>(jverify_compression);
  options.read_amp_bytes_per_bit =
      static_cast<uint32_t>(jread_amp_bytes_per_bit);
  options.format_version = static_cast<uint32_t>(jformat_version);
  options.separate_key_value_in_data_block =
      static_cast<bool>(jseparate_key_value_in_data_block);
  options.enable_index_compression =
      static_cast<bool>(jenable_index_compression);
  options.block_align = static_cast<bool>(jblock_align);
  options.super_block_alignment_size =
      static_cast<size_t>(jsuper_block_alignment_size);
  options.super_block_alignment_space_overhead_ratio =
      static_cast<size_t>(jsuper_block_alignment_space_overhead_ratio);
  options.index_shortening =
      ROCKSDB_NAMESPACE::IndexShorteningModeJni::toCppIndexShorteningMode(
          jindex_shortening);
  options.index_block_search_type =
      ROCKSDB_NAMESPACE::IndexSearchTypeJni::toCppIndexSearchType(
          jindex_search_type);

  return GET_CPLUSPLUS_POINTER(
      ROCKSDB_NAMESPACE::NewBlockBasedTableFactory(options));
}