diff --git a/digest/writer_mock.go b/digest/writer_mock.go
index 239b56c..31ca4e7 100644
--- a/digest/writer_mock.go
+++ b/digest/writer_mock.go
@@ -18,110 +18,94 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-// Code generated by MockGen. DO NOT EDIT.
+// Automatically generated by MockGen. DO NOT EDIT!
 // Source: github.com/xichen2020/eventdb/digest (interfaces: FdWithDigestWriter)
 
-// Package digest is a generated GoMock package.
 package digest
 
 import (
 	"hash"
 	"os"
-	"reflect"
 
 	"github.com/golang/mock/gomock"
 )
 
-// MockFdWithDigestWriter is a mock of FdWithDigestWriter interface
+// Mock of FdWithDigestWriter interface
 type MockFdWithDigestWriter struct {
 	ctrl     *gomock.Controller
-	recorder *MockFdWithDigestWriterMockRecorder
+	recorder *_MockFdWithDigestWriterRecorder
 }
 
-// MockFdWithDigestWriterMockRecorder is the mock recorder for MockFdWithDigestWriter
-type MockFdWithDigestWriterMockRecorder struct {
+// Recorder for MockFdWithDigestWriter (not exported)
+type _MockFdWithDigestWriterRecorder struct {
 	mock *MockFdWithDigestWriter
 }
 
-// NewMockFdWithDigestWriter creates a new mock instance
 func NewMockFdWithDigestWriter(ctrl *gomock.Controller) *MockFdWithDigestWriter {
 	mock := &MockFdWithDigestWriter{ctrl: ctrl}
-	mock.recorder = &MockFdWithDigestWriterMockRecorder{mock}
+	mock.recorder = &_MockFdWithDigestWriterRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockFdWithDigestWriter) EXPECT() *MockFdWithDigestWriterMockRecorder {
-	return m.recorder
+func (_m *MockFdWithDigestWriter) EXPECT() *_MockFdWithDigestWriterRecorder {
+	return _m.recorder
 }
 
-// Close mocks base method
-func (m *MockFdWithDigestWriter) Close() error {
-	ret := m.ctrl.Call(m, "Close")
+func (_m *MockFdWithDigestWriter) Close() error {
+	ret := _m.ctrl.Call(_m, "Close")
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// Close indicates an expected call of Close
-func (mr *MockFdWithDigestWriterMockRecorder) Close() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockFdWithDigestWriter)(nil).Close))
+func (_mr *_MockFdWithDigestWriterRecorder) Close() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Close")
 }
 
-// Digest mocks base method
-func (m *MockFdWithDigestWriter) Digest() hash.Hash32 {
-	ret := m.ctrl.Call(m, "Digest")
+func (_m *MockFdWithDigestWriter) Digest() hash.Hash32 {
+	ret := _m.ctrl.Call(_m, "Digest")
 	ret0, _ := ret[0].(hash.Hash32)
 	return ret0
 }
 
-// Digest indicates an expected call of Digest
-func (mr *MockFdWithDigestWriterMockRecorder) Digest() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Digest", reflect.TypeOf((*MockFdWithDigestWriter)(nil).Digest))
+func (_mr *_MockFdWithDigestWriterRecorder) Digest() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Digest")
 }
 
-// Fd mocks base method
-func (m *MockFdWithDigestWriter) Fd() *os.File {
-	ret := m.ctrl.Call(m, "Fd")
+func (_m *MockFdWithDigestWriter) Fd() *os.File {
+	ret := _m.ctrl.Call(_m, "Fd")
 	ret0, _ := ret[0].(*os.File)
 	return ret0
 }
 
-// Fd indicates an expected call of Fd
-func (mr *MockFdWithDigestWriterMockRecorder) Fd() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fd", reflect.TypeOf((*MockFdWithDigestWriter)(nil).Fd))
+func (_mr *_MockFdWithDigestWriterRecorder) Fd() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Fd")
 }
 
-// Flush mocks base method
-func (m *MockFdWithDigestWriter) Flush() error {
-	ret := m.ctrl.Call(m, "Flush")
+func (_m *MockFdWithDigestWriter) Flush() error {
+	ret := _m.ctrl.Call(_m, "Flush")
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// Flush indicates an expected call of Flush
-func (mr *MockFdWithDigestWriterMockRecorder) Flush() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockFdWithDigestWriter)(nil).Flush))
+func (_mr *_MockFdWithDigestWriterRecorder) Flush() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Flush")
 }
 
-// Reset mocks base method
-func (m *MockFdWithDigestWriter) Reset(arg0 *os.File) {
-	m.ctrl.Call(m, "Reset", arg0)
+func (_m *MockFdWithDigestWriter) Reset(_param0 *os.File) {
+	_m.ctrl.Call(_m, "Reset", _param0)
 }
 
-// Reset indicates an expected call of Reset
-func (mr *MockFdWithDigestWriterMockRecorder) Reset(arg0 interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockFdWithDigestWriter)(nil).Reset), arg0)
+func (_mr *_MockFdWithDigestWriterRecorder) Reset(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Reset", arg0)
 }
 
-// Write mocks base method
-func (m *MockFdWithDigestWriter) Write(arg0 []byte) (int, error) {
-	ret := m.ctrl.Call(m, "Write", arg0)
+func (_m *MockFdWithDigestWriter) Write(_param0 []byte) (int, error) {
+	ret := _m.ctrl.Call(_m, "Write", _param0)
 	ret0, _ := ret[0].(int)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// Write indicates an expected call of Write
-func (mr *MockFdWithDigestWriterMockRecorder) Write(arg0 interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockFdWithDigestWriter)(nil).Write), arg0)
+func (_mr *_MockFdWithDigestWriterRecorder) Write(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Write", arg0)
 }
diff --git a/encoding/encoding_mock.go b/encoding/encoding_mock.go
new file mode 100644
index 0000000..bda07bb
--- /dev/null
+++ b/encoding/encoding_mock.go
@@ -0,0 +1,320 @@
+// Copyright (c) 2018 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// Automatically generated by MockGen. DO NOT EDIT!
+// Source: github.com/xichen2020/eventdb/encoding (interfaces: RewindableIntIterator,RewindableStringIterator,ForwardDoubleIterator,RewindableBoolIterator)
+
+package encoding
+
+import (
+	"github.com/golang/mock/gomock"
+)
+
+// Mock of RewindableIntIterator interface
+type MockRewindableIntIterator struct {
+	ctrl     *gomock.Controller
+	recorder *_MockRewindableIntIteratorRecorder
+}
+
+// Recorder for MockRewindableIntIterator (not exported)
+type _MockRewindableIntIteratorRecorder struct {
+	mock *MockRewindableIntIterator
+}
+
+func NewMockRewindableIntIterator(ctrl *gomock.Controller) *MockRewindableIntIterator {
+	mock := &MockRewindableIntIterator{ctrl: ctrl}
+	mock.recorder = &_MockRewindableIntIteratorRecorder{mock}
+	return mock
+}
+
+func (_m *MockRewindableIntIterator) EXPECT() *_MockRewindableIntIteratorRecorder {
+	return _m.recorder
+}
+
+func (_m *MockRewindableIntIterator) Close() error {
+	ret := _m.ctrl.Call(_m, "Close")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockRewindableIntIteratorRecorder) Close() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Close")
+}
+
+func (_m *MockRewindableIntIterator) Current() int {
+	ret := _m.ctrl.Call(_m, "Current")
+	ret0, _ := ret[0].(int)
+	return ret0
+}
+
+func (_mr *_MockRewindableIntIteratorRecorder) Current() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Current")
+}
+
+func (_m *MockRewindableIntIterator) Err() error {
+	ret := _m.ctrl.Call(_m, "Err")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockRewindableIntIteratorRecorder) Err() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Err")
+}
+
+func (_m *MockRewindableIntIterator) Next() bool {
+	ret := _m.ctrl.Call(_m, "Next")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+func (_mr *_MockRewindableIntIteratorRecorder) Next() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Next")
+}
+
+func (_m *MockRewindableIntIterator) Reset(_param0 []int) {
+	_m.ctrl.Call(_m, "Reset", _param0)
+}
+
+func (_mr *_MockRewindableIntIteratorRecorder) Reset(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Reset", arg0)
+}
+
+func (_m *MockRewindableIntIterator) Rewind() {
+	_m.ctrl.Call(_m, "Rewind")
+}
+
+func (_mr *_MockRewindableIntIteratorRecorder) Rewind() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Rewind")
+}
+
+// Mock of RewindableStringIterator interface
+type MockRewindableStringIterator struct {
+	ctrl     *gomock.Controller
+	recorder *_MockRewindableStringIteratorRecorder
+}
+
+// Recorder for MockRewindableStringIterator (not exported)
+type _MockRewindableStringIteratorRecorder struct {
+	mock *MockRewindableStringIterator
+}
+
+func NewMockRewindableStringIterator(ctrl *gomock.Controller) *MockRewindableStringIterator {
+	mock := &MockRewindableStringIterator{ctrl: ctrl}
+	mock.recorder = &_MockRewindableStringIteratorRecorder{mock}
+	return mock
+}
+
+func (_m *MockRewindableStringIterator) EXPECT() *_MockRewindableStringIteratorRecorder {
+	return _m.recorder
+}
+
+func (_m *MockRewindableStringIterator) Close() error {
+	ret := _m.ctrl.Call(_m, "Close")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockRewindableStringIteratorRecorder) Close() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Close")
+}
+
+func (_m *MockRewindableStringIterator) Current() string {
+	ret := _m.ctrl.Call(_m, "Current")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+func (_mr *_MockRewindableStringIteratorRecorder) Current() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Current")
+}
+
+func (_m *MockRewindableStringIterator) Err() error {
+	ret := _m.ctrl.Call(_m, "Err")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockRewindableStringIteratorRecorder) Err() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Err")
+}
+
+func (_m *MockRewindableStringIterator) Next() bool {
+	ret := _m.ctrl.Call(_m, "Next")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+func (_mr *_MockRewindableStringIteratorRecorder) Next() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Next")
+}
+
+func (_m *MockRewindableStringIterator) Reset(_param0 []string) {
+	_m.ctrl.Call(_m, "Reset", _param0)
+}
+
+func (_mr *_MockRewindableStringIteratorRecorder) Reset(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Reset", arg0)
+}
+
+func (_m *MockRewindableStringIterator) Rewind() {
+	_m.ctrl.Call(_m, "Rewind")
+}
+
+func (_mr *_MockRewindableStringIteratorRecorder) Rewind() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Rewind")
+}
+
+// Mock of ForwardDoubleIterator interface
+type MockForwardDoubleIterator struct {
+	ctrl     *gomock.Controller
+	recorder *_MockForwardDoubleIteratorRecorder
+}
+
+// Recorder for MockForwardDoubleIterator (not exported)
+type _MockForwardDoubleIteratorRecorder struct {
+	mock *MockForwardDoubleIterator
+}
+
+func NewMockForwardDoubleIterator(ctrl *gomock.Controller) *MockForwardDoubleIterator {
+	mock := &MockForwardDoubleIterator{ctrl: ctrl}
+	mock.recorder = &_MockForwardDoubleIteratorRecorder{mock}
+	return mock
+}
+
+func (_m *MockForwardDoubleIterator) EXPECT() *_MockForwardDoubleIteratorRecorder {
+	return _m.recorder
+}
+
+func (_m *MockForwardDoubleIterator) Close() error {
+	ret := _m.ctrl.Call(_m, "Close")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockForwardDoubleIteratorRecorder) Close() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Close")
+}
+
+func (_m *MockForwardDoubleIterator) Current() float64 {
+	ret := _m.ctrl.Call(_m, "Current")
+	ret0, _ := ret[0].(float64)
+	return ret0
+}
+
+func (_mr *_MockForwardDoubleIteratorRecorder) Current() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Current")
+}
+
+func (_m *MockForwardDoubleIterator) Err() error {
+	ret := _m.ctrl.Call(_m, "Err")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockForwardDoubleIteratorRecorder) Err() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Err")
+}
+
+func (_m *MockForwardDoubleIterator) Next() bool {
+	ret := _m.ctrl.Call(_m, "Next")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+func (_mr *_MockForwardDoubleIteratorRecorder) Next() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Next")
+}
+
+// Mock of RewindableBoolIterator interface
+type MockRewindableBoolIterator struct {
+	ctrl     *gomock.Controller
+	recorder *_MockRewindableBoolIteratorRecorder
+}
+
+// Recorder for MockRewindableBoolIterator (not exported)
+type _MockRewindableBoolIteratorRecorder struct {
+	mock *MockRewindableBoolIterator
+}
+
+func NewMockRewindableBoolIterator(ctrl *gomock.Controller) *MockRewindableBoolIterator {
+	mock := &MockRewindableBoolIterator{ctrl: ctrl}
+	mock.recorder = &_MockRewindableBoolIteratorRecorder{mock}
+	return mock
+}
+
+func (_m *MockRewindableBoolIterator) EXPECT() *_MockRewindableBoolIteratorRecorder {
+	return _m.recorder
+}
+
+func (_m *MockRewindableBoolIterator) Close() error {
+	ret := _m.ctrl.Call(_m, "Close")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockRewindableBoolIteratorRecorder) Close() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Close")
+}
+
+func (_m *MockRewindableBoolIterator) Current() bool {
+	ret := _m.ctrl.Call(_m, "Current")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+func (_mr *_MockRewindableBoolIteratorRecorder) Current() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Current")
+}
+
+func (_m *MockRewindableBoolIterator) Err() error {
+	ret := _m.ctrl.Call(_m, "Err")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockRewindableBoolIteratorRecorder) Err() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Err")
+}
+
+func (_m *MockRewindableBoolIterator) Next() bool {
+	ret := _m.ctrl.Call(_m, "Next")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+func (_mr *_MockRewindableBoolIteratorRecorder) Next() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Next")
+}
+
+func (_m *MockRewindableBoolIterator) Reset(_param0 []bool) {
+	_m.ctrl.Call(_m, "Reset", _param0)
+}
+
+func (_mr *_MockRewindableBoolIteratorRecorder) Reset(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Reset", arg0)
+}
+
+func (_m *MockRewindableBoolIterator) Rewind() {
+	_m.ctrl.Call(_m, "Rewind")
+}
+
+func (_mr *_MockRewindableBoolIteratorRecorder) Rewind() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Rewind")
+}
diff --git a/storage/segment_mock.go b/storage/segment_mock.go
index 1b5a705..c8b0717 100644
--- a/storage/segment_mock.go
+++ b/storage/segment_mock.go
@@ -18,84 +18,68 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-// Code generated by MockGen. DO NOT EDIT.
+// Automatically generated by MockGen. DO NOT EDIT!
 // Source: github.com/xichen2020/eventdb/storage/segment.go
 
-// Package storage is a generated GoMock package.
 package storage
 
 import (
-	"reflect"
-
 	"github.com/golang/mock/gomock"
 	"github.com/xichen2020/eventdb/event"
 	"github.com/xichen2020/eventdb/persist"
 )
 
-// MockimmutableDatabaseSegment is a mock of immutableDatabaseSegment interface
+// Mock of immutableDatabaseSegment interface
 type MockimmutableDatabaseSegment struct {
 	ctrl     *gomock.Controller
-	recorder *MockimmutableDatabaseSegmentMockRecorder
+	recorder *_MockimmutableDatabaseSegmentRecorder
 }
 
-// MockimmutableDatabaseSegmentMockRecorder is the mock recorder for MockimmutableDatabaseSegment
-type MockimmutableDatabaseSegmentMockRecorder struct {
+// Recorder for MockimmutableDatabaseSegment (not exported)
+type _MockimmutableDatabaseSegmentRecorder struct {
 	mock *MockimmutableDatabaseSegment
 }
 
-// NewMockimmutableDatabaseSegment creates a new mock instance
 func NewMockimmutableDatabaseSegment(ctrl *gomock.Controller) *MockimmutableDatabaseSegment {
 	mock := &MockimmutableDatabaseSegment{ctrl: ctrl}
-	mock.recorder = &MockimmutableDatabaseSegmentMockRecorder{mock}
+	mock.recorder = &_MockimmutableDatabaseSegmentRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockimmutableDatabaseSegment) EXPECT() *MockimmutableDatabaseSegmentMockRecorder {
-	return m.recorder
+func (_m *MockimmutableDatabaseSegment) EXPECT() *_MockimmutableDatabaseSegmentRecorder {
+	return _m.recorder
 }
 
-// ID mocks base method
-func (m *MockimmutableDatabaseSegment) ID() string {
-	ret := m.ctrl.Call(m, "ID")
+func (_m *MockimmutableDatabaseSegment) ID() string {
+	ret := _m.ctrl.Call(_m, "ID")
 	ret0, _ := ret[0].(string)
 	return ret0
 }
 
-// ID indicates an expected call of ID
-func (mr *MockimmutableDatabaseSegmentMockRecorder) ID() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockimmutableDatabaseSegment)(nil).ID))
+func (_mr *_MockimmutableDatabaseSegmentRecorder) ID() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ID")
 }
 
-// MinTimeNanos mocks base method
-func (m *MockimmutableDatabaseSegment) MinTimeNanos() int64 {
-	ret := m.ctrl.Call(m, "MinTimeNanos")
+func (_m *MockimmutableDatabaseSegment) MinTimeNanos() int64 {
+	ret := _m.ctrl.Call(_m, "MinTimeNanos")
 	ret0, _ := ret[0].(int64)
 	return ret0
 }
 
-// MinTimeNanos indicates an expected call of MinTimeNanos
-func (mr *MockimmutableDatabaseSegmentMockRecorder) MinTimeNanos() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MinTimeNanos", reflect.TypeOf((*MockimmutableDatabaseSegment)(nil).MinTimeNanos))
+func (_mr *_MockimmutableDatabaseSegmentRecorder) MinTimeNanos() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "MinTimeNanos")
 }
 
-// MaxTimeNanos mocks base method
-func (m *MockimmutableDatabaseSegment) MaxTimeNanos() int64 {
-	ret := m.ctrl.Call(m, "MaxTimeNanos")
+func (_m *MockimmutableDatabaseSegment) MaxTimeNanos() int64 {
+	ret := _m.ctrl.Call(_m, "MaxTimeNanos")
 	ret0, _ := ret[0].(int64)
 	return ret0
 }
 
-// MaxTimeNanos indicates an expected call of MaxTimeNanos
-func (mr *MockimmutableDatabaseSegmentMockRecorder) MaxTimeNanos() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaxTimeNanos", reflect.TypeOf((*MockimmutableDatabaseSegment)(nil).MaxTimeNanos))
+func (_mr *_MockimmutableDatabaseSegmentRecorder) MaxTimeNanos() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "MaxTimeNanos")
 }
 
-<<<<<<< HEAD
-// NumDocuments mocks base method
-func (m *MockimmutableDatabaseSegment) NumDocuments() int32 {
-	ret := m.ctrl.Call(m, "NumDocuments")
-=======
 func (_m *MockimmutableDatabaseSegment) Intersects(startNanosInclusive int64, endNanosExclusive int64) bool {
 	ret := _m.ctrl.Call(_m, "Intersects", startNanosInclusive, endNanosExclusive)
 	ret0, _ := ret[0].(bool)
@@ -108,21 +92,14 @@ func (_mr *_MockimmutableDatabaseSegmentRecorder) Intersects(arg0, arg1 interfac
 
 func (_m *MockimmutableDatabaseSegment) NumDocuments() int32 {
 	ret := _m.ctrl.Call(_m, "NumDocuments")
->>>>>>> Database server read path (part 1)
 	ret0, _ := ret[0].(int32)
 	return ret0
 }
 
-// NumDocuments indicates an expected call of NumDocuments
-func (mr *MockimmutableDatabaseSegmentMockRecorder) NumDocuments() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumDocuments", reflect.TypeOf((*MockimmutableDatabaseSegment)(nil).NumDocuments))
+func (_mr *_MockimmutableDatabaseSegmentRecorder) NumDocuments() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "NumDocuments")
 }
 
-<<<<<<< HEAD
-// Flush mocks base method
-func (m *MockimmutableDatabaseSegment) Flush(persistFns persist.Fns) error {
-	ret := m.ctrl.Call(m, "Flush", persistFns)
-=======
 func (_m *MockimmutableDatabaseSegment) IsFull() bool {
 	ret := _m.ctrl.Call(_m, "IsFull")
 	ret0, _ := ret[0].(bool)
@@ -135,19 +112,14 @@ func (_mr *_MockimmutableDatabaseSegmentRecorder) IsFull() *gomock.Call {
 
 func (_m *MockimmutableDatabaseSegment) Flush(persistFns persist.Fns) error {
 	ret := _m.ctrl.Call(_m, "Flush", persistFns)
->>>>>>> Database server read path (part 1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// Flush indicates an expected call of Flush
-func (mr *MockimmutableDatabaseSegmentMockRecorder) Flush(persistFns interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockimmutableDatabaseSegment)(nil).Flush), persistFns)
+func (_mr *_MockimmutableDatabaseSegmentRecorder) Flush(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Flush", arg0)
 }
 
-<<<<<<< HEAD
-// MockmutableDatabaseSegment is a mock of mutableDatabaseSegment interface
-=======
 func (_m *MockimmutableDatabaseSegment) IncReader() {
 	_m.ctrl.Call(_m, "IncReader")
 }
@@ -173,70 +145,56 @@ func (_mr *_MockimmutableDatabaseSegmentRecorder) Close() *gomock.Call {
 }
 
 // Mock of mutableDatabaseSegment interface
->>>>>>> Database server read path (part 1)
 type MockmutableDatabaseSegment struct {
 	ctrl     *gomock.Controller
-	recorder *MockmutableDatabaseSegmentMockRecorder
+	recorder *_MockmutableDatabaseSegmentRecorder
 }
 
-// MockmutableDatabaseSegmentMockRecorder is the mock recorder for MockmutableDatabaseSegment
-type MockmutableDatabaseSegmentMockRecorder struct {
+// Recorder for MockmutableDatabaseSegment (not exported)
+type _MockmutableDatabaseSegmentRecorder struct {
 	mock *MockmutableDatabaseSegment
 }
 
-// NewMockmutableDatabaseSegment creates a new mock instance
 func NewMockmutableDatabaseSegment(ctrl *gomock.Controller) *MockmutableDatabaseSegment {
 	mock := &MockmutableDatabaseSegment{ctrl: ctrl}
-	mock.recorder = &MockmutableDatabaseSegmentMockRecorder{mock}
+	mock.recorder = &_MockmutableDatabaseSegmentRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockmutableDatabaseSegment) EXPECT() *MockmutableDatabaseSegmentMockRecorder {
-	return m.recorder
+func (_m *MockmutableDatabaseSegment) EXPECT() *_MockmutableDatabaseSegmentRecorder {
+	return _m.recorder
 }
 
-// ID mocks base method
-func (m *MockmutableDatabaseSegment) ID() string {
-	ret := m.ctrl.Call(m, "ID")
+func (_m *MockmutableDatabaseSegment) ID() string {
+	ret := _m.ctrl.Call(_m, "ID")
 	ret0, _ := ret[0].(string)
 	return ret0
 }
 
-// ID indicates an expected call of ID
-func (mr *MockmutableDatabaseSegmentMockRecorder) ID() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockmutableDatabaseSegment)(nil).ID))
+func (_mr *_MockmutableDatabaseSegmentRecorder) ID() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ID")
 }
 
-// MinTimeNanos mocks base method
-func (m *MockmutableDatabaseSegment) MinTimeNanos() int64 {
-	ret := m.ctrl.Call(m, "MinTimeNanos")
+func (_m *MockmutableDatabaseSegment) MinTimeNanos() int64 {
+	ret := _m.ctrl.Call(_m, "MinTimeNanos")
 	ret0, _ := ret[0].(int64)
 	return ret0
 }
 
-// MinTimeNanos indicates an expected call of MinTimeNanos
-func (mr *MockmutableDatabaseSegmentMockRecorder) MinTimeNanos() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MinTimeNanos", reflect.TypeOf((*MockmutableDatabaseSegment)(nil).MinTimeNanos))
+func (_mr *_MockmutableDatabaseSegmentRecorder) MinTimeNanos() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "MinTimeNanos")
 }
 
-// MaxTimeNanos mocks base method
-func (m *MockmutableDatabaseSegment) MaxTimeNanos() int64 {
-	ret := m.ctrl.Call(m, "MaxTimeNanos")
+func (_m *MockmutableDatabaseSegment) MaxTimeNanos() int64 {
+	ret := _m.ctrl.Call(_m, "MaxTimeNanos")
 	ret0, _ := ret[0].(int64)
 	return ret0
 }
 
-// MaxTimeNanos indicates an expected call of MaxTimeNanos
-func (mr *MockmutableDatabaseSegmentMockRecorder) MaxTimeNanos() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaxTimeNanos", reflect.TypeOf((*MockmutableDatabaseSegment)(nil).MaxTimeNanos))
+func (_mr *_MockmutableDatabaseSegmentRecorder) MaxTimeNanos() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "MaxTimeNanos")
 }
 
-<<<<<<< HEAD
-// NumDocuments mocks base method
-func (m *MockmutableDatabaseSegment) NumDocuments() int32 {
-	ret := m.ctrl.Call(m, "NumDocuments")
-=======
 func (_m *MockmutableDatabaseSegment) Intersects(startNanosInclusive int64, endNanosExclusive int64) bool {
 	ret := _m.ctrl.Call(_m, "Intersects", startNanosInclusive, endNanosExclusive)
 	ret0, _ := ret[0].(bool)
@@ -249,21 +207,14 @@ func (_mr *_MockmutableDatabaseSegmentRecorder) Intersects(arg0, arg1 interface{
 
 func (_m *MockmutableDatabaseSegment) NumDocuments() int32 {
 	ret := _m.ctrl.Call(_m, "NumDocuments")
->>>>>>> Database server read path (part 1)
 	ret0, _ := ret[0].(int32)
 	return ret0
 }
 
-// NumDocuments indicates an expected call of NumDocuments
-func (mr *MockmutableDatabaseSegmentMockRecorder) NumDocuments() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumDocuments", reflect.TypeOf((*MockmutableDatabaseSegment)(nil).NumDocuments))
+func (_mr *_MockmutableDatabaseSegmentRecorder) NumDocuments() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "NumDocuments")
 }
 
-<<<<<<< HEAD
-// Flush mocks base method
-func (m *MockmutableDatabaseSegment) Flush(persistFns persist.Fns) error {
-	ret := m.ctrl.Call(m, "Flush", persistFns)
-=======
 func (_m *MockmutableDatabaseSegment) IsFull() bool {
 	ret := _m.ctrl.Call(_m, "IsFull")
 	ret0, _ := ret[0].(bool)
@@ -276,33 +227,14 @@ func (_mr *_MockmutableDatabaseSegmentRecorder) IsFull() *gomock.Call {
 
 func (_m *MockmutableDatabaseSegment) Flush(persistFns persist.Fns) error {
 	ret := _m.ctrl.Call(_m, "Flush", persistFns)
->>>>>>> Database server read path (part 1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// Flush indicates an expected call of Flush
-func (mr *MockmutableDatabaseSegmentMockRecorder) Flush(persistFns interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockmutableDatabaseSegment)(nil).Flush), persistFns)
-}
-
-// IsFull mocks base method
-func (m *MockmutableDatabaseSegment) IsFull() bool {
-	ret := m.ctrl.Call(m, "IsFull")
-	ret0, _ := ret[0].(bool)
-	return ret0
-}
-
-// IsFull indicates an expected call of IsFull
-func (mr *MockmutableDatabaseSegmentMockRecorder) IsFull() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsFull", reflect.TypeOf((*MockmutableDatabaseSegment)(nil).IsFull))
+func (_mr *_MockmutableDatabaseSegmentRecorder) Flush(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Flush", arg0)
 }
 
-<<<<<<< HEAD
-// Write mocks base method
-func (m *MockmutableDatabaseSegment) Write(ev event.Event) error {
-	ret := m.ctrl.Call(m, "Write", ev)
-=======
 func (_m *MockmutableDatabaseSegment) IncReader() {
 	_m.ctrl.Call(_m, "IncReader")
 }
@@ -329,37 +261,18 @@ func (_mr *_MockmutableDatabaseSegmentRecorder) Close() *gomock.Call {
 
 func (_m *MockmutableDatabaseSegment) Write(ev event.Event) error {
 	ret := _m.ctrl.Call(_m, "Write", ev)
->>>>>>> Database server read path (part 1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// Write indicates an expected call of Write
-func (mr *MockmutableDatabaseSegmentMockRecorder) Write(ev interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockmutableDatabaseSegment)(nil).Write), ev)
+func (_mr *_MockmutableDatabaseSegmentRecorder) Write(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Write", arg0)
 }
 
-// Seal mocks base method
-func (m *MockmutableDatabaseSegment) Seal() {
-	m.ctrl.Call(m, "Seal")
-}
-
-// Seal indicates an expected call of Seal
-func (mr *MockmutableDatabaseSegmentMockRecorder) Seal() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockmutableDatabaseSegment)(nil).Seal))
-}
-<<<<<<< HEAD
-
-// Close mocks base method
-func (m *MockmutableDatabaseSegment) Close() error {
-	ret := m.ctrl.Call(m, "Close")
-	ret0, _ := ret[0].(error)
-	return ret0
+func (_m *MockmutableDatabaseSegment) Seal() {
+	_m.ctrl.Call(_m, "Seal")
 }
 
-// Close indicates an expected call of Close
-func (mr *MockmutableDatabaseSegmentMockRecorder) Close() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockmutableDatabaseSegment)(nil).Close))
+func (_mr *_MockmutableDatabaseSegmentRecorder) Seal() *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "Seal")
 }
-=======
->>>>>>> Database server read path (part 1)