Function TestNestedTxnMergedIteration

store/txn_test.go:78–118

(t *testing.T)

}

func TestNestedTxnMergedIteration(t *testing.T) {
	baseTxn, db, batch := newTxn(t, []byte(nil))
	defer func() { baseTxn.Close(); db.Close(); baseTxn.Discard() }()
	// create a nested transaction
	nested := NewTxn(baseTxn, baseTxn, nil, false, true, true, baseTxn.writeVersion)
	// set and and flush a value in the parent transaction
	require.NoError(t, nested.Set(lib.JoinLenPrefix([]byte("a")), []byte("a")))
	require.NoError(t, baseTxn.Commit())
	// set and flush a value in the nested transaction
	require.NoError(t, nested.Set(lib.JoinLenPrefix([]byte("b")), []byte("b")))
	require.NoError(t, nested.Commit())
	// flush the batch
	require.NoError(t, batch.Commit(&pebble.WriteOptions{Sync: false}))
	// set a value in the parent transaction to not be flushed
	require.NoError(t, baseTxn.Set(lib.JoinLenPrefix([]byte("c")), []byte("c")))
	// set a value in the nested transaction to not be flushed
	require.NoError(t, nested.Set(lib.JoinLenPrefix([]byte("d")), []byte("d")))

	// create a new iterator on the nested transaction
	iter, err := nested.NewIterator(nil, false, false)
	require.NoError(t, err)
	expected := []string{"a", "b", "c", "d"}
	got := []string{}
	for ; iter.Valid(); iter.Next() {
		got = append(got, string(iter.Value()))
	}
	iter.Close()
	// confirm the iterator returns the expected values
	require.Equal(t, expected, got)

	// create a new reverse iterator on the nested transaction
	iter, err = nested.NewIterator(nil, true, false)
	require.NoError(t, err)
	expected = []string{"d", "c", "b", "a"}
	got = []string{}
	for ; iter.Valid(); iter.Next() {
		got = append(got, string(iter.Value()))
	}
	iter.Close()
	require.Equal(t, expected, got)
}

func TestTxnWriteSetGet(t *testing.T) {
	prefix := lib.JoinLenPrefix([]byte("1/"))