remove unused features (#59)

CHANGELOG.md

@@ -5,6 +5,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+Remove SetWithDiscard and NextSequence related implementations. 
+These features are not used any more.
+
 
 ## [1.5.0] - 2018-05-08
 * Introduce `NumVersionsToKeep` option. This option is used to discard many

README.md

@@ -29,7 +29,6 @@ version.
       - [Read-write transactions](#read-write-transactions)
       - [Managing transactions manually](#managing-transactions-manually)
     + [Using key/value pairs](#using-keyvalue-pairs)
-    + [Monotonically increasing integers](#monotonically-increasing-integers)
     + [Iterating over keys](#iterating-over-keys)
       - [Prefix scans](#prefix-scans)
       - [Key-only iteration](#key-only-iteration)
@@ -235,26 +234,6 @@ then you must use `copy()` to copy it to another byte slice.
 
 Use the `Txn.Delete()` method to delete a key.
 
-### Monotonically increasing integers
-
-To get unique monotonically increasing integers with strong durability, you can
-use the `DB.GetSequence` method. This method returns a `Sequence` object, which
-is thread-safe and can be used concurrently via various goroutines.
-
-Badger would lease a range of integers to hand out from memory, with the
-bandwidth provided to `DB.GetSequence`. The frequency at which disk writes are
-done is determined by this lease bandwidth and the frequency of `Next`
-invocations. Setting a bandwith too low would do more disk writes, setting it
-too high would result in wasted integers if Badger is closed or crashes.
-To avoid wasted integers, call `Release` before closing Badger.
-
-```go
-seq, err := db.GetSequence(key, 1000)
-defer seq.Release()
-for {
-  num, err := seq.Next()
-}
-```
 
 
 ### Iterating over keys

db.go

@@ -17,7 +17,6 @@
 package badger
 
 import (
-	"encoding/binary"
 	"expvar"
 	"math"
 	"os"
@@ -839,98 +838,6 @@ func (db *DB) Size() (lsm int64, vlog int64) {
 	return
 }
 
-// Sequence represents a Badger sequence.
-type Sequence struct {
-	sync.Mutex
-	db        *DB
-	key       []byte
-	next      uint64
-	leased    uint64
-	bandwidth uint64
-}
-
-// Next would return the next integer in the sequence, updating the lease by running a transaction
-// if needed.
-func (seq *Sequence) Next() (uint64, error) {
-	seq.Lock()
-	defer seq.Unlock()
-	if seq.next >= seq.leased {
-		if err := seq.updateLease(); err != nil {
-			return 0, err
-		}
-	}
-	val := seq.next
-	seq.next++
-	return val, nil
-}
-
-// Release the leased sequence to avoid wasted integers. This should be done right
-// before closing the associated DB. However it is valid to use the sequence after
-// it was released, causing a new lease with full bandwidth.
-func (seq *Sequence) Release() error {
-	seq.Lock()
-	defer seq.Unlock()
-	err := seq.db.Update(func(txn *Txn) error {
-		var buf [8]byte
-		binary.BigEndian.PutUint64(buf[:], seq.next)
-		return txn.Set(seq.key, buf[:])
-	})
-	if err != nil {
-		return err
-	}
-	seq.leased = seq.next
-	return nil
-}
-
-func (seq *Sequence) updateLease() error {
-	return seq.db.Update(func(txn *Txn) error {
-		item, err := txn.Get(seq.key)
-		if err == ErrKeyNotFound {
-			seq.next = 0
-		} else if err != nil {
-			return err
-		} else {
-			val, err := item.Value()
-			if err != nil {
-				return err
-			}
-			num := binary.BigEndian.Uint64(val)
-			seq.next = num
-		}
-
-		lease := seq.next + seq.bandwidth
-		var buf [8]byte
-		binary.BigEndian.PutUint64(buf[:], lease)
-		if err = txn.Set(seq.key, buf[:]); err != nil {
-			return err
-		}
-		seq.leased = lease
-		return nil
-	})
-}
-
-// GetSequence would initiate a new sequence object, generating it from the stored lease, if
-// available, in the database. Sequence can be used to get a list of monotonically increasing
-// integers. Multiple sequences can be created by providing different keys. Bandwidth sets the
-// size of the lease, determining how many Next() requests can be served from memory.
-func (db *DB) GetSequence(key []byte, bandwidth uint64) (*Sequence, error) {
-	switch {
-	case len(key) == 0:
-		return nil, ErrEmptyKey
-	case bandwidth == 0:
-		return nil, ErrZeroBandwidth
-	}
-	seq := &Sequence{
-		db:        db,
-		key:       key,
-		next:      0,
-		leased:    0,
-		bandwidth: bandwidth,
-	}
-	err := seq.updateLease()
-	return seq, err
-}
-
 func (db *DB) Tables() []TableInfo {
 	return db.lc.getTableInfo()
 }

db_test.go

@@ -18,7 +18,6 @@ package badger
 
 import (
 	"bytes"
-	"encoding/binary"
 	"flag"
 	"fmt"
 	"io/ioutil"
@@ -1018,99 +1017,6 @@ func TestWriteDeadlock(t *testing.T) {
 	require.NoError(t, err)
 }
 
-func TestSequence(t *testing.T) {
-	key0 := []byte("seq0")
-	key1 := []byte("seq1")
-
-	runBadgerTest(t, nil, func(t *testing.T, db *DB) {
-		seq0, err := db.GetSequence(key0, 10)
-		require.NoError(t, err)
-		seq1, err := db.GetSequence(key1, 100)
-		require.NoError(t, err)
-
-		for i := uint64(0); i < uint64(105); i++ {
-			num, err := seq0.Next()
-			require.NoError(t, err)
-			require.Equal(t, i, num)
-
-			num, err = seq1.Next()
-			require.NoError(t, err)
-			require.Equal(t, i, num)
-		}
-		err = db.View(func(txn *Txn) error {
-			item, err := txn.Get(key0)
-			if err != nil {
-				return err
-			}
-			val, err := item.Value()
-			if err != nil {
-				return err
-			}
-			num0 := binary.BigEndian.Uint64(val)
-			require.Equal(t, uint64(110), num0)
-
-			item, err = txn.Get(key1)
-			if err != nil {
-				return err
-			}
-			val, err = item.Value()
-			if err != nil {
-				return err
-			}
-			num1 := binary.BigEndian.Uint64(val)
-			require.Equal(t, uint64(200), num1)
-			return nil
-		})
-		require.NoError(t, err)
-	})
-}
-
-func TestSequence_Release(t *testing.T) {
-	runBadgerTest(t, nil, func(t *testing.T, db *DB) {
-		// get sequence, use once and release
-		key := []byte("key")
-		seq, err := db.GetSequence(key, 1000)
-		require.NoError(t, err)
-		num, err := seq.Next()
-		require.NoError(t, err)
-		require.Equal(t, uint64(0), num)
-		require.NoError(t, seq.Release())
-
-		// we used up 0 and 1 should be stored now
-		err = db.View(func(txn *Txn) error {
-			item, err := txn.Get(key)
-			if err != nil {
-				return err
-			}
-			val, err := item.Value()
-			if err != nil {
-				return err
-			}
-			require.Equal(t, num+1, binary.BigEndian.Uint64(val))
-			return nil
-		})
-		require.NoError(t, err)
-
-		// using it again will lease 1+1000
-		num, err = seq.Next()
-		require.NoError(t, err)
-		require.Equal(t, uint64(1), num)
-		err = db.View(func(txn *Txn) error {
-			item, err := txn.Get(key)
-			if err != nil {
-				return err
-			}
-			val, err := item.Value()
-			if err != nil {
-				return err
-			}
-			require.Equal(t, uint64(1001), binary.BigEndian.Uint64(val))
-			return nil
-		})
-		require.NoError(t, err)
-	})
-}
-
 func TestReadOnly(t *testing.T) {
 	dir, err := ioutil.TempDir("", "badger")
 	require.NoError(t, err)

managed_db.go

@@ -71,9 +71,3 @@ func (txn *Txn) CommitAt(commitTs uint64) error {
 	txn.commitTs = commitTs
 	return txn.Commit()
 }
-
-// GetSequence is not supported on ManagedDB. Calling this would result
-// in a panic.
-func (db *ManagedDB) GetSequence(_ []byte, _ uint64) (*Sequence, error) {
-	panic("Cannot use GetSequence for ManagedDB.")
-}