@nxtedition/rocksdb 6.0.1 → 7.0.0-alpha.1

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

@@ -397,8 +397,8 @@ class WritePreparedTxnDB : public PessimisticTransactionDB {
       if (delta >= format.DELTA_UPPERBOUND) {
         throw std::runtime_error(
             "commit_seq >> prepare_seq. The allowed distance is " +
-            ToString(format.DELTA_UPPERBOUND) + " commit_seq is " +
-            ToString(cs) + " prepare_seq is " + ToString(ps));
+            std::to_string(format.DELTA_UPPERBOUND) + " commit_seq is " +
+            std::to_string(cs) + " prepare_seq is " + std::to_string(ps));
       }
       rep_ = (ps << format.PAD_BITS) & ~format.COMMIT_FILTER;
       rep_ = rep_ | delta;
@@ -465,6 +465,16 @@ class WritePreparedTxnDB : public PessimisticTransactionDB {
   // Get a dummy snapshot that refers to kMaxSequenceNumber
   Snapshot* GetMaxSnapshot() { return &dummy_max_snapshot_; }
 
+  bool ShouldRollbackWithSingleDelete(ColumnFamilyHandle* column_family,
+                                      const Slice& key) {
+    return rollback_deletion_type_callback_
+               ? rollback_deletion_type_callback_(this, column_family, key)
+               : false;
+  }
+
+  std::function<bool(TransactionDB*, ColumnFamilyHandle*, const Slice&)>
+      rollback_deletion_type_callback_;
+
  private:
   friend class AddPreparedCallback;
   friend class PreparedHeap_BasicsTest_Test;
@@ -503,8 +513,9 @@ class WritePreparedTxnDB : public PessimisticTransactionDB {
   friend class WriteUnpreparedTxn;
   friend class WriteUnpreparedTxnDB;
   friend class WriteUnpreparedTransactionTest_RecoveryTest_Test;
+  friend class MultiOpsTxnsStressTest;
 
-  void Init(const TransactionDBOptions& /* unused */);
+  void Init(const TransactionDBOptions& txn_db_opts);
 
   void WPRecordTick(uint32_t ticker_type) const {
     RecordTick(db_impl_->immutable_db_options_.statistics.get(), ticker_type);
@@ -1071,7 +1082,9 @@ struct SubBatchCounter : public WriteBatch::Handler {
   }
   Status MarkBeginPrepare(bool) override { return Status::OK(); }
   Status MarkRollback(const Slice&) override { return Status::OK(); }
-  bool WriteAfterCommit() const override { return false; }
+  Handler::OptionState WriteAfterCommit() const override {
+    return Handler::OptionState::kDisabled;
+  }
 };
 
 SnapshotBackup WritePreparedTxnDB::AssignMinMaxSeqs(const Snapshot* snapshot,

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

@@ -87,7 +87,7 @@ TEST_P(WriteUnpreparedTransactionTest, ReadYourOwnWrite) {
     txn->SetSnapshot();
 
     for (int i = 0; i < 5; i++) {
-      std::string stored_value = "v" + ToString(i);
+      std::string stored_value = "v" + std::to_string(i);
       ASSERT_OK(txn->Put("a", stored_value));
       ASSERT_OK(txn->Put("b", stored_value));
       ASSERT_OK(wup_txn->FlushWriteBatchToDB(false));
@@ -159,7 +159,7 @@ TEST_P(WriteUnpreparedStressTest, ReadYourOwnWriteStress) {
 
   std::vector<std::string> keys;
   for (uint32_t k = 0; k < kNumKeys * kNumThreads; k++) {
-    keys.push_back("k" + ToString(k));
+    keys.push_back("k" + std::to_string(k));
   }
   RandomShuffle(keys.begin(), keys.end());
 
@@ -188,7 +188,7 @@ TEST_P(WriteUnpreparedStressTest, ReadYourOwnWriteStress) {
       }
 
       txn = db->BeginTransaction(write_options, txn_options);
-      ASSERT_OK(txn->SetName(ToString(id)));
+      ASSERT_OK(txn->SetName(std::to_string(id)));
       txn->SetSnapshot();
       if (a >= RO_SNAPSHOT) {
         read_options.snapshot = txn->GetSnapshot();
@@ -342,8 +342,8 @@ TEST_P(WriteUnpreparedTransactionTest, RecoveryTest) {
           wup_db = dynamic_cast<WriteUnpreparedTxnDB*>(db);
           if (!empty) {
             for (int i = 0; i < num_batches; i++) {
-              ASSERT_OK(db->Put(WriteOptions(), "k" + ToString(i),
-                                "before value" + ToString(i)));
+              ASSERT_OK(db->Put(WriteOptions(), "k" + std::to_string(i),
+                                "before value" + std::to_string(i)));
             }
           }
 
@@ -352,7 +352,8 @@ TEST_P(WriteUnpreparedTransactionTest, RecoveryTest) {
           WriteUnpreparedTxn* wup_txn = dynamic_cast<WriteUnpreparedTxn*>(txn);
           ASSERT_OK(txn->SetName("xid"));
           for (int i = 0; i < num_batches; i++) {
-            ASSERT_OK(txn->Put("k" + ToString(i), "value" + ToString(i)));
+            ASSERT_OK(
+                txn->Put("k" + std::to_string(i), "value" + std::to_string(i)));
             if (txn_options.write_batch_flush_threshold == 1) {
               // WriteUnprepared will check write_batch_flush_threshold and
               // possibly flush before appending to the write batch. No flush
@@ -396,12 +397,13 @@ TEST_P(WriteUnpreparedTransactionTest, RecoveryTest) {
           if (!empty || a == COMMIT) {
             for (int i = 0; i < num_batches; i++) {
               ASSERT_TRUE(iter->Valid());
-              ASSERT_EQ(iter->key().ToString(), "k" + ToString(i));
+              ASSERT_EQ(iter->key().ToString(), "k" + std::to_string(i));
               if (a == COMMIT) {
-                ASSERT_EQ(iter->value().ToString(), "value" + ToString(i));
+                ASSERT_EQ(iter->value().ToString(),
+                          "value" + std::to_string(i));
               } else {
                 ASSERT_EQ(iter->value().ToString(),
-                          "before value" + ToString(i));
+                          "before value" + std::to_string(i));
               }
               iter->Next();
             }
@@ -434,7 +436,7 @@ TEST_P(WriteUnpreparedTransactionTest, UnpreparedBatch) {
         ASSERT_OK(txn->SetName("xid"));
 
         for (int i = 0; i < kNumKeys; i++) {
-          ASSERT_OK(txn->Put("k" + ToString(i), "v" + ToString(i)));
+          ASSERT_OK(txn->Put("k" + std::to_string(i), "v" + std::to_string(i)));
           if (txn_options.write_batch_flush_threshold == 1) {
             // WriteUnprepared will check write_batch_flush_threshold and
             // possibly flush before appending to the write batch. No flush will
@@ -471,8 +473,8 @@ TEST_P(WriteUnpreparedTransactionTest, UnpreparedBatch) {
 
         for (int i = 0; i < (commit ? kNumKeys : 0); i++) {
           ASSERT_TRUE(iter->Valid());
-          ASSERT_EQ(iter->key().ToString(), "k" + ToString(i));
-          ASSERT_EQ(iter->value().ToString(), "v" + ToString(i));
+          ASSERT_EQ(iter->key().ToString(), "k" + std::to_string(i));
+          ASSERT_EQ(iter->value().ToString(), "v" + std::to_string(i));
           iter->Next();
         }
         ASSERT_FALSE(iter->Valid());
@@ -512,9 +514,10 @@ TEST_P(WriteUnpreparedTransactionTest, MarkLogWithPrepSection) {
 
       // Spread this transaction across multiple log files.
       for (int i = 0; i < kNumKeys; i++) {
-        ASSERT_OK(txn1->Put("k1" + ToString(i), "v" + ToString(i)));
+        ASSERT_OK(txn1->Put("k1" + std::to_string(i), "v" + std::to_string(i)));
         if (i >= kNumKeys / 2) {
-          ASSERT_OK(txn2->Put("k2" + ToString(i), "v" + ToString(i)));
+          ASSERT_OK(
+              txn2->Put("k2" + std::to_string(i), "v" + std::to_string(i)));
         }
 
         if (i > 0) {
@@ -601,7 +604,7 @@ TEST_P(WriteUnpreparedTransactionTest, IterateAndWrite) {
 
   for (Action a : {DO_DELETE, DO_UPDATE}) {
     for (int i = 0; i < 100; i++) {
-      ASSERT_OK(db->Put(woptions, ToString(i), ToString(i)));
+      ASSERT_OK(db->Put(woptions, std::to_string(i), std::to_string(i)));
     }
 
     Transaction* txn = db->BeginTransaction(woptions, txn_options);
@@ -662,7 +665,7 @@ TEST_P(WriteUnpreparedTransactionTest, IterateAfterClear) {
 
   for (Action a : {kCommit, kRollback}) {
     for (int i = 0; i < 100; i++) {
-      ASSERT_OK(db->Put(woptions, ToString(i), ToString(i)));
+      ASSERT_OK(db->Put(woptions, std::to_string(i), std::to_string(i)));
     }
 
     Transaction* txn = db->BeginTransaction(woptions, txn_options);

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

@@ -281,8 +281,8 @@ Status WriteUnpreparedTxn::FlushWriteBatchToDBInternal(bool prepared) {
     static std::atomic_ullong autogen_id{0};
     // To avoid changing all tests to call SetName, just autogenerate one.
     if (wupt_db_->txn_db_options_.autogenerate_name) {
-      auto s =
-          SetName(std::string("autoxid") + ToString(autogen_id.fetch_add(1)));
+      auto s = SetName(std::string("autoxid") +
+                       std::to_string(autogen_id.fetch_add(1)));
       assert(s.ok());
     } else
 #endif
@@ -675,7 +675,11 @@ Status WriteUnpreparedTxn::WriteRollbackKeys(
       s = rollback_batch->Put(cf_handle, key, pinnable_val);
       assert(s.ok());
     } else if (s.IsNotFound()) {
-      s = rollback_batch->Delete(cf_handle, key);
+      if (wupt_db_->ShouldRollbackWithSingleDelete(cf_handle, key)) {
+        s = rollback_batch->SingleDelete(cf_handle, key);
+      } else {
+        s = rollback_batch->Delete(cf_handle, key);
+      }
       assert(s.ok());
     } else {
       return s;

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

@@ -247,8 +247,9 @@ Status WriteBatchWithIndex::Rep::ReBuildIndex() {
       case kTypeNoop:
         break;
       default:
-        return Status::Corruption("unknown WriteBatch tag in ReBuildIndex",
-                                  ToString(static_cast<unsigned int>(tag)));
+        return Status::Corruption(
+            "unknown WriteBatch tag in ReBuildIndex",
+            std::to_string(static_cast<unsigned int>(tag)));
     }
   }
 

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

@@ -514,7 +514,7 @@ Status ReadableWriteBatch::GetEntryFromDataOffset(size_t data_offset,
       break;
     default:
       return Status::Corruption("unknown WriteBatch tag ",
-                                ToString(static_cast<unsigned int>(tag)));
+                                std::to_string(static_cast<unsigned int>(tag)));
   }
   return Status::OK();
 }
@@ -700,7 +700,7 @@ WBWIIteratorImpl::Result WriteBatchWithIndexInternal::GetFromBatch(
   auto result = iter->FindLatestUpdate(key, context);
   if (result == WBWIIteratorImpl::kError) {
     (*s) = Status::Corruption("Unexpected entry in WriteBatchWithIndex:",
-                              ToString(iter->Entry().type));
+                              std::to_string(iter->Entry().type));
     return result;
   } else if (result == WBWIIteratorImpl::kNotFound) {
     return result;

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

@@ -95,7 +95,7 @@ struct WriteBatchIndexEntry {
                        bool is_forward_direction, bool is_seek_to_first)
       // For SeekForPrev(), we need to make the dummy entry larger than any
       // entry who has the same search key. Otherwise, we'll miss those entries.
-      : offset(is_forward_direction ? 0 : port::kMaxSizet),
+      : offset(is_forward_direction ? 0 : std::numeric_limits<size_t>::max()),
         column_family(_column_family),
         key_offset(0),
         key_size(is_seek_to_first ? kFlagMinInCf : 0),
@@ -105,7 +105,7 @@ struct WriteBatchIndexEntry {
 
   // If this flag appears in the key_size, it indicates a
   // key that is smaller than any other entry for the same column family.
-  static const size_t kFlagMinInCf = port::kMaxSizet;
+  static const size_t kFlagMinInCf = std::numeric_limits<size_t>::max();
 
   bool is_min_in_cf() const {
     assert(key_size != kFlagMinInCf ||

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

@@ -265,10 +265,10 @@ class WBWIBaseTest : public testing::Test {
         batch_->Delete(cf, key);
         result = "";
       } else if (key[i] == 'p') {
-        result = key + ToString(i);
+        result = key + std::to_string(i);
         batch_->Put(cf, key, result);
       } else if (key[i] == 'm') {
-        std::string value = key + ToString(i);
+        std::string value = key + std::to_string(i);
         batch_->Merge(cf, key, value);
         if (result.empty()) {
           result = value;
@@ -1192,11 +1192,11 @@ TEST_P(WriteBatchWithIndexTest, TestGetFromBatchMerge) {
   std::string expected = "X";
 
   for (int i = 0; i < 5; i++) {
-    ASSERT_OK(batch_->Merge("x", ToString(i)));
-    expected = expected + "," + ToString(i);
+    ASSERT_OK(batch_->Merge("x", std::to_string(i)));
+    expected = expected + "," + std::to_string(i);
 
     if (i % 2 == 0) {
-      ASSERT_OK(batch_->Put("y", ToString(i / 2)));
+      ASSERT_OK(batch_->Put("y", std::to_string(i / 2)));
     }
 
     ASSERT_OK(batch_->Merge("z", "z"));
@@ -1207,7 +1207,7 @@ TEST_P(WriteBatchWithIndexTest, TestGetFromBatchMerge) {
 
     s = batch_->GetFromBatch(column_family, options_, "y", &value);
     ASSERT_OK(s);
-    ASSERT_EQ(ToString(i / 2), value);
+    ASSERT_EQ(std::to_string(i / 2), value);
 
     s = batch_->GetFromBatch(column_family, options_, "z", &value);
     ASSERT_TRUE(s.IsMergeInProgress());

package/deps/rocksdb/rocksdb.gyp

@@ -5,21 +5,18 @@
       "target_name": "rocksdb",
       "type": "static_library",
       "standalone_static_library": 1,
-      "direct_dependent_settings": { 
-        "include_dirs": ["rocksdb/include/"] 
+      "direct_dependent_settings": {
+        "include_dirs": ["rocksdb/include/"]
       },
       "defines": [
         "ZSTD=1",
         "ZSTD_STATIC_LINKING_ONLY=1",
-        # "ROCKSDB_JEMALLOC=1",
-        # "JEMALLOC_NO_DEMANGLE=1",
         "ROCKSDB_BACKTRACE=1",
-        "ROCKSDB_SUPPORT_THREAD_LOCAL=1",
         "NIOSTATS_CONTEXT=1",
         "NPERF_CONTEXT=1"
       ],
       "include_dirs": [
-        "rocksdb/", 
+        "rocksdb/",
         "rocksdb/include/"
       ],
       "conditions": [
@@ -91,6 +88,8 @@
               "ROCKSDB_RANGESYNC_PRESENT=1",
               "ROCKSDB_SCHED_GETCPU_PRESENT=1",
               "ROCKSDB_IOURING_PRESENT=1",
+              "USE_FOLLY=1",
+              "FOLLY_NO_CONFIG=1"
               "HAVE_SSE42=1",
               "HAVE_BMI=1",
               "HAVE_LZCNT=1",
@@ -101,16 +100,20 @@
               # "HAVE_FULLFSYNC=1",
               # "NUMA=1",
               # "TBB=1",
+              # "ROCKSDB_JEMALLOC=1",
+              # "JEMALLOC_NO_DEMANGLE=1",
             ],
             "direct_dependent_settings": {
               "libraries": [
-                "/usr/lib/x86_64-linux-gnu/libzstd_pic.a",
-                # "/usr/lib/x86_64-linux-gnu/libjemalloc_pic.a",
+                "/usr/lib/x86_64-linux-gnu/libzstd.a",
+                "/usr/lib/x86_64-linux-gnu/libfolly.a",
+                # "/usr/lib/x86_64-linux-gnu/libjemalloc.a",
               ],
             },
             "include_dirs": [
               "/usr/lib/x86_64-linux-gnu/include",
-              # "/opt/homebrew/Cellar/jemalloc/5.3.0/include"
+              "/usr/lib/include",
+              # "/usr/local/Cellar/jemalloc/5.3.0/include"
             ],
             "dependencies": [
               "../liburing/liburing.gyp:liburing"
@@ -135,13 +138,11 @@
             "defines": ["OS_MACOSX=1"],
             "direct_dependent_settings": {
               "libraries": [
-                "/opt/homebrew/Cellar/zstd/1.5.2/lib/libzstd.a",
-                # "/opt/homebrew/Cellar/jemalloc/5.3.0/lib/libjemalloc.a"
+                "/opt/homebrew/Cellar/zstd/1.5.2/lib/libzstd.a"
               ],
             },
             "include_dirs": [
-              "/opt/homebrew/Cellar/zstd/1.5.2/include",
-              # "/opt/homebrew/Cellar/jemalloc/5.3.0/include"
+              "/opt/homebrew/Cellar/zstd/1.5.2/include"
             ],
             "xcode_settings": {
               "OTHER_CPLUSPLUSFLAGS": [
@@ -166,6 +167,7 @@
         "rocksdb/cache/cache_reservation_manager.cc",
         "rocksdb/cache/clock_cache.cc",
         "rocksdb/cache/compressed_secondary_cache.cc",
+        "rocksdb/cache/fast_lru_cache.cc",
         "rocksdb/cache/lru_cache.cc",
         "rocksdb/cache/sharded_cache.cc",
         "rocksdb/db/arena_wrapped_db_iter.cc",
@@ -366,6 +368,8 @@
         "rocksdb/trace_replay/trace_record_result.cc",
         "rocksdb/trace_replay/trace_record.cc",
         "rocksdb/trace_replay/trace_replay.cc",
+        "rocksdb/util/async_file_reader.cc",
+        "rocksdb/util/cleanable.cc",
         "rocksdb/util/coding.cc",
         "rocksdb/util/compaction_job_stats_impl.cc",
         "rocksdb/util/comparator.cc",
@@ -397,6 +401,9 @@
         "rocksdb/utilities/blob_db/blob_file.cc",
         "rocksdb/utilities/cache_dump_load.cc",
         "rocksdb/utilities/cache_dump_load_impl.cc",
+        # "rocksdb/utilities/cassandra/cassandra_compaction_filter.cc",
+        # "rocksdb/utilities/cassandra/format.cc",
+        # "rocksdb/utilities/cassandra/merge_operator.cc",
         "rocksdb/utilities/checkpoint/checkpoint_impl.cc",
         "rocksdb/utilities/compaction_filters.cc",
         "rocksdb/utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc",

package/index.js

@@ -6,6 +6,7 @@ const fs = require('fs')
 const binding = require('./binding')
 const { ChainedBatch } = require('./chained-batch')
 const { Iterator } = require('./iterator')
+const { Snapshot } = require('./snapshot')
 
 const kContext = Symbol('context')
 const kLocation = Symbol('location')
@@ -30,7 +31,13 @@ class RocksLevel extends AbstractLevel {
       },
       seek: true,
       createIfMissing: true,
-      errorIfExists: true
+      errorIfExists: true,
+      additionalMethods: {
+        getLatestSequenceNumber: true,
+        getSnapshot: true,
+        updates: true,
+        query: true
+      }
     }, options)
 
     this[kLocation] = location
@@ -84,6 +91,10 @@ class RocksLevel extends AbstractLevel {
     process.nextTick(callback, binding.batch_do(this[kContext], operations, options))
   }
 
+  _iterator (options) {
+    return new Iterator(this, this[kContext], options)
+  }
+
   getProperty (property) {
     if (typeof property !== 'string') {
       throw new TypeError("The first argument 'property' must be a string")
@@ -99,8 +110,181 @@ class RocksLevel extends AbstractLevel {
     return binding.db_get_property(this[kContext], property)
   }
 
-  _iterator (options) {
-    return new Iterator(this, this[kContext], options)
+  getLatestSequenceNumber () {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
+    return binding.db_get_latest_sequence_number(this[kContext])
+  }
+
+  getSnapshot () {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
+    return new Snapshot(this, this[kContext])
+  }
+
+  async * query (options) {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
+    class Query {
+      constructor (db, options) {
+        this.context = binding.iterator_init(db[kContext], options)
+        this.closed = false
+        this.promise = null
+        this.sequence = binding.iterator_get_sequence(this.context)
+        this.db = db
+        this.db.attachResource(this)
+      }
+
+      async next () {
+        if (this.closed) {
+          return {}
+        }
+
+        this.promise = new Promise(resolve => binding.iterator_nextv(this.context, 1000, (err, rows, finished) => {
+          this.promise = null
+          if (err) {
+            resolve(Promise.reject(err))
+          } else {
+            resolve({
+              finished,
+              rows,
+              sequence: this.sequence
+            })
+          }
+        }))
+
+        return this.promise
+      }
+
+      async close (callback) {
+        try {
+          await this.promise
+        } catch {
+          // Do nothing...
+        }
+
+        try {
+          if (!this.closed) {
+            this.closed = true
+            binding.iterator_close(this.context)
+          }
+
+          if (callback) {
+            process.nextTick(callback)
+          }
+        } catch (err) {
+          if (callback) {
+            process.nextTick(callback, err)
+          } else {
+            throw err
+          }
+        } finally {
+          this.db.detachResource(this)
+        }
+      }
+    }
+
+    const query = new Query(this, options)
+    try {
+      while (true) {
+        const { finished, rows, sequence } = await query.next()
+
+        yield { rows, sequence }
+
+        if (finished) {
+          return
+        }
+      }
+    } finally {
+      await query.close()
+    }
+  }
+
+  async * updates (options) {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
+    class Updates {
+      constructor (db, options) {
+        this.context = binding.updates_init(db[kContext], options)
+        this.closed = false
+        this.promise = null
+        this.db = db
+        this.db.attachResource(this)
+      }
+
+      async next () {
+        if (this.closed) {
+          return {}
+        }
+
+        this.promise = new Promise(resolve => binding.updates_next(this.context, (err, rows, sequence) => {
+          this.promise = null
+          if (err) {
+            resolve(Promise.reject(err))
+          } else {
+            resolve({ rows, sequence })
+          }
+        }))
+
+        return this.promise
+      }
+
+      async close (callback) {
+        try {
+          await this.promise
+        } catch {
+          // Do nothing...
+        }
+
+        try {
+          if (!this.closed) {
+            this.closed = true
+            binding.updates_close(this.context)
+          }
+
+          if (callback) {
+            process.nextTick(callback)
+          }
+        } catch (err) {
+          if (callback) {
+            process.nextTick(callback, err)
+          } else {
+            throw err
+          }
+        } finally {
+          this.db.detachResource(this)
+        }
+      }
+    }
+
+    const updates = new Updates(this, options)
+    try {
+      while (true) {
+        const { rows, sequence } = await updates.next()
+        if (!rows) {
+          return
+        }
+        yield { rows, sequence }
+      }
+    } finally {
+      await updates.close()
+    }
   }
 }
 

package/iterator.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { AbstractIterator } = require('abstract-level')
+
 const binding = require('./binding')
 
 const kContext = Symbol('context')