@nxtedition/rocksdb 7.1.32 → 7.1.34

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

@@ -5619,7 +5619,7 @@ TEST_P(TransactionStressTest, SeqAdvanceTest) {
     size_t branch = 0;
     auto seq = db_impl->GetLatestSequenceNumber();
     exp_seq = seq;
-    txn_t0(0);
+    TestTxn0(0);
     seq = db_impl->TEST_GetLastVisibleSequence();
     ASSERT_EQ(exp_seq, seq);
 
@@ -5637,11 +5637,11 @@ TEST_P(TransactionStressTest, SeqAdvanceTest) {
     }
 
     // Doing it twice might detect some bugs
-    txn_t0(1);
+    TestTxn0(1);
     seq = db_impl->TEST_GetLastVisibleSequence();
     ASSERT_EQ(exp_seq, seq);
 
-    txn_t1(0);
+    TestTxn1(0);
     seq = db_impl->TEST_GetLastVisibleSequence();
     ASSERT_EQ(exp_seq, seq);
 
@@ -5658,7 +5658,7 @@ TEST_P(TransactionStressTest, SeqAdvanceTest) {
       ASSERT_EQ(exp_seq, seq);
     }
 
-    txn_t3(0);
+    TestTxn3(0);
     seq = db_impl->TEST_GetLastVisibleSequence();
     ASSERT_EQ(exp_seq, seq);
 
@@ -5675,7 +5675,7 @@ TEST_P(TransactionStressTest, SeqAdvanceTest) {
       ASSERT_EQ(exp_seq, seq);
     }
 
-    txn_t4(0);
+    TestTxn4(0);
     seq = db_impl->TEST_GetLastVisibleSequence();
 
     ASSERT_EQ(exp_seq, seq);
@@ -5693,7 +5693,7 @@ TEST_P(TransactionStressTest, SeqAdvanceTest) {
       ASSERT_EQ(exp_seq, seq);
     }
 
-    txn_t2(0);
+    TestTxn2(0);
     seq = db_impl->TEST_GetLastVisibleSequence();
     ASSERT_EQ(exp_seq, seq);
 

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

@@ -223,12 +223,10 @@ class TransactionTestBase : public ::testing::Test {
   std::atomic<size_t> expected_commits = {0};
   // Without Prepare, the commit does not write to WAL
   std::atomic<size_t> with_empty_commits = {0};
-  std::function<void(size_t, Status)> txn_t0_with_status = [&](size_t index,
-                                                               Status exp_s) {
+  void TestTxn0(size_t index) {
     // Test DB's internal txn. It involves no prepare phase nor a commit marker.
-    WriteOptions wopts;
-    auto s = db->Put(wopts, "key" + std::to_string(index), "value");
-    ASSERT_EQ(exp_s, s);
+    auto s = db->Put(WriteOptions(), "key" + std::to_string(index), "value");
+    ASSERT_OK(s);
     if (txn_db_options.write_policy == TxnDBWritePolicy::WRITE_COMMITTED) {
       // Consume one seq per key
       exp_seq++;
@@ -241,11 +239,9 @@ class TransactionTestBase : public ::testing::Test {
       }
     }
     with_empty_commits++;
-  };
-  std::function<void(size_t)> txn_t0 = [&](size_t index) {
-    return txn_t0_with_status(index, Status::OK());
-  };
-  std::function<void(size_t)> txn_t1 = [&](size_t index) {
+  }
+
+  void TestTxn1(size_t index) {
     // Testing directly writing a write batch. Functionality-wise it is
     // equivalent to commit without prepare.
     WriteBatch wb;
@@ -253,8 +249,7 @@ class TransactionTestBase : public ::testing::Test {
     ASSERT_OK(wb.Put("k1" + istr, "v1"));
     ASSERT_OK(wb.Put("k2" + istr, "v2"));
     ASSERT_OK(wb.Put("k3" + istr, "v3"));
-    WriteOptions wopts;
-    auto s = db->Write(wopts, &wb);
+    auto s = db->Write(WriteOptions(), &wb);
     if (txn_db_options.write_policy == TxnDBWritePolicy::WRITE_COMMITTED) {
       // Consume one seq per key
       exp_seq += 3;
@@ -268,12 +263,12 @@ class TransactionTestBase : public ::testing::Test {
     }
     ASSERT_OK(s);
     with_empty_commits++;
-  };
-  std::function<void(size_t)> txn_t2 = [&](size_t index) {
+  }
+
+  void TestTxn2(size_t index) {
     // Commit without prepare. It should write to DB without a commit marker.
-    TransactionOptions txn_options;
-    WriteOptions write_options;
-    Transaction* txn = db->BeginTransaction(write_options, txn_options);
+    Transaction* txn =
+        db->BeginTransaction(WriteOptions(), TransactionOptions());
     auto istr = std::to_string(index);
     ASSERT_OK(txn->SetName("xid" + istr));
     ASSERT_OK(txn->Put(Slice("foo" + istr), Slice("bar")));
@@ -301,12 +296,12 @@ class TransactionTestBase : public ::testing::Test {
     }
     delete txn;
     with_empty_commits++;
-  };
-  std::function<void(size_t)> txn_t3 = [&](size_t index) {
+  }
+
+  void TestTxn3(size_t index) {
     // A full 2pc txn that also involves a commit marker.
-    TransactionOptions txn_options;
-    WriteOptions write_options;
-    Transaction* txn = db->BeginTransaction(write_options, txn_options);
+    Transaction* txn =
+        db->BeginTransaction(WriteOptions(), TransactionOptions());
     auto istr = std::to_string(index);
     ASSERT_OK(txn->SetName("xid" + istr));
     ASSERT_OK(txn->Put(Slice("foo" + istr), Slice("bar")));
@@ -334,12 +329,12 @@ class TransactionTestBase : public ::testing::Test {
       exp_seq++;
     }
     delete txn;
-  };
-  std::function<void(size_t)> txn_t4 = [&](size_t index) {
+  }
+
+  void TestTxn4(size_t index) {
     // A full 2pc txn that also involves a commit marker.
-    TransactionOptions txn_options;
-    WriteOptions write_options;
-    Transaction* txn = db->BeginTransaction(write_options, txn_options);
+    Transaction* txn =
+        db->BeginTransaction(WriteOptions(), TransactionOptions());
     auto istr = std::to_string(index);
     ASSERT_OK(txn->SetName("xid" + istr));
     ASSERT_OK(txn->Put(Slice("foo" + istr), Slice("bar")));
@@ -375,7 +370,7 @@ class TransactionTestBase : public ::testing::Test {
       }
     }
     delete txn;
-  };
+  }
 
   // Test that we can change write policy after a clean shutdown (which would
   // empty the WAL)

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

@@ -320,6 +320,7 @@ TEST_P(WriteCommittedTxnWithTsTest, Merge) {
 
   ColumnFamilyOptions cf_options;
   cf_options.comparator = test::BytewiseComparatorWithU64TsWrapper();
+  cf_options.merge_operator = MergeOperators::CreateStringAppendOperator();
   const std::string test_cf_name = "test_cf";
   ColumnFamilyHandle* cfh = nullptr;
   assert(db);
@@ -338,8 +339,17 @@ TEST_P(WriteCommittedTxnWithTsTest, Merge) {
       NewTxn(WriteOptions(), TransactionOptions()));
   assert(txn);
   ASSERT_OK(txn->Put(handles_[1], "foo", "bar"));
-  ASSERT_TRUE(txn->Merge(handles_[1], "foo", "1").IsInvalidArgument());
+  ASSERT_OK(txn->Merge(handles_[1], "foo", "1"));
+  ASSERT_OK(txn->SetCommitTimestamp(24));
+  ASSERT_OK(txn->Commit());
   txn.reset();
+  {
+    std::string value;
+    const Status s =
+        GetFromDb(ReadOptions(), handles_[1], "foo", /*ts=*/24, &value);
+    ASSERT_OK(s);
+    ASSERT_EQ("bar,1", value);
+  }
 }
 
 TEST_P(WriteCommittedTxnWithTsTest, GetForUpdate) {

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

@@ -1684,22 +1684,23 @@ TEST_P(SeqAdvanceConcurrentTest, SeqAdvanceConcurrent) {
     expected_commits = 0;
     std::vector<port::Thread> threads;
 
-    linked = 0;
+    linked.store(0, std::memory_order_release);
     std::atomic<bool> batch_formed(false);
     ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
         "WriteThread::EnterAsBatchGroupLeader:End",
         [&](void* /*arg*/) { batch_formed = true; });
     ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
         "WriteThread::JoinBatchGroup:Wait", [&](void* /*arg*/) {
-          linked++;
-          if (linked == 1) {
+          size_t orig_linked = linked.fetch_add(1, std::memory_order_acq_rel);
+          if (orig_linked == 0) {
             // Wait until the others are linked too.
-            while (linked < first_group_size) {
+            while (linked.load(std::memory_order_acquire) < first_group_size) {
             }
-          } else if (linked == 1 + first_group_size) {
+          } else if (orig_linked == first_group_size) {
             // Make the 2nd batch of the rest of writes plus any followup
             // commits from the first batch
-            while (linked < txn_cnt + commit_writes) {
+            while (linked.load(std::memory_order_acquire) <
+                   txn_cnt + commit_writes) {
             }
           }
           // Then we will have one or more batches consisting of follow-up
@@ -1713,32 +1714,33 @@ TEST_P(SeqAdvanceConcurrentTest, SeqAdvanceConcurrent) {
       size_t d = (n % base[bi + 1]) / base[bi];
       switch (d) {
         case 0:
-          threads.emplace_back(txn_t0, bi);
+          threads.emplace_back(&TransactionTestBase::TestTxn0, this, bi);
           break;
         case 1:
-          threads.emplace_back(txn_t1, bi);
+          threads.emplace_back(&TransactionTestBase::TestTxn1, this, bi);
           break;
         case 2:
-          threads.emplace_back(txn_t2, bi);
+          threads.emplace_back(&TransactionTestBase::TestTxn2, this, bi);
           break;
         case 3:
-          threads.emplace_back(txn_t3, bi);
+          threads.emplace_back(&TransactionTestBase::TestTxn3, this, bi);
           break;
         case 4:
-          threads.emplace_back(txn_t3, bi);
+          threads.emplace_back(&TransactionTestBase::TestTxn3, this, bi);
           break;
         default:
           FAIL();
       }
       // wait to be linked
-      while (linked.load() <= bi) {
+      while (linked.load(std::memory_order_acquire) <= bi) {
       }
       // after a queue of size first_group_size
       if (bi + 1 == first_group_size) {
         while (!batch_formed) {
         }
         // to make it more deterministic, wait until the commits are linked
-        while (linked.load() <= bi + expected_commits) {
+        while (linked.load(std::memory_order_acquire) <=
+               bi + expected_commits) {
         }
       }
     }
@@ -1792,7 +1794,7 @@ TEST_P(WritePreparedTransactionTest, BasicRecovery) {
   ASSERT_OK(ReOpen());
   WritePreparedTxnDB* wp_db = dynamic_cast<WritePreparedTxnDB*>(db);
 
-  txn_t0(0);
+  TestTxn0(0);
 
   TransactionOptions txn_options;
   WriteOptions write_options;
@@ -1807,7 +1809,7 @@ TEST_P(WritePreparedTransactionTest, BasicRecovery) {
   ASSERT_OK(s);
   auto prep_seq_0 = txn0->GetId();
 
-  txn_t1(0);
+  TestTxn1(0);
 
   index++;
   Transaction* txn1 = db->BeginTransaction(write_options, txn_options);
@@ -1820,7 +1822,7 @@ TEST_P(WritePreparedTransactionTest, BasicRecovery) {
   ASSERT_OK(s);
   auto prep_seq_1 = txn1->GetId();
 
-  txn_t2(0);
+  TestTxn2(0);
 
   ReadOptions ropt;
   PinnableSlice pinnable_val;
@@ -1856,7 +1858,7 @@ TEST_P(WritePreparedTransactionTest, BasicRecovery) {
   ASSERT_TRUE(s.IsNotFound());
   pinnable_val.Reset();
 
-  txn_t3(0);
+  TestTxn3(0);
 
   // Test that a recovered txns will be properly marked committed for the next
   // recovery

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

@@ -664,22 +664,25 @@ Status WriteBatchWithIndexInternal::MergeKey(const Slice& key,
       Statistics* statistics = immutable_db_options.statistics.get();
       Logger* logger = immutable_db_options.info_log.get();
       SystemClock* clock = immutable_db_options.clock;
-      return MergeHelper::TimedFullMerge(merge_operator, key, value,
-                                         context.GetOperands(), result, logger,
-                                         statistics, clock);
+      return MergeHelper::TimedFullMerge(
+          merge_operator, key, value, context.GetOperands(), result, logger,
+          statistics, clock, /* result_operand */ nullptr,
+          /* update_num_ops_stats */ false);
     } else if (db_options_ != nullptr) {
       Statistics* statistics = db_options_->statistics.get();
       Env* env = db_options_->env;
       Logger* logger = db_options_->info_log.get();
       SystemClock* clock = env->GetSystemClock().get();
-      return MergeHelper::TimedFullMerge(merge_operator, key, value,
-                                         context.GetOperands(), result, logger,
-                                         statistics, clock);
+      return MergeHelper::TimedFullMerge(
+          merge_operator, key, value, context.GetOperands(), result, logger,
+          statistics, clock, /* result_operand */ nullptr,
+          /* update_num_ops_stats */ false);
     } else {
       const auto cf_opts = cfh->cfd()->ioptions();
       return MergeHelper::TimedFullMerge(
           merge_operator, key, value, context.GetOperands(), result,
-          cf_opts->logger, cf_opts->stats, cf_opts->clock);
+          cf_opts->logger, cf_opts->stats, cf_opts->clock,
+          /* result_operand */ nullptr, /* update_num_ops_stats */ false);
     }
   } else {
     return Status::InvalidArgument("Must provide a column_family");

package/index.js

@@ -208,11 +208,7 @@ class RocksLevel extends AbstractLevel {
           this[kUnref]()
 
           if (!err) {
-            this.emit('update', {
-              rows: batch.toArray(),
-              count: batch.length,
-              sequence: sequence
-            })
+            this.emit('update', { batch, sequence })
           }
 
           callback(err)
@@ -233,11 +229,7 @@ class RocksLevel extends AbstractLevel {
 
         // TODO (fix)
         // if (!err) {
-        //   this.emit('update', {
-        //     rows: batch.toArray(),
-        //     count: batch.length,
-        //     sequence: sequence
-        //   })
+        //   this.emit('update', { batch, sequence })
         // }
 
         callback(err)
@@ -253,9 +245,9 @@ class RocksLevel extends AbstractLevel {
     return new Iterator(this, this[kContext], options ?? EMPTY)
   }
 
-	get identity () {
-		return binding.db_get_identity(this[kContext])
-	}
+  get identity () {
+    return binding.db_get_identity(this[kContext])
+  }
 
   getProperty (property) {
     if (typeof property !== 'string') {
@@ -366,7 +358,13 @@ class RocksLevel extends AbstractLevel {
           objectMode: true,
           readableHighWaterMark: 8192,
           construct (callback) {
-            this._next = (update) => {
+            this._next = ({ batch, sequence }) => {
+              const update = {
+                rows: batch.toArray(options),
+                count: batch.length,
+                sequence
+              }
+
               if (!this.push(update)) {
                 this.push(null)
                 db.off('update', this._next)
@@ -401,7 +399,7 @@ class RocksLevel extends AbstractLevel {
                 first = false
               }
 
-							// TODO (Fix): What if since > sequence && since < sequence + count
+              // TODO (Fix): What if since > sequence && since < sequence + count
               if (update.sequence + update.count > since) {
                 yield update
               }
@@ -428,7 +426,7 @@ class RocksLevel extends AbstractLevel {
             first = false
           }
 
-					// TODO (Fix): What if since > sequence && since < sequence + count
+          // TODO (Fix): What if since > sequence && since < sequence + count
           if (update.sequence + update.count > since) {
             yield update
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/rocksdb",
-  "version": "7.1.32",
+  "version": "7.1.34",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",