ceph/src/rocksdb/java/rocksjni/write_batch_test.cc

   1 // Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5 //
   6 // This file implements the "bridge" between Java and C++ and enables
   7 // calling c++ ROCKSDB_NAMESPACE::WriteBatch methods testing from Java side.
   8 #include "rocksdb/write_batch.h"
   9
  10 #include <memory>
  11
  12 #include "db/memtable.h"
  13 #include "db/write_batch_internal.h"
  14 #include "include/org_rocksdb_WriteBatch.h"
  15 #include "include/org_rocksdb_WriteBatchTest.h"
  16 #include "include/org_rocksdb_WriteBatchTestInternalHelper.h"
  17 #include "include/org_rocksdb_WriteBatch_Handler.h"
  18 #include "options/cf_options.h"
  19 #include "rocksdb/db.h"
  20 #include "rocksdb/env.h"
  21 #include "rocksdb/memtablerep.h"
  22 #include "rocksdb/status.h"
  23 #include "rocksdb/write_buffer_manager.h"
  24 #include "rocksjni/portal.h"
  25 #include "table/scoped_arena_iterator.h"
  26 #include "test_util/testharness.h"
  27 #include "util/string_util.h"
  28
  29 /*
  30  * Class:     org_rocksdb_WriteBatchTest
  31  * Method:    getContents
  32  * Signature: (J)[B
  33  */
  34 jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env,
  35                                                        jclass /*jclazz*/,
  36                                                        jlong jwb_handle) {
  37   auto* b = reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch*>(jwb_handle);
  38   assert(b != nullptr);
  39
  40   // todo: Currently the following code is directly copied from
  41   // db/write_bench_test.cc.  It could be implemented in java once
  42   // all the necessary components can be accessed via jni api.
  43
  44   ROCKSDB_NAMESPACE::InternalKeyComparator cmp(
  45       ROCKSDB_NAMESPACE::BytewiseComparator());
  46   auto factory = std::make_shared<ROCKSDB_NAMESPACE::SkipListFactory>();
  47   ROCKSDB_NAMESPACE::Options options;
  48   ROCKSDB_NAMESPACE::WriteBufferManager wb(options.db_write_buffer_size);
  49   options.memtable_factory = factory;
  50   ROCKSDB_NAMESPACE::MemTable* mem = new ROCKSDB_NAMESPACE::MemTable(
  51       cmp, ROCKSDB_NAMESPACE::ImmutableOptions(options),
  52       ROCKSDB_NAMESPACE::MutableCFOptions(options), &wb,
  53       ROCKSDB_NAMESPACE::kMaxSequenceNumber, 0 /* column_family_id */);
  54   mem->Ref();
  55   std::string state;
  56   ROCKSDB_NAMESPACE::ColumnFamilyMemTablesDefault cf_mems_default(mem);
  57   ROCKSDB_NAMESPACE::Status s =
  58       ROCKSDB_NAMESPACE::WriteBatchInternal::InsertInto(b, &cf_mems_default,
  59                                                         nullptr, nullptr);
  60   unsigned int count = 0;
  61   ROCKSDB_NAMESPACE::Arena arena;
  62   ROCKSDB_NAMESPACE::ScopedArenaIterator iter(
  63       mem->NewIterator(ROCKSDB_NAMESPACE::ReadOptions(), &arena));
  64   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
  65     ROCKSDB_NAMESPACE::ParsedInternalKey ikey;
  66     ikey.clear();
  67     ROCKSDB_NAMESPACE::Status pik_status = ROCKSDB_NAMESPACE::ParseInternalKey(
  68         iter->key(), &ikey, true /* log_err_key */);
  69     pik_status.PermitUncheckedError();
  70     assert(pik_status.ok());
  71     switch (ikey.type) {
  72       case ROCKSDB_NAMESPACE::kTypeValue:
  73         state.append("Put(");
  74         state.append(ikey.user_key.ToString());
  75         state.append(", ");
  76         state.append(iter->value().ToString());
  77         state.append(")");
  78         count++;
  79         break;
  80       case ROCKSDB_NAMESPACE::kTypeMerge:
  81         state.append("Merge(");
  82         state.append(ikey.user_key.ToString());
  83         state.append(", ");
  84         state.append(iter->value().ToString());
  85         state.append(")");
  86         count++;
  87         break;
  88       case ROCKSDB_NAMESPACE::kTypeDeletion:
  89         state.append("Delete(");
  90         state.append(ikey.user_key.ToString());
  91         state.append(")");
  92         count++;
  93         break;
  94       case ROCKSDB_NAMESPACE::kTypeSingleDeletion:
  95         state.append("SingleDelete(");
  96         state.append(ikey.user_key.ToString());
  97         state.append(")");
  98         count++;
  99         break;
 100       case ROCKSDB_NAMESPACE::kTypeRangeDeletion:
 101         state.append("DeleteRange(");
 102         state.append(ikey.user_key.ToString());
 103         state.append(", ");
 104         state.append(iter->value().ToString());
 105         state.append(")");
 106         count++;
 107         break;
 108       case ROCKSDB_NAMESPACE::kTypeLogData:
 109         state.append("LogData(");
 110         state.append(ikey.user_key.ToString());
 111         state.append(")");
 112         count++;
 113         break;
 114       default:
 115         assert(false);
 116         state.append("Err:Expected(");
 117         state.append(std::to_string(ikey.type));
 118         state.append(")");
 119         count++;
 120         break;
 121     }
 122     state.append("@");
 123     state.append(std::to_string(ikey.sequence));
 124   }
 125   if (!s.ok()) {
 126     state.append(s.ToString());
 127   } else if (ROCKSDB_NAMESPACE::WriteBatchInternal::Count(b) != count) {
 128     state.append("Err:CountMismatch(expected=");
 129     state.append(
 130         std::to_string(ROCKSDB_NAMESPACE::WriteBatchInternal::Count(b)));
 131     state.append(", actual=");
 132     state.append(std::to_string(count));
 133     state.append(")");
 134   }
 135   delete mem->Unref();
 136
 137   jbyteArray jstate = env->NewByteArray(static_cast<jsize>(state.size()));
 138   if (jstate == nullptr) {
 139     // exception thrown: OutOfMemoryError
 140     return nullptr;
 141   }
 142
 143   env->SetByteArrayRegion(
 144       jstate, 0, static_cast<jsize>(state.size()),
 145       const_cast<jbyte*>(reinterpret_cast<const jbyte*>(state.c_str())));
 146   if (env->ExceptionCheck()) {
 147     // exception thrown: ArrayIndexOutOfBoundsException
 148     env->DeleteLocalRef(jstate);
 149     return nullptr;
 150   }
 151
 152   return jstate;
 153 }
 154
 155 /*
 156  * Class:     org_rocksdb_WriteBatchTestInternalHelper
 157  * Method:    setSequence
 158  * Signature: (JJ)V
 159  */
 160 void Java_org_rocksdb_WriteBatchTestInternalHelper_setSequence(
 161     JNIEnv* /*env*/, jclass /*jclazz*/, jlong jwb_handle, jlong jsn) {
 162   auto* wb = reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch*>(jwb_handle);
 163   assert(wb != nullptr);
 164
 165   ROCKSDB_NAMESPACE::WriteBatchInternal::SetSequence(
 166       wb, static_cast<ROCKSDB_NAMESPACE::SequenceNumber>(jsn));
 167 }
 168
 169 /*
 170  * Class:     org_rocksdb_WriteBatchTestInternalHelper
 171  * Method:    sequence
 172  * Signature: (J)J
 173  */
 174 jlong Java_org_rocksdb_WriteBatchTestInternalHelper_sequence(JNIEnv* /*env*/,
 175                                                              jclass /*jclazz*/,
 176                                                              jlong jwb_handle) {
 177   auto* wb = reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch*>(jwb_handle);
 178   assert(wb != nullptr);
 179
 180   return static_cast<jlong>(
 181       ROCKSDB_NAMESPACE::WriteBatchInternal::Sequence(wb));
 182 }
 183
 184 /*
 185  * Class:     org_rocksdb_WriteBatchTestInternalHelper
 186  * Method:    append
 187  * Signature: (JJ)V
 188  */
 189 void Java_org_rocksdb_WriteBatchTestInternalHelper_append(JNIEnv* /*env*/,
 190                                                           jclass /*jclazz*/,
 191                                                           jlong jwb_handle_1,
 192                                                           jlong jwb_handle_2) {
 193   auto* wb1 = reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch*>(jwb_handle_1);
 194   assert(wb1 != nullptr);
 195   auto* wb2 = reinterpret_cast<ROCKSDB_NAMESPACE::WriteBatch*>(jwb_handle_2);
 196   assert(wb2 != nullptr);
 197
 198   ROCKSDB_NAMESPACE::WriteBatchInternal::Append(wb1, wb2);
 199 }