refactor some code and fix warnings

vampiebar · Apr 13, 2024 · e9f8e9e · e9f8e9e
1 parent 669e9b0
commit e9f8e9e
Show file tree

Hide file tree

Showing 6 changed files with 36 additions and 31 deletions.
diff --git a/bptree.go b/bptree.go
@@ -209,11 +209,10 @@ type bptreeIterator struct {
 	options IteratorOptions
 }
 
-// NewBptreeIterator
-func NewBptreeIterator(tx *bbolt.Tx, options IteratorOptions) *bptreeIterator {
-	cursor := tx.Bucket(indexBucketName).Cursor()
+// create a boltdb based btree iterator
+func newBptreeIterator(tx *bbolt.Tx, options IteratorOptions) *bptreeIterator {
 	return &bptreeIterator{
-		cursor:  cursor,
+		cursor:  tx.Bucket(indexBucketName).Cursor(),
 		options: options,
 		tx:      tx,
 	}

diff --git a/bptree_test.go b/bptree_test.go
@@ -369,7 +369,7 @@ func Test_bptreeIterator(t *testing.T) {
 		Reverse: false,
 	}
 
-	itr := NewBptreeIterator(tx, iteratorOptions)
+	itr := newBptreeIterator(tx, iteratorOptions)
 	assert.Nil(t, err)
 	var prev []byte
 	itr.Rewind()
@@ -390,7 +390,7 @@ func Test_bptreeIterator(t *testing.T) {
 	}
 	prev = nil
 
-	itr = NewBptreeIterator(tx, iteratorOptions)
+	itr = newBptreeIterator(tx, iteratorOptions)
 	assert.Nil(t, err)
 	itr.Rewind()
 	for itr.Valid() {
@@ -418,7 +418,7 @@ func Test_bptreeIterator(t *testing.T) {
 	}
 	prev = nil
 
-	itr = NewBptreeIterator(tx, iteratorOptions)
+	itr = newBptreeIterator(tx, iteratorOptions)
 	assert.Nil(t, err)
 	itr.Rewind()
 	for itr.Valid() {
@@ -450,7 +450,7 @@ func Test_bptreeIterator(t *testing.T) {
 		Prefix:  []byte("not valid"),
 	}
 
-	itr = NewBptreeIterator(tx, iteratorOptions)
+	itr = newBptreeIterator(tx, iteratorOptions)
 	assert.Nil(t, err)
 	itr.Rewind()
 	assert.False(t, itr.Valid())
@@ -464,7 +464,7 @@ func Test_bptreeIterator(t *testing.T) {
 		Prefix:  []byte("abc"),
 	}
 
-	itr = NewBptreeIterator(tx, iteratorOptions)
+	itr = newBptreeIterator(tx, iteratorOptions)
 	assert.Nil(t, err)
 	itr.Rewind()
 	assert.True(t, itr.Valid())

diff --git a/db_test.go b/db_test.go
@@ -591,7 +591,7 @@ func TestDBIterator(t *testing.T) {
 		db.immuMems[i], err = openMemtable(opts)
 		assert.Nil(t, err)
 	}
-	logRecord_0 := []*LogRecord{
+	logRecord0 := []*LogRecord{
 		// 0
 		{[]byte("k3"), nil, LogRecordDeleted, 0},
 		{[]byte("k1"), []byte("v1"), LogRecordNormal, 0},
@@ -602,20 +602,20 @@ func TestDBIterator(t *testing.T) {
 		{[]byte("abc1"), []byte("v1_1"), LogRecordNormal, 0},
 		{[]byte("abc2"), []byte("v1_1"), LogRecordNormal, 0},
 	}
-	logRecord_1 := []*LogRecord{
+	logRecord1 := []*LogRecord{
 		{[]byte("k1"), []byte("v2_1"), LogRecordNormal, 0},
 		{[]byte("k2"), []byte("v2_1"), LogRecordNormal, 0},
 		{[]byte("k2"), []byte("v2_2"), LogRecordNormal, 0},
 		{[]byte("abc1"), []byte("v2_1"), LogRecordNormal, 0},
 		{[]byte("abc2"), []byte("v2_1"), LogRecordNormal, 0},
 		{[]byte("abc2"), []byte("v2_2"), LogRecordNormal, 0},
 	}
-	logRecord_2 := []*LogRecord{
+	logRecord2 := []*LogRecord{
 		// 2
 		{[]byte("k2"), nil, LogRecordDeleted, 0},
 		{[]byte("abc2"), nil, LogRecordDeleted, 0},
 	}
-	logRecord_3 := []*LogRecord{
+	logRecord3 := []*LogRecord{
 		{[]byte("k3"), []byte("v3_1"), LogRecordNormal, 0},
 		{[]byte("abc3"), []byte("v3_1"), LogRecordNormal, 0},
 	}
@@ -627,13 +627,13 @@ func TestDBIterator(t *testing.T) {
 		}
 		return
 	}
-	err = db.immuMems[0].putBatch(list2Map(logRecord_0), 0, nil)
+	err = db.immuMems[0].putBatch(list2Map(logRecord0), 0, nil)
 	assert.Nil(t, err)
-	err = db.immuMems[1].putBatch(list2Map(logRecord_1), 1, nil)
+	err = db.immuMems[1].putBatch(list2Map(logRecord1), 1, nil)
 	assert.Nil(t, err)
-	err = db.immuMems[2].putBatch(list2Map(logRecord_2), 2, nil)
+	err = db.immuMems[2].putBatch(list2Map(logRecord2), 2, nil)
 	assert.Nil(t, err)
-	err = db.activeMem.putBatch(list2Map(logRecord_3), 3, nil)
+	err = db.activeMem.putBatch(list2Map(logRecord3), 3, nil)
 	assert.Nil(t, err)
 
 	expectedKey := [][]byte{

diff --git a/iterator.go b/iterator.go
@@ -207,23 +207,25 @@ func (db *DB) NewIterator(options IteratorOptions) (*Iterator, error) {
 			db.mu.Unlock()
 		}
 	}()
+
 	itrs := make([]*singleIter, 0, db.options.PartitionNum+len(db.immuMems)+1)
 	itrsM := make(map[int]*singleIter)
 	rank := 0
 	index := db.index.(*BPTree)
+
 	for i := 0; i < db.options.PartitionNum; i++ {
 		tx, err := index.trees[i].Begin(false)
 		if err != nil {
 			return nil, err
 		}
-		itr := NewBptreeIterator(
+		itr := newBptreeIterator(
 			tx,
 			options,
 		)
 		itr.Rewind()
 		// is empty
 		if !itr.Valid() {
-			itr.Close()
+			_ = itr.Close()
 			continue
 		}
 		itrs = append(itrs, &singleIter{
@@ -236,13 +238,14 @@ func (db *DB) NewIterator(options IteratorOptions) (*Iterator, error) {
 		itrsM[rank] = itrs[len(itrs)-1]
 		rank++
 	}
+
 	memtableList := append(db.immuMems, db.activeMem)
 	for i := 0; i < len(memtableList); i++ {
-		itr := NewMemtableIterator(options, memtableList[i])
+		itr := newMemtableIterator(options, memtableList[i])
 		itr.Rewind()
 		// is empty
 		if !itr.Valid() {
-			itr.Close()
+			_ = itr.Close()
 			continue
 		}
 		itrs = append(itrs, &singleIter{
@@ -255,6 +258,7 @@ func (db *DB) NewIterator(options IteratorOptions) (*Iterator, error) {
 		itrsM[rank] = itrs[len(itrs)-1]
 		rank++
 	}
+
 	h := iterHeap(itrs)
 	heap.Init(&h)
 

diff --git a/memtable.go b/memtable.go
@@ -240,8 +240,7 @@ type memtableIterator struct {
 	iter    *arenaskl.UniIterator
 }
 
-// NewMemtableIterator
-func NewMemtableIterator(options IteratorOptions, memtable *memtable) *memtableIterator {
+func newMemtableIterator(options IteratorOptions, memtable *memtable) *memtableIterator {
 	return &memtableIterator{
 		options: options,
 		iter:    memtable.skl.NewUniIterator(options.Reverse),

diff --git a/memtable_test.go b/memtable_test.go
@@ -486,13 +486,16 @@ func TestNewMemtableIterator(t *testing.T) {
 	}
 
 	table, err := openMemtable(opts)
-	defer table.close()
+	defer func() {
+		err = table.close()
+		assert.Nil(t, err)
+	}()
 	assert.Nil(t, err)
 
 	options := IteratorOptions{
 		Reverse: false,
 	}
-	iter := NewMemtableIterator(options, table)
+	iter := newMemtableIterator(options, table)
 	assert.Nil(t, err)
 
 	err = iter.Close()
@@ -540,7 +543,7 @@ func Test_memtableIterator(t *testing.T) {
 	iteratorOptions := IteratorOptions{
 		Reverse: false,
 	}
-	itr := NewMemtableIterator(iteratorOptions, table)
+	itr := newMemtableIterator(iteratorOptions, table)
 	assert.Nil(t, err)
 	var prev []byte
 	itr.Rewind()
@@ -557,7 +560,7 @@ func Test_memtableIterator(t *testing.T) {
 
 	iteratorOptions.Reverse = true
 	prev = nil
-	itr = NewMemtableIterator(iteratorOptions, table)
+	itr = newMemtableIterator(iteratorOptions, table)
 	assert.Nil(t, err)
 	itr.Rewind()
 	for itr.Valid() {
@@ -572,7 +575,7 @@ func Test_memtableIterator(t *testing.T) {
 	assert.Nil(t, err)
 
 	iteratorOptions.Reverse = false
-	itr = NewMemtableIterator(iteratorOptions, table)
+	itr = newMemtableIterator(iteratorOptions, table)
 	assert.Nil(t, err)
 	itr.Seek([]byte("key 0"))
 	assert.Equal(t, []byte("key 0"), itr.Key())
@@ -585,7 +588,7 @@ func Test_memtableIterator(t *testing.T) {
 	assert.Nil(t, err)
 
 	iteratorOptions.Reverse = true
-	itr = NewMemtableIterator(iteratorOptions, table)
+	itr = newMemtableIterator(iteratorOptions, table)
 	assert.Nil(t, err)
 	itr.Seek([]byte("key 4"))
 	assert.Equal(t, []byte("key 2"), itr.Key())
@@ -605,7 +608,7 @@ func Test_memtableIterator(t *testing.T) {
 
 	iteratorOptions.Reverse = false
 	iteratorOptions.Prefix = []byte("not valid")
-	itr = NewMemtableIterator(iteratorOptions, table)
+	itr = newMemtableIterator(iteratorOptions, table)
 	assert.Nil(t, err)
 	itr.Rewind()
 	assert.False(t, itr.Valid())
@@ -614,7 +617,7 @@ func Test_memtableIterator(t *testing.T) {
 
 	iteratorOptions.Reverse = false
 	iteratorOptions.Prefix = []byte("abc")
-	itr = NewMemtableIterator(iteratorOptions, table)
+	itr = newMemtableIterator(iteratorOptions, table)
 	assert.Nil(t, err)
 	itr.Rewind()
 	for itr.Valid() {