libroach/engine: plumb support for SingleDelete operation

c-deps/libroach/batch.cc

@@ -86,6 +86,11 @@ DBStatus ProcessDeltaKey(Getter* base, rocksdb::WBWIIterator* delta, rocksdb::Sl
       }
       break;
     }
+    case rocksdb::kSingleDeleteRecord:
+      // Treating a SingleDelete operation as a standard Delete doesn't
+      // quite mirror SingleDelete's expected implementation, but it
+      // doesn't violate the operation's contract:
+      // https://github.com/facebook/rocksdb/wiki/Single-Delete.
     case rocksdb::kDeleteRecord:
       if (value->data != NULL) {
         free(value->data);
@@ -418,7 +423,7 @@ class DBBatchInserter : public rocksdb::WriteBatch::Handler {
   DBBatchInserter(rocksdb::WriteBatchBase* batch) : batch_(batch) {}
 
   virtual rocksdb::Status PutCF(uint32_t column_family_id, const rocksdb::Slice& key,
-    const rocksdb::Slice& value) {
+                                const rocksdb::Slice& value) {
     if (column_family_id != 0) {
       return rocksdb::Status::InvalidArgument("DBBatchInserter: column families not supported");
     }
@@ -431,10 +436,13 @@ class DBBatchInserter : public rocksdb::WriteBatch::Handler {
     return batch_->Delete(key);
   }
   virtual rocksdb::Status SingleDeleteCF(uint32_t column_family_id, const rocksdb::Slice& key) {
-    return rocksdb::Status::InvalidArgument("DBBatchInserter: SingleDelete not supported");
+    if (column_family_id != 0) {
+      return rocksdb::Status::InvalidArgument("DBBatchInserter: column families not supported");
+    }
+    return batch_->SingleDelete(key);
   }
   virtual rocksdb::Status MergeCF(uint32_t column_family_id, const rocksdb::Slice& key,
-    const rocksdb::Slice& value) {
+                                  const rocksdb::Slice& value) {
     if (column_family_id != 0) {
       return rocksdb::Status::InvalidArgument("DBBatchInserter: column families not supported");
     }
@@ -494,6 +502,12 @@ DBStatus DBBatch::Delete(DBKey key) {
   return kSuccess;
 }
 
+DBStatus DBBatch::SingleDelete(DBKey key) {
+  ++updates;
+  batch.SingleDelete(EncodeKey(key));
+  return kSuccess;
+}
+
 DBStatus DBBatch::DeleteRange(DBKey start, DBKey end) {
   ++updates;
   has_delete_range = true;
@@ -597,6 +611,12 @@ DBStatus DBWriteOnlyBatch::Delete(DBKey key) {
   return kSuccess;
 }
 
+DBStatus DBWriteOnlyBatch::SingleDelete(DBKey key) {
+  ++updates;
+  batch.SingleDelete(EncodeKey(key));
+  return kSuccess;
+}
+
 DBStatus DBWriteOnlyBatch::DeleteRange(DBKey start, DBKey end) {
   ++updates;
   batch.DeleteRange(EncodeKey(start), EncodeKey(end));

c-deps/libroach/batch.h

@@ -32,6 +32,7 @@ struct DBBatch : public DBEngine {
   virtual DBStatus Put(DBKey key, DBSlice value);
   virtual DBStatus Merge(DBKey key, DBSlice value);
   virtual DBStatus Delete(DBKey key);
+  virtual DBStatus SingleDelete(DBKey key);
   virtual DBStatus DeleteRange(DBKey start, DBKey end);
   virtual DBStatus CommitBatch(bool sync);
   virtual DBStatus ApplyBatchRepr(DBSlice repr, bool sync);
@@ -63,6 +64,7 @@ struct DBWriteOnlyBatch : public DBEngine {
   virtual DBStatus Put(DBKey key, DBSlice value);
   virtual DBStatus Merge(DBKey key, DBSlice value);
   virtual DBStatus Delete(DBKey key);
+  virtual DBStatus SingleDelete(DBKey key);
   virtual DBStatus DeleteRange(DBKey start, DBKey end);
   virtual DBStatus CommitBatch(bool sync);
   virtual DBStatus ApplyBatchRepr(DBSlice repr, bool sync);

c-deps/libroach/db.cc

@@ -411,12 +411,12 @@ DBStatus DBCompactRange(DBEngine* db, DBSlice start, DBSlice end, bool force_bot
   return kSuccess;
 }
 
-DBStatus DBDisableAutoCompaction(DBEngine *db) {
+DBStatus DBDisableAutoCompaction(DBEngine* db) {
   auto status = db->rep->SetOptions({{"disable_auto_compactions", "true"}});
   return ToDBStatus(status);
 }
 
-DBStatus DBEnableAutoCompaction(DBEngine *db) {
+DBStatus DBEnableAutoCompaction(DBEngine* db) {
   auto status = db->rep->EnableAutoCompaction({db->rep->DefaultColumnFamily()});
   return ToDBStatus(status);
 }
@@ -439,6 +439,8 @@ DBStatus DBGet(DBEngine* db, DBKey key, DBString* value) { return db->Get(key, v
 
 DBStatus DBDelete(DBEngine* db, DBKey key) { return db->Delete(key); }
 
+DBStatus DBSingleDelete(DBEngine* db, DBKey key) { return db->SingleDelete(key); }
+
 DBStatus DBDeleteRange(DBEngine* db, DBKey start, DBKey end) { return db->DeleteRange(start, end); }
 
 DBStatus DBDeleteIterRange(DBEngine* db, DBIterator* iter, DBKey start, DBKey end) {

c-deps/libroach/engine.cc

@@ -159,6 +159,11 @@ DBStatus DBImpl::Delete(DBKey key) {
   return ToDBStatus(rep->Delete(options, EncodeKey(key)));
 }
 
+DBStatus DBImpl::SingleDelete(DBKey key) {
+  rocksdb::WriteOptions options;
+  return ToDBStatus(rep->SingleDelete(options, EncodeKey(key)));
+}
+
 DBStatus DBImpl::DeleteRange(DBKey start, DBKey end) {
   rocksdb::WriteOptions options;
   return ToDBStatus(

c-deps/libroach/engine.h

@@ -33,6 +33,7 @@ struct DBEngine {
   virtual DBStatus Put(DBKey key, DBSlice value) = 0;
   virtual DBStatus Merge(DBKey key, DBSlice value) = 0;
   virtual DBStatus Delete(DBKey key) = 0;
+  virtual DBStatus SingleDelete(DBKey key) = 0;
   virtual DBStatus DeleteRange(DBKey start, DBKey end) = 0;
   virtual DBStatus CommitBatch(bool sync) = 0;
   virtual DBStatus ApplyBatchRepr(DBSlice repr, bool sync) = 0;
@@ -80,6 +81,7 @@ struct DBImpl : public DBEngine {
   virtual DBStatus Put(DBKey key, DBSlice value);
   virtual DBStatus Merge(DBKey key, DBSlice value);
   virtual DBStatus Delete(DBKey key);
+  virtual DBStatus SingleDelete(DBKey key);
   virtual DBStatus DeleteRange(DBKey start, DBKey end);
   virtual DBStatus CommitBatch(bool sync);
   virtual DBStatus ApplyBatchRepr(DBSlice repr, bool sync);

c-deps/libroach/include/libroach.h

@@ -134,8 +134,8 @@ DBStatus DBCompactRange(DBEngine* db, DBSlice start, DBSlice end, bool force_bot
 // Disable/enable automatic compactions. Automatic compactions are
 // enabled by default. Disabling is provided for testing purposes so
 // that automatic compactions do not interfere with test expectations.
-DBStatus DBDisableAutoCompaction(DBEngine *db);
-DBStatus DBEnableAutoCompaction(DBEngine *db);
+DBStatus DBDisableAutoCompaction(DBEngine* db);
+DBStatus DBEnableAutoCompaction(DBEngine* db);
 
 // Stores the approximate on-disk size of the given key range into the
 // supplied uint64.
@@ -153,6 +153,11 @@ DBStatus DBGet(DBEngine* db, DBKey key, DBString* value);
 // Deletes the database entry for "key".
 DBStatus DBDelete(DBEngine* db, DBKey key);
 
+// Deletes the most recent database entry for "key". See the following
+// documentation for details on the subtleties of this operation:
+// https://github.com/facebook/rocksdb/wiki/Single-Delete.
+DBStatus DBSingleDelete(DBEngine* db, DBKey key);
+
 // Deletes a range of keys from start (inclusive) to end (exclusive).
 DBStatus DBDeleteRange(DBEngine* db, DBKey start, DBKey end);
 
@@ -326,7 +331,8 @@ typedef struct {
 DBScanResults MVCCGet(DBIterator* iter, DBSlice key, DBTimestamp timestamp, DBTxn txn,
                       bool inconsistent, bool tombstones);
 DBScanResults MVCCScan(DBIterator* iter, DBSlice start, DBSlice end, DBTimestamp timestamp,
-                       int64_t max_keys, DBTxn txn, bool inconsistent, bool reverse, bool tombstones);
+                       int64_t max_keys, DBTxn txn, bool inconsistent, bool reverse,
+                       bool tombstones);
 
 // DBStatsResult contains various runtime stats for RocksDB.
 typedef struct {

c-deps/libroach/snapshot.cc

@@ -35,6 +35,8 @@ DBStatus DBSnapshot::Get(DBKey key, DBString* value) {
 
 DBStatus DBSnapshot::Delete(DBKey key) { return FmtStatus("unsupported"); }
 
+DBStatus DBSnapshot::SingleDelete(DBKey key) { return FmtStatus("unsupported"); }
+
 DBStatus DBSnapshot::DeleteRange(DBKey start, DBKey end) { return FmtStatus("unsupported"); }
 
 DBStatus DBSnapshot::CommitBatch(bool sync) { return FmtStatus("unsupported"); }

c-deps/libroach/snapshot.h

@@ -29,6 +29,7 @@ struct DBSnapshot : public DBEngine {
   virtual DBStatus Put(DBKey key, DBSlice value);
   virtual DBStatus Merge(DBKey key, DBSlice value);
   virtual DBStatus Delete(DBKey key);
+  virtual DBStatus SingleDelete(DBKey key);
   virtual DBStatus DeleteRange(DBKey start, DBKey end);
   virtual DBStatus CommitBatch(bool sync);
   virtual DBStatus ApplyBatchRepr(DBSlice repr, bool sync);

pkg/storage/engine/batch.go

@@ -35,7 +35,7 @@ const (
 	// BatchTypeColumnFamilyDeletion                 = 0x4
 	// BatchTypeColumnFamilyValue                    = 0x5
 	// BatchTypeColumnFamilyMerge                    = 0x6
-	// BatchTypeSingleDeletion                       = 0x7
+	BatchTypeSingleDeletion = 0x7
 	// BatchTypeColumnFamilySingleDeletion           = 0x8
 	// BatchTypeBeginPrepareXID                      = 0x9
 	// BatchTypeEndPrepareXID                        = 0xA
@@ -75,10 +75,10 @@ const (
 //      data: uint8[len]
 //
 // The RocksDBBatchBuilder code currently only supports kTypeValue
-// (BatchTypeValue), kTypeDeletion (BatchTypeDeletion)and kTypeMerge
-// (BatchTypeMerge) operations. Before a batch is written to the RocksDB
-// write-ahead-log, the sequence number is 0. The "fixed32" format is little
-// endian.
+// (BatchTypeValue), kTypeDeletion (BatchTypeDeletion), kTypeMerge
+// (BatchTypeMerge), and kTypeSingleDeletion (BatchTypeSingleDeletion)
+// operations. Before a batch is written to the RocksDB write-ahead-log,
+// the sequence number is 0. The "fixed32" format is little endian.
 //
 // The keys encoded into the batch are MVCC keys: a string key with a timestamp
 // suffix. MVCC keys are encoded as:
@@ -262,6 +262,15 @@ func (b *RocksDBBatchBuilder) Clear(key MVCCKey) {
 	b.repr[pos] = byte(BatchTypeDeletion)
 }
 
+// SingleClear removes the most recent item from the db with the given key.
+func (b *RocksDBBatchBuilder) SingleClear(key MVCCKey) {
+	b.maybeInit()
+	b.count++
+	pos := len(b.repr)
+	b.encodeKey(key, 0)
+	b.repr[pos] = byte(BatchTypeSingleDeletion)
+}
+
 // LogData adds a blob of log data to the batch. It will be written to the WAL,
 // but otherwise uninterpreted by RocksDB.
 func (b *RocksDBBatchBuilder) LogData(data []byte) {
@@ -385,6 +394,8 @@ func rocksDBBatchVarString(repr []byte) (s []byte, orepr []byte, err error) {
 // 	   fmt.Printf("put(%x,%x)", r.Key(), r.Value())
 // 	 case BatchTypeMerge:
 // 	   fmt.Printf("merge(%x,%x)", r.Key(), r.Value())
+//   case BatchTypeSingleDeletion:
+// 	   fmt.Printf("single_delete(%x)", r.Key())
 // 	 }
 // }
 // if err := r.Error(); err != nil {
@@ -400,7 +411,7 @@ type RocksDBBatchReader struct {
 	count int
 
 	// The following all represent the current entry and are updated by Next.
-	// `value` is not applicable for BatchTypeDeletion.
+	// `value` is not applicable for BatchTypeDeletion or BatchTypeSingleDeletion.
 	offset int
 	typ    BatchType
 	key    []byte
@@ -447,7 +458,7 @@ func (r *RocksDBBatchReader) MVCCKey() (MVCCKey, error) {
 // Value returns the value of the current batch entry. Value panics if the
 // BatchType is BatchTypeDeleted.
 func (r *RocksDBBatchReader) Value() []byte {
-	if r.typ == BatchTypeDeletion {
+	if r.typ == BatchTypeDeletion || r.typ == BatchTypeSingleDeletion {
 		panic("cannot call Value on a deletion entry")
 	}
 	return r.value
@@ -471,18 +482,11 @@ func (r *RocksDBBatchReader) Next() bool {
 	r.typ = BatchType(r.repr[0])
 	r.repr = r.repr[1:]
 	switch r.typ {
-	case BatchTypeDeletion:
+	case BatchTypeDeletion, BatchTypeSingleDeletion:
 		if r.key, r.err = r.varstring(); r.err != nil {
 			return false
 		}
-	case BatchTypeValue:
-		if r.key, r.err = r.varstring(); r.err != nil {
-			return false
-		}
-		if r.value, r.err = r.varstring(); r.err != nil {
-			return false
-		}
-	case BatchTypeMerge:
+	case BatchTypeValue, BatchTypeMerge:
 		if r.key, r.err = r.varstring(); r.err != nil {
 			return false
 		}