@nxtedition/rocksdb 7.0.5 → 7.0.8

package/deps/rocksdb/rocksdb/utilities/transactions/pessimistic_transaction_db.h

@@ -71,20 +71,27 @@ class PessimisticTransactionDB : public TransactionDB {
   virtual Status Write(const WriteOptions& opts, WriteBatch* updates) override;
   inline Status WriteWithConcurrencyControl(const WriteOptions& opts,
                                             WriteBatch* updates) {
-    // Need to lock all keys in this batch to prevent write conflicts with
-    // concurrent transactions.
-    Transaction* txn = BeginInternalTransaction(opts);
-    txn->DisableIndexing();
-
-    auto txn_impl = static_cast_with_check<PessimisticTransaction>(txn);
-
-    // Since commitBatch sorts the keys before locking, concurrent Write()
-    // operations will not cause a deadlock.
-    // In order to avoid a deadlock with a concurrent Transaction, Transactions
-    // should use a lock timeout.
-    Status s = txn_impl->CommitBatch(updates);
-
-    delete txn;
+    Status s;
+    if (opts.protection_bytes_per_key > 0) {
+      s = WriteBatchInternal::UpdateProtectionInfo(
+          updates, opts.protection_bytes_per_key);
+    }
+    if (s.ok()) {
+      // Need to lock all keys in this batch to prevent write conflicts with
+      // concurrent transactions.
+      Transaction* txn = BeginInternalTransaction(opts);
+      txn->DisableIndexing();
+
+      auto txn_impl = static_cast_with_check<PessimisticTransaction>(txn);
+
+      // Since commitBatch sorts the keys before locking, concurrent Write()
+      // operations will not cause a deadlock.
+      // In order to avoid a deadlock with a concurrent Transaction,
+      // Transactions should use a lock timeout.
+      s = txn_impl->CommitBatch(updates);
+
+      delete txn;
+    }
 
     return s;
   }

package/deps/rocksdb/rocksdb/utilities/transactions/transaction_base.cc

@@ -67,8 +67,11 @@ TransactionBaseImpl::TransactionBaseImpl(
       cmp_(GetColumnFamilyUserComparator(db->DefaultColumnFamily())),
       lock_tracker_factory_(lock_tracker_factory),
       start_time_(dbimpl_->GetSystemClock()->NowMicros()),
-      write_batch_(cmp_, 0, true, 0),
+      write_batch_(cmp_, 0, true, 0, write_options.protection_bytes_per_key),
       tracked_locks_(lock_tracker_factory_.Create()),
+      commit_time_batch_(0 /* reserved_bytes */, 0 /* max_bytes */,
+                         write_options.protection_bytes_per_key,
+                         0 /* default_cf_ts_sz */),
       indexing_enabled_(true) {
   assert(dynamic_cast<DBImpl*>(db_) != nullptr);
   log_number_ = 0;
@@ -108,6 +111,12 @@ void TransactionBaseImpl::Reinitialize(DB* db,
   start_time_ = dbimpl_->GetSystemClock()->NowMicros();
   indexing_enabled_ = true;
   cmp_ = GetColumnFamilyUserComparator(db_->DefaultColumnFamily());
+  WriteBatchInternal::UpdateProtectionInfo(
+      write_batch_.GetWriteBatch(), write_options_.protection_bytes_per_key)
+      .PermitUncheckedError();
+  WriteBatchInternal::UpdateProtectionInfo(
+      &commit_time_batch_, write_options_.protection_bytes_per_key)
+      .PermitUncheckedError();
 }
 
 void TransactionBaseImpl::SetSnapshot() {

package/deps/rocksdb/rocksdb/utilities/transactions/write_prepared_txn.cc

@@ -267,7 +267,9 @@ Status WritePreparedTxn::RollbackInternal() {
   assert(db_impl_);
   assert(wpt_db_);
 
-  WriteBatch rollback_batch;
+  WriteBatch rollback_batch(0 /* reserved_bytes */, 0 /* max_bytes */,
+                            write_options_.protection_bytes_per_key,
+                            0 /* default_cf_ts_sz */);
   assert(GetId() != kMaxSequenceNumber);
   assert(GetId() > 0);
   auto cf_map_shared_ptr = wpt_db_->GetCFHandleMap();

package/deps/rocksdb/rocksdb/utilities/transactions/write_prepared_txn_db.cc

@@ -166,6 +166,15 @@ Status WritePreparedTxnDB::WriteInternal(const WriteOptions& write_options_orig,
     // increased for this batch.
     return Status::OK();
   }
+
+  if (write_options_orig.protection_bytes_per_key > 0) {
+    auto s = WriteBatchInternal::UpdateProtectionInfo(
+        batch, write_options_orig.protection_bytes_per_key);
+    if (!s.ok()) {
+      return s;
+    }
+  }
+
   if (batch_cnt == 0) {  // not provided, then compute it
     // TODO(myabandeh): add an option to allow user skipping this cost
     SubBatchCounter counter(*GetCFComparatorMap());

package/deps/rocksdb/rocksdb/utilities/transactions/write_unprepared_txn.cc

@@ -464,7 +464,7 @@ Status WriteUnpreparedTxn::FlushWriteBatchWithSavePointToDB() {
   // only used if the write batch encounters an invalid cf id, and falls back to
   // this comparator.
   WriteBatchWithIndex wb(wpt_db_->DefaultColumnFamily()->GetComparator(), 0,
-                         true, 0);
+                         true, 0, write_options_.protection_bytes_per_key);
   // Swap with write_batch_ so that wb contains the complete write batch. The
   // actual write batch that will be flushed to DB will be built in
   // write_batch_, and will be read by FlushWriteBatchToDBInternal.
@@ -722,7 +722,8 @@ Status WriteUnpreparedTxn::WriteRollbackKeys(
 Status WriteUnpreparedTxn::RollbackInternal() {
   // TODO(lth): Reduce duplicate code with WritePrepared rollback logic.
   WriteBatchWithIndex rollback_batch(
-      wpt_db_->DefaultColumnFamily()->GetComparator(), 0, true, 0);
+      wpt_db_->DefaultColumnFamily()->GetComparator(), 0, true, 0,
+      write_options_.protection_bytes_per_key);
   assert(GetId() != kMaxSequenceNumber);
   assert(GetId() > 0);
   Status s;

package/deps/rocksdb/rocksdb/utilities/transactions/write_unprepared_txn_db.cc

@@ -59,7 +59,9 @@ Status WriteUnpreparedTxnDB::RollbackRecoveredTransaction(
   for (auto it = rtxn->batches_.rbegin(); it != rtxn->batches_.rend(); ++it) {
     auto last_visible_txn = it->first - 1;
     const auto& batch = it->second.batch_;
-    WriteBatch rollback_batch;
+    WriteBatch rollback_batch(0 /* reserved_bytes */, 0 /* max_bytes */,
+                              w_options.protection_bytes_per_key,
+                              0 /* default_cf_ts_sz */);
 
     struct RollbackWriteBatchBuilder : public WriteBatch::Handler {
       DBImpl* db_;

package/deps/rocksdb/rocksdb/utilities/write_batch_with_index/write_batch_with_index.cc

@@ -25,8 +25,9 @@
 namespace ROCKSDB_NAMESPACE {
 struct WriteBatchWithIndex::Rep {
   explicit Rep(const Comparator* index_comparator, size_t reserved_bytes = 0,
-               size_t max_bytes = 0, bool _overwrite_key = false)
-      : write_batch(reserved_bytes, max_bytes, /*protection_bytes_per_key=*/0,
+               size_t max_bytes = 0, bool _overwrite_key = false,
+               size_t protection_bytes_per_key = 0)
+      : write_batch(reserved_bytes, max_bytes, protection_bytes_per_key,
                     index_comparator ? index_comparator->timestamp_size() : 0),
         comparator(index_comparator, &write_batch),
         skip_list(comparator, &arena),
@@ -262,9 +263,9 @@ Status WriteBatchWithIndex::Rep::ReBuildIndex() {
 
 WriteBatchWithIndex::WriteBatchWithIndex(
     const Comparator* default_index_comparator, size_t reserved_bytes,
-    bool overwrite_key, size_t max_bytes)
+    bool overwrite_key, size_t max_bytes, size_t protection_bytes_per_key)
     : rep(new Rep(default_index_comparator, reserved_bytes, max_bytes,
-                  overwrite_key)) {}
+                  overwrite_key, protection_bytes_per_key)) {}
 
 WriteBatchWithIndex::~WriteBatchWithIndex() {}
 

package/deps/rocksdb/rocksdb.gyp

@@ -182,6 +182,7 @@
         "rocksdb/db/blob/blob_log_format.cc",
         "rocksdb/db/blob/blob_log_sequential_reader.cc",
         "rocksdb/db/blob/blob_log_writer.cc",
+        "rocksdb/db/blob/blob_source.cc",
         "rocksdb/db/blob/prefetch_buffer_collection.cc",
         "rocksdb/db/builder.cc",
         "rocksdb/db/c.cc",
@@ -306,7 +307,6 @@
         "rocksdb/table/adaptive/adaptive_table_factory.cc",
         "rocksdb/table/block_based/binary_search_index_reader.cc",
         "rocksdb/table/block_based/block.cc",
-        "rocksdb/table/block_based/block_based_filter_block.cc",
         "rocksdb/table/block_based/block_based_table_builder.cc",
         "rocksdb/table/block_based/block_based_table_factory.cc",
         "rocksdb/table/block_based/block_based_table_iterator.cc",

package/index.js

@@ -75,7 +75,12 @@ class RocksLevel extends AbstractLevel {
   }
 
   _put (key, value, options, callback) {
-    process.nextTick(callback, binding.db_put(this[kContext], key, value, options))
+    try {
+      binding.db_put(this[kContext], key, value, options)
+      process.nextTick(callback, null)
+    } catch (err) {
+      process.nextTick(callback, err)
+    }
   }
 
   _get (key, options, callback) {
@@ -87,11 +92,21 @@ class RocksLevel extends AbstractLevel {
   }
 
   _del (key, options, callback) {
-    process.nextTick(callback, binding.db_del(this[kContext], key, options))
+    try {
+      binding.db_del(this[kContext], key, options)
+      process.nextTick(callback, null)
+    } catch (err) {
+      process.nextTick(callback, err)
+    }
   }
 
   _clear (options, callback) {
-    process.nextTick(callback, binding.db_clear(this[kContext], options))
+    try {
+      binding.db_clear(this[kContext], options)
+      process.nextTick(callback, null)
+    } catch (err) {
+      process.nextTick(callback, err)
+    }
   }
 
   _chainedBatch () {
@@ -99,7 +114,12 @@ class RocksLevel extends AbstractLevel {
   }
 
   _batch (operations, options, callback) {
-    process.nextTick(callback, binding.batch_do(this[kContext], operations, options))
+    try {
+      binding.batch_do(this[kContext], operations, options)
+      process.nextTick(callback, null)
+    } catch (err) {
+      process.nextTick(callback, err)
+    }
   }
 
   _iterator (options) {
@@ -128,10 +148,7 @@ class RocksLevel extends AbstractLevel {
       })
     }
 
-    const context = binding.iterator_init(this[kContext], {
-      highWaterMarkBytes: 1024 * 1024 * 1024, // TODO (fix): Replace with -1.
-      ...options
-    })
+    const context = binding.iterator_init(this[kContext], options)
     const resource = {
       callback: null,
       close (callback) {
@@ -141,12 +158,17 @@ class RocksLevel extends AbstractLevel {
 
     try {
       this.attachResource(resource)
-      return await new Promise((resolve, reject) => binding.iterator_nextv(context, options.limit || 1000, (err, rows, finished) => {
+
+      const limit = options.limit ?? 1000
+      return await new Promise((resolve, reject) => binding.iterator_nextv(context, limit, (err, rows, finished) => {
         if (err) {
           reject(err)
         } else {
-          const sequence = binding.iterator_get_sequence(context)
-          resolve({ rows, sequence, finished })
+          resolve({
+            rows,
+            sequence: binding.iterator_get_sequence(context),
+            finished
+          })
         }
       }))
     } finally {
@@ -222,11 +244,11 @@ class RocksLevel extends AbstractLevel {
     const updates = new Updates(this, options)
     try {
       while (true) {
-        const { rows, sequence } = await updates.next()
-        if (!rows) {
+        const entry = await updates.next()
+        if (!entry.rows) {
           return
         }
-        yield { rows, sequence }
+        yield entry
       }
     } finally {
       await updates.close()