mirror of
https://gitee.com/milvus-io/milvus.git
synced 2025-12-07 01:28:27 +08:00
5038036ece
issue: #32530 when try to match segment bloom filter with pk, we can reuse the hash locations. This PR maintain the max hash Func, and compute hash location once for all segment, reuse hash location can speed up bf access --------- Signed-off-by: Wei Liu <wei.liu@zilliz.com>
1659 lines
47 KiB
Go
1659 lines
47 KiB
Go
// Code generated by mockery v2.32.4. DO NOT EDIT.
|
|
|
|
package segments
|
|
|
|
import (
|
|
context "context"
|
|
|
|
commonpb "github.com/milvus-io/milvus-proto/go-api/v2/commonpb"
|
|
|
|
datapb "github.com/milvus-io/milvus/internal/proto/datapb"
|
|
|
|
metautil "github.com/milvus-io/milvus/pkg/util/metautil"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
|
|
msgpb "github.com/milvus-io/milvus-proto/go-api/v2/msgpb"
|
|
|
|
querypb "github.com/milvus-io/milvus/internal/proto/querypb"
|
|
|
|
segcorepb "github.com/milvus-io/milvus/internal/proto/segcorepb"
|
|
|
|
storage "github.com/milvus-io/milvus/internal/storage"
|
|
)
|
|
|
|
// MockSegment is an autogenerated mock type for the Segment type
|
|
type MockSegment struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockSegment_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockSegment) EXPECT() *MockSegment_Expecter {
|
|
return &MockSegment_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// CASVersion provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockSegment) CASVersion(_a0 int64, _a1 int64) bool {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(int64, int64) bool); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_CASVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CASVersion'
|
|
type MockSegment_CASVersion_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CASVersion is a helper method to define mock.On call
|
|
// - _a0 int64
|
|
// - _a1 int64
|
|
func (_e *MockSegment_Expecter) CASVersion(_a0 interface{}, _a1 interface{}) *MockSegment_CASVersion_Call {
|
|
return &MockSegment_CASVersion_Call{Call: _e.mock.On("CASVersion", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockSegment_CASVersion_Call) Run(run func(_a0 int64, _a1 int64)) *MockSegment_CASVersion_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64), args[1].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_CASVersion_Call) Return(_a0 bool) *MockSegment_CASVersion_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_CASVersion_Call) RunAndReturn(run func(int64, int64) bool) *MockSegment_CASVersion_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Collection provides a mock function with given fields:
|
|
func (_m *MockSegment) Collection() int64 {
|
|
ret := _m.Called()
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_Collection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Collection'
|
|
type MockSegment_Collection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Collection is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) Collection() *MockSegment_Collection_Call {
|
|
return &MockSegment_Collection_Call{Call: _e.mock.On("Collection")}
|
|
}
|
|
|
|
func (_c *MockSegment_Collection_Call) Run(run func()) *MockSegment_Collection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Collection_Call) Return(_a0 int64) *MockSegment_Collection_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Collection_Call) RunAndReturn(run func() int64) *MockSegment_Collection_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DatabaseName provides a mock function with given fields:
|
|
func (_m *MockSegment) DatabaseName() string {
|
|
ret := _m.Called()
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_DatabaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DatabaseName'
|
|
type MockSegment_DatabaseName_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DatabaseName is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) DatabaseName() *MockSegment_DatabaseName_Call {
|
|
return &MockSegment_DatabaseName_Call{Call: _e.mock.On("DatabaseName")}
|
|
}
|
|
|
|
func (_c *MockSegment_DatabaseName_Call) Run(run func()) *MockSegment_DatabaseName_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_DatabaseName_Call) Return(_a0 string) *MockSegment_DatabaseName_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_DatabaseName_Call) RunAndReturn(run func() string) *MockSegment_DatabaseName_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Delete provides a mock function with given fields: ctx, primaryKeys, timestamps
|
|
func (_m *MockSegment) Delete(ctx context.Context, primaryKeys []storage.PrimaryKey, timestamps []uint64) error {
|
|
ret := _m.Called(ctx, primaryKeys, timestamps)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, []storage.PrimaryKey, []uint64) error); ok {
|
|
r0 = rf(ctx, primaryKeys, timestamps)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
|
|
type MockSegment_Delete_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Delete is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - primaryKeys []storage.PrimaryKey
|
|
// - timestamps []uint64
|
|
func (_e *MockSegment_Expecter) Delete(ctx interface{}, primaryKeys interface{}, timestamps interface{}) *MockSegment_Delete_Call {
|
|
return &MockSegment_Delete_Call{Call: _e.mock.On("Delete", ctx, primaryKeys, timestamps)}
|
|
}
|
|
|
|
func (_c *MockSegment_Delete_Call) Run(run func(ctx context.Context, primaryKeys []storage.PrimaryKey, timestamps []uint64)) *MockSegment_Delete_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].([]storage.PrimaryKey), args[2].([]uint64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Delete_Call) Return(_a0 error) *MockSegment_Delete_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Delete_Call) RunAndReturn(run func(context.Context, []storage.PrimaryKey, []uint64) error) *MockSegment_Delete_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ExistIndex provides a mock function with given fields: fieldID
|
|
func (_m *MockSegment) ExistIndex(fieldID int64) bool {
|
|
ret := _m.Called(fieldID)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(int64) bool); ok {
|
|
r0 = rf(fieldID)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_ExistIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExistIndex'
|
|
type MockSegment_ExistIndex_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ExistIndex is a helper method to define mock.On call
|
|
// - fieldID int64
|
|
func (_e *MockSegment_Expecter) ExistIndex(fieldID interface{}) *MockSegment_ExistIndex_Call {
|
|
return &MockSegment_ExistIndex_Call{Call: _e.mock.On("ExistIndex", fieldID)}
|
|
}
|
|
|
|
func (_c *MockSegment_ExistIndex_Call) Run(run func(fieldID int64)) *MockSegment_ExistIndex_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_ExistIndex_Call) Return(_a0 bool) *MockSegment_ExistIndex_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_ExistIndex_Call) RunAndReturn(run func(int64) bool) *MockSegment_ExistIndex_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetHashFuncNum provides a mock function with given fields:
|
|
func (_m *MockSegment) GetHashFuncNum() uint {
|
|
ret := _m.Called()
|
|
|
|
var r0 uint
|
|
if rf, ok := ret.Get(0).(func() uint); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(uint)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_GetHashFuncNum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHashFuncNum'
|
|
type MockSegment_GetHashFuncNum_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetHashFuncNum is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) GetHashFuncNum() *MockSegment_GetHashFuncNum_Call {
|
|
return &MockSegment_GetHashFuncNum_Call{Call: _e.mock.On("GetHashFuncNum")}
|
|
}
|
|
|
|
func (_c *MockSegment_GetHashFuncNum_Call) Run(run func()) *MockSegment_GetHashFuncNum_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_GetHashFuncNum_Call) Return(_a0 uint) *MockSegment_GetHashFuncNum_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_GetHashFuncNum_Call) RunAndReturn(run func() uint) *MockSegment_GetHashFuncNum_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetIndex provides a mock function with given fields: fieldID
|
|
func (_m *MockSegment) GetIndex(fieldID int64) *IndexedFieldInfo {
|
|
ret := _m.Called(fieldID)
|
|
|
|
var r0 *IndexedFieldInfo
|
|
if rf, ok := ret.Get(0).(func(int64) *IndexedFieldInfo); ok {
|
|
r0 = rf(fieldID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*IndexedFieldInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_GetIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndex'
|
|
type MockSegment_GetIndex_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetIndex is a helper method to define mock.On call
|
|
// - fieldID int64
|
|
func (_e *MockSegment_Expecter) GetIndex(fieldID interface{}) *MockSegment_GetIndex_Call {
|
|
return &MockSegment_GetIndex_Call{Call: _e.mock.On("GetIndex", fieldID)}
|
|
}
|
|
|
|
func (_c *MockSegment_GetIndex_Call) Run(run func(fieldID int64)) *MockSegment_GetIndex_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_GetIndex_Call) Return(_a0 *IndexedFieldInfo) *MockSegment_GetIndex_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_GetIndex_Call) RunAndReturn(run func(int64) *IndexedFieldInfo) *MockSegment_GetIndex_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// HasRawData provides a mock function with given fields: fieldID
|
|
func (_m *MockSegment) HasRawData(fieldID int64) bool {
|
|
ret := _m.Called(fieldID)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(int64) bool); ok {
|
|
r0 = rf(fieldID)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_HasRawData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasRawData'
|
|
type MockSegment_HasRawData_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// HasRawData is a helper method to define mock.On call
|
|
// - fieldID int64
|
|
func (_e *MockSegment_Expecter) HasRawData(fieldID interface{}) *MockSegment_HasRawData_Call {
|
|
return &MockSegment_HasRawData_Call{Call: _e.mock.On("HasRawData", fieldID)}
|
|
}
|
|
|
|
func (_c *MockSegment_HasRawData_Call) Run(run func(fieldID int64)) *MockSegment_HasRawData_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_HasRawData_Call) Return(_a0 bool) *MockSegment_HasRawData_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_HasRawData_Call) RunAndReturn(run func(int64) bool) *MockSegment_HasRawData_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ID provides a mock function with given fields:
|
|
func (_m *MockSegment) ID() int64 {
|
|
ret := _m.Called()
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
|
|
type MockSegment_ID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ID is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) ID() *MockSegment_ID_Call {
|
|
return &MockSegment_ID_Call{Call: _e.mock.On("ID")}
|
|
}
|
|
|
|
func (_c *MockSegment_ID_Call) Run(run func()) *MockSegment_ID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_ID_Call) Return(_a0 int64) *MockSegment_ID_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_ID_Call) RunAndReturn(run func() int64) *MockSegment_ID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Indexes provides a mock function with given fields:
|
|
func (_m *MockSegment) Indexes() []*IndexedFieldInfo {
|
|
ret := _m.Called()
|
|
|
|
var r0 []*IndexedFieldInfo
|
|
if rf, ok := ret.Get(0).(func() []*IndexedFieldInfo); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*IndexedFieldInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_Indexes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Indexes'
|
|
type MockSegment_Indexes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Indexes is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) Indexes() *MockSegment_Indexes_Call {
|
|
return &MockSegment_Indexes_Call{Call: _e.mock.On("Indexes")}
|
|
}
|
|
|
|
func (_c *MockSegment_Indexes_Call) Run(run func()) *MockSegment_Indexes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Indexes_Call) Return(_a0 []*IndexedFieldInfo) *MockSegment_Indexes_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Indexes_Call) RunAndReturn(run func() []*IndexedFieldInfo) *MockSegment_Indexes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Insert provides a mock function with given fields: ctx, rowIDs, timestamps, record
|
|
func (_m *MockSegment) Insert(ctx context.Context, rowIDs []int64, timestamps []uint64, record *segcorepb.InsertRecord) error {
|
|
ret := _m.Called(ctx, rowIDs, timestamps, record)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, []int64, []uint64, *segcorepb.InsertRecord) error); ok {
|
|
r0 = rf(ctx, rowIDs, timestamps, record)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_Insert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Insert'
|
|
type MockSegment_Insert_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Insert is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - rowIDs []int64
|
|
// - timestamps []uint64
|
|
// - record *segcorepb.InsertRecord
|
|
func (_e *MockSegment_Expecter) Insert(ctx interface{}, rowIDs interface{}, timestamps interface{}, record interface{}) *MockSegment_Insert_Call {
|
|
return &MockSegment_Insert_Call{Call: _e.mock.On("Insert", ctx, rowIDs, timestamps, record)}
|
|
}
|
|
|
|
func (_c *MockSegment_Insert_Call) Run(run func(ctx context.Context, rowIDs []int64, timestamps []uint64, record *segcorepb.InsertRecord)) *MockSegment_Insert_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].([]int64), args[2].([]uint64), args[3].(*segcorepb.InsertRecord))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Insert_Call) Return(_a0 error) *MockSegment_Insert_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Insert_Call) RunAndReturn(run func(context.Context, []int64, []uint64, *segcorepb.InsertRecord) error) *MockSegment_Insert_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// InsertCount provides a mock function with given fields:
|
|
func (_m *MockSegment) InsertCount() int64 {
|
|
ret := _m.Called()
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_InsertCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertCount'
|
|
type MockSegment_InsertCount_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// InsertCount is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) InsertCount() *MockSegment_InsertCount_Call {
|
|
return &MockSegment_InsertCount_Call{Call: _e.mock.On("InsertCount")}
|
|
}
|
|
|
|
func (_c *MockSegment_InsertCount_Call) Run(run func()) *MockSegment_InsertCount_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_InsertCount_Call) Return(_a0 int64) *MockSegment_InsertCount_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_InsertCount_Call) RunAndReturn(run func() int64) *MockSegment_InsertCount_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// IsLazyLoad provides a mock function with given fields:
|
|
func (_m *MockSegment) IsLazyLoad() bool {
|
|
ret := _m.Called()
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func() bool); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_IsLazyLoad_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLazyLoad'
|
|
type MockSegment_IsLazyLoad_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// IsLazyLoad is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) IsLazyLoad() *MockSegment_IsLazyLoad_Call {
|
|
return &MockSegment_IsLazyLoad_Call{Call: _e.mock.On("IsLazyLoad")}
|
|
}
|
|
|
|
func (_c *MockSegment_IsLazyLoad_Call) Run(run func()) *MockSegment_IsLazyLoad_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_IsLazyLoad_Call) Return(_a0 bool) *MockSegment_IsLazyLoad_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_IsLazyLoad_Call) RunAndReturn(run func() bool) *MockSegment_IsLazyLoad_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// LastDeltaTimestamp provides a mock function with given fields:
|
|
func (_m *MockSegment) LastDeltaTimestamp() uint64 {
|
|
ret := _m.Called()
|
|
|
|
var r0 uint64
|
|
if rf, ok := ret.Get(0).(func() uint64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(uint64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_LastDeltaTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastDeltaTimestamp'
|
|
type MockSegment_LastDeltaTimestamp_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// LastDeltaTimestamp is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) LastDeltaTimestamp() *MockSegment_LastDeltaTimestamp_Call {
|
|
return &MockSegment_LastDeltaTimestamp_Call{Call: _e.mock.On("LastDeltaTimestamp")}
|
|
}
|
|
|
|
func (_c *MockSegment_LastDeltaTimestamp_Call) Run(run func()) *MockSegment_LastDeltaTimestamp_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_LastDeltaTimestamp_Call) Return(_a0 uint64) *MockSegment_LastDeltaTimestamp_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_LastDeltaTimestamp_Call) RunAndReturn(run func() uint64) *MockSegment_LastDeltaTimestamp_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Level provides a mock function with given fields:
|
|
func (_m *MockSegment) Level() datapb.SegmentLevel {
|
|
ret := _m.Called()
|
|
|
|
var r0 datapb.SegmentLevel
|
|
if rf, ok := ret.Get(0).(func() datapb.SegmentLevel); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(datapb.SegmentLevel)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_Level_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Level'
|
|
type MockSegment_Level_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Level is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) Level() *MockSegment_Level_Call {
|
|
return &MockSegment_Level_Call{Call: _e.mock.On("Level")}
|
|
}
|
|
|
|
func (_c *MockSegment_Level_Call) Run(run func()) *MockSegment_Level_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Level_Call) Return(_a0 datapb.SegmentLevel) *MockSegment_Level_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Level_Call) RunAndReturn(run func() datapb.SegmentLevel) *MockSegment_Level_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// LoadDeltaData provides a mock function with given fields: ctx, deltaData
|
|
func (_m *MockSegment) LoadDeltaData(ctx context.Context, deltaData *storage.DeleteData) error {
|
|
ret := _m.Called(ctx, deltaData)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *storage.DeleteData) error); ok {
|
|
r0 = rf(ctx, deltaData)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_LoadDeltaData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadDeltaData'
|
|
type MockSegment_LoadDeltaData_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// LoadDeltaData is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - deltaData *storage.DeleteData
|
|
func (_e *MockSegment_Expecter) LoadDeltaData(ctx interface{}, deltaData interface{}) *MockSegment_LoadDeltaData_Call {
|
|
return &MockSegment_LoadDeltaData_Call{Call: _e.mock.On("LoadDeltaData", ctx, deltaData)}
|
|
}
|
|
|
|
func (_c *MockSegment_LoadDeltaData_Call) Run(run func(ctx context.Context, deltaData *storage.DeleteData)) *MockSegment_LoadDeltaData_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*storage.DeleteData))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_LoadDeltaData_Call) Return(_a0 error) *MockSegment_LoadDeltaData_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_LoadDeltaData_Call) RunAndReturn(run func(context.Context, *storage.DeleteData) error) *MockSegment_LoadDeltaData_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// LoadInfo provides a mock function with given fields:
|
|
func (_m *MockSegment) LoadInfo() *querypb.SegmentLoadInfo {
|
|
ret := _m.Called()
|
|
|
|
var r0 *querypb.SegmentLoadInfo
|
|
if rf, ok := ret.Get(0).(func() *querypb.SegmentLoadInfo); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*querypb.SegmentLoadInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_LoadInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadInfo'
|
|
type MockSegment_LoadInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// LoadInfo is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) LoadInfo() *MockSegment_LoadInfo_Call {
|
|
return &MockSegment_LoadInfo_Call{Call: _e.mock.On("LoadInfo")}
|
|
}
|
|
|
|
func (_c *MockSegment_LoadInfo_Call) Run(run func()) *MockSegment_LoadInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_LoadInfo_Call) Return(_a0 *querypb.SegmentLoadInfo) *MockSegment_LoadInfo_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_LoadInfo_Call) RunAndReturn(run func() *querypb.SegmentLoadInfo) *MockSegment_LoadInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// MayPkExist provides a mock function with given fields: pk
|
|
func (_m *MockSegment) MayPkExist(pk storage.PrimaryKey) bool {
|
|
ret := _m.Called(pk)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(storage.PrimaryKey) bool); ok {
|
|
r0 = rf(pk)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_MayPkExist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MayPkExist'
|
|
type MockSegment_MayPkExist_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// MayPkExist is a helper method to define mock.On call
|
|
// - pk storage.PrimaryKey
|
|
func (_e *MockSegment_Expecter) MayPkExist(pk interface{}) *MockSegment_MayPkExist_Call {
|
|
return &MockSegment_MayPkExist_Call{Call: _e.mock.On("MayPkExist", pk)}
|
|
}
|
|
|
|
func (_c *MockSegment_MayPkExist_Call) Run(run func(pk storage.PrimaryKey)) *MockSegment_MayPkExist_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(storage.PrimaryKey))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_MayPkExist_Call) Return(_a0 bool) *MockSegment_MayPkExist_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_MayPkExist_Call) RunAndReturn(run func(storage.PrimaryKey) bool) *MockSegment_MayPkExist_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// MemSize provides a mock function with given fields:
|
|
func (_m *MockSegment) MemSize() int64 {
|
|
ret := _m.Called()
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_MemSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MemSize'
|
|
type MockSegment_MemSize_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// MemSize is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) MemSize() *MockSegment_MemSize_Call {
|
|
return &MockSegment_MemSize_Call{Call: _e.mock.On("MemSize")}
|
|
}
|
|
|
|
func (_c *MockSegment_MemSize_Call) Run(run func()) *MockSegment_MemSize_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_MemSize_Call) Return(_a0 int64) *MockSegment_MemSize_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_MemSize_Call) RunAndReturn(run func() int64) *MockSegment_MemSize_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NeedUpdatedVersion provides a mock function with given fields:
|
|
func (_m *MockSegment) NeedUpdatedVersion() int64 {
|
|
ret := _m.Called()
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_NeedUpdatedVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NeedUpdatedVersion'
|
|
type MockSegment_NeedUpdatedVersion_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// NeedUpdatedVersion is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) NeedUpdatedVersion() *MockSegment_NeedUpdatedVersion_Call {
|
|
return &MockSegment_NeedUpdatedVersion_Call{Call: _e.mock.On("NeedUpdatedVersion")}
|
|
}
|
|
|
|
func (_c *MockSegment_NeedUpdatedVersion_Call) Run(run func()) *MockSegment_NeedUpdatedVersion_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_NeedUpdatedVersion_Call) Return(_a0 int64) *MockSegment_NeedUpdatedVersion_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_NeedUpdatedVersion_Call) RunAndReturn(run func() int64) *MockSegment_NeedUpdatedVersion_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Partition provides a mock function with given fields:
|
|
func (_m *MockSegment) Partition() int64 {
|
|
ret := _m.Called()
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_Partition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Partition'
|
|
type MockSegment_Partition_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Partition is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) Partition() *MockSegment_Partition_Call {
|
|
return &MockSegment_Partition_Call{Call: _e.mock.On("Partition")}
|
|
}
|
|
|
|
func (_c *MockSegment_Partition_Call) Run(run func()) *MockSegment_Partition_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Partition_Call) Return(_a0 int64) *MockSegment_Partition_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Partition_Call) RunAndReturn(run func() int64) *MockSegment_Partition_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// PinIfNotReleased provides a mock function with given fields:
|
|
func (_m *MockSegment) PinIfNotReleased() error {
|
|
ret := _m.Called()
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_PinIfNotReleased_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PinIfNotReleased'
|
|
type MockSegment_PinIfNotReleased_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// PinIfNotReleased is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) PinIfNotReleased() *MockSegment_PinIfNotReleased_Call {
|
|
return &MockSegment_PinIfNotReleased_Call{Call: _e.mock.On("PinIfNotReleased")}
|
|
}
|
|
|
|
func (_c *MockSegment_PinIfNotReleased_Call) Run(run func()) *MockSegment_PinIfNotReleased_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_PinIfNotReleased_Call) Return(_a0 error) *MockSegment_PinIfNotReleased_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_PinIfNotReleased_Call) RunAndReturn(run func() error) *MockSegment_PinIfNotReleased_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Release provides a mock function with given fields: ctx, opts
|
|
func (_m *MockSegment) Release(ctx context.Context, opts ...releaseOption) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx)
|
|
_ca = append(_ca, _va...)
|
|
_m.Called(_ca...)
|
|
}
|
|
|
|
// MockSegment_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
|
|
type MockSegment_Release_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Release is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - opts ...releaseOption
|
|
func (_e *MockSegment_Expecter) Release(ctx interface{}, opts ...interface{}) *MockSegment_Release_Call {
|
|
return &MockSegment_Release_Call{Call: _e.mock.On("Release",
|
|
append([]interface{}{ctx}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockSegment_Release_Call) Run(run func(ctx context.Context, opts ...releaseOption)) *MockSegment_Release_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]releaseOption, len(args)-1)
|
|
for i, a := range args[1:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(releaseOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Release_Call) Return() *MockSegment_Release_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Release_Call) RunAndReturn(run func(context.Context, ...releaseOption)) *MockSegment_Release_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RemoveUnusedFieldFiles provides a mock function with given fields:
|
|
func (_m *MockSegment) RemoveUnusedFieldFiles() error {
|
|
ret := _m.Called()
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_RemoveUnusedFieldFiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUnusedFieldFiles'
|
|
type MockSegment_RemoveUnusedFieldFiles_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RemoveUnusedFieldFiles is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) RemoveUnusedFieldFiles() *MockSegment_RemoveUnusedFieldFiles_Call {
|
|
return &MockSegment_RemoveUnusedFieldFiles_Call{Call: _e.mock.On("RemoveUnusedFieldFiles")}
|
|
}
|
|
|
|
func (_c *MockSegment_RemoveUnusedFieldFiles_Call) Run(run func()) *MockSegment_RemoveUnusedFieldFiles_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_RemoveUnusedFieldFiles_Call) Return(_a0 error) *MockSegment_RemoveUnusedFieldFiles_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_RemoveUnusedFieldFiles_Call) RunAndReturn(run func() error) *MockSegment_RemoveUnusedFieldFiles_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ResetIndexesLazyLoad provides a mock function with given fields: lazyState
|
|
func (_m *MockSegment) ResetIndexesLazyLoad(lazyState bool) {
|
|
_m.Called(lazyState)
|
|
}
|
|
|
|
// MockSegment_ResetIndexesLazyLoad_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetIndexesLazyLoad'
|
|
type MockSegment_ResetIndexesLazyLoad_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ResetIndexesLazyLoad is a helper method to define mock.On call
|
|
// - lazyState bool
|
|
func (_e *MockSegment_Expecter) ResetIndexesLazyLoad(lazyState interface{}) *MockSegment_ResetIndexesLazyLoad_Call {
|
|
return &MockSegment_ResetIndexesLazyLoad_Call{Call: _e.mock.On("ResetIndexesLazyLoad", lazyState)}
|
|
}
|
|
|
|
func (_c *MockSegment_ResetIndexesLazyLoad_Call) Run(run func(lazyState bool)) *MockSegment_ResetIndexesLazyLoad_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_ResetIndexesLazyLoad_Call) Return() *MockSegment_ResetIndexesLazyLoad_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_ResetIndexesLazyLoad_Call) RunAndReturn(run func(bool)) *MockSegment_ResetIndexesLazyLoad_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ResourceGroup provides a mock function with given fields:
|
|
func (_m *MockSegment) ResourceGroup() string {
|
|
ret := _m.Called()
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_ResourceGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceGroup'
|
|
type MockSegment_ResourceGroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ResourceGroup is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) ResourceGroup() *MockSegment_ResourceGroup_Call {
|
|
return &MockSegment_ResourceGroup_Call{Call: _e.mock.On("ResourceGroup")}
|
|
}
|
|
|
|
func (_c *MockSegment_ResourceGroup_Call) Run(run func()) *MockSegment_ResourceGroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_ResourceGroup_Call) Return(_a0 string) *MockSegment_ResourceGroup_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_ResourceGroup_Call) RunAndReturn(run func() string) *MockSegment_ResourceGroup_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ResourceUsageEstimate provides a mock function with given fields:
|
|
func (_m *MockSegment) ResourceUsageEstimate() ResourceUsage {
|
|
ret := _m.Called()
|
|
|
|
var r0 ResourceUsage
|
|
if rf, ok := ret.Get(0).(func() ResourceUsage); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(ResourceUsage)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_ResourceUsageEstimate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUsageEstimate'
|
|
type MockSegment_ResourceUsageEstimate_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ResourceUsageEstimate is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) ResourceUsageEstimate() *MockSegment_ResourceUsageEstimate_Call {
|
|
return &MockSegment_ResourceUsageEstimate_Call{Call: _e.mock.On("ResourceUsageEstimate")}
|
|
}
|
|
|
|
func (_c *MockSegment_ResourceUsageEstimate_Call) Run(run func()) *MockSegment_ResourceUsageEstimate_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_ResourceUsageEstimate_Call) Return(_a0 ResourceUsage) *MockSegment_ResourceUsageEstimate_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_ResourceUsageEstimate_Call) RunAndReturn(run func() ResourceUsage) *MockSegment_ResourceUsageEstimate_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Retrieve provides a mock function with given fields: ctx, plan
|
|
func (_m *MockSegment) Retrieve(ctx context.Context, plan *RetrievePlan) (*segcorepb.RetrieveResults, error) {
|
|
ret := _m.Called(ctx, plan)
|
|
|
|
var r0 *segcorepb.RetrieveResults
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *RetrievePlan) (*segcorepb.RetrieveResults, error)); ok {
|
|
return rf(ctx, plan)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *RetrievePlan) *segcorepb.RetrieveResults); ok {
|
|
r0 = rf(ctx, plan)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*segcorepb.RetrieveResults)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *RetrievePlan) error); ok {
|
|
r1 = rf(ctx, plan)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSegment_Retrieve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Retrieve'
|
|
type MockSegment_Retrieve_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Retrieve is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - plan *RetrievePlan
|
|
func (_e *MockSegment_Expecter) Retrieve(ctx interface{}, plan interface{}) *MockSegment_Retrieve_Call {
|
|
return &MockSegment_Retrieve_Call{Call: _e.mock.On("Retrieve", ctx, plan)}
|
|
}
|
|
|
|
func (_c *MockSegment_Retrieve_Call) Run(run func(ctx context.Context, plan *RetrievePlan)) *MockSegment_Retrieve_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*RetrievePlan))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Retrieve_Call) Return(_a0 *segcorepb.RetrieveResults, _a1 error) *MockSegment_Retrieve_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Retrieve_Call) RunAndReturn(run func(context.Context, *RetrievePlan) (*segcorepb.RetrieveResults, error)) *MockSegment_Retrieve_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RetrieveByOffsets provides a mock function with given fields: ctx, plan, offsets
|
|
func (_m *MockSegment) RetrieveByOffsets(ctx context.Context, plan *RetrievePlan, offsets []int64) (*segcorepb.RetrieveResults, error) {
|
|
ret := _m.Called(ctx, plan, offsets)
|
|
|
|
var r0 *segcorepb.RetrieveResults
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *RetrievePlan, []int64) (*segcorepb.RetrieveResults, error)); ok {
|
|
return rf(ctx, plan, offsets)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *RetrievePlan, []int64) *segcorepb.RetrieveResults); ok {
|
|
r0 = rf(ctx, plan, offsets)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*segcorepb.RetrieveResults)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *RetrievePlan, []int64) error); ok {
|
|
r1 = rf(ctx, plan, offsets)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSegment_RetrieveByOffsets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByOffsets'
|
|
type MockSegment_RetrieveByOffsets_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RetrieveByOffsets is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - plan *RetrievePlan
|
|
// - offsets []int64
|
|
func (_e *MockSegment_Expecter) RetrieveByOffsets(ctx interface{}, plan interface{}, offsets interface{}) *MockSegment_RetrieveByOffsets_Call {
|
|
return &MockSegment_RetrieveByOffsets_Call{Call: _e.mock.On("RetrieveByOffsets", ctx, plan, offsets)}
|
|
}
|
|
|
|
func (_c *MockSegment_RetrieveByOffsets_Call) Run(run func(ctx context.Context, plan *RetrievePlan, offsets []int64)) *MockSegment_RetrieveByOffsets_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*RetrievePlan), args[2].([]int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_RetrieveByOffsets_Call) Return(_a0 *segcorepb.RetrieveResults, _a1 error) *MockSegment_RetrieveByOffsets_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_RetrieveByOffsets_Call) RunAndReturn(run func(context.Context, *RetrievePlan, []int64) (*segcorepb.RetrieveResults, error)) *MockSegment_RetrieveByOffsets_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RowNum provides a mock function with given fields:
|
|
func (_m *MockSegment) RowNum() int64 {
|
|
ret := _m.Called()
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_RowNum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RowNum'
|
|
type MockSegment_RowNum_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RowNum is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) RowNum() *MockSegment_RowNum_Call {
|
|
return &MockSegment_RowNum_Call{Call: _e.mock.On("RowNum")}
|
|
}
|
|
|
|
func (_c *MockSegment_RowNum_Call) Run(run func()) *MockSegment_RowNum_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_RowNum_Call) Return(_a0 int64) *MockSegment_RowNum_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_RowNum_Call) RunAndReturn(run func() int64) *MockSegment_RowNum_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Search provides a mock function with given fields: ctx, searchReq
|
|
func (_m *MockSegment) Search(ctx context.Context, searchReq *SearchRequest) (*SearchResult, error) {
|
|
ret := _m.Called(ctx, searchReq)
|
|
|
|
var r0 *SearchResult
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *SearchRequest) (*SearchResult, error)); ok {
|
|
return rf(ctx, searchReq)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *SearchRequest) *SearchResult); ok {
|
|
r0 = rf(ctx, searchReq)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*SearchResult)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *SearchRequest) error); ok {
|
|
r1 = rf(ctx, searchReq)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockSegment_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
|
|
type MockSegment_Search_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Search is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - searchReq *SearchRequest
|
|
func (_e *MockSegment_Expecter) Search(ctx interface{}, searchReq interface{}) *MockSegment_Search_Call {
|
|
return &MockSegment_Search_Call{Call: _e.mock.On("Search", ctx, searchReq)}
|
|
}
|
|
|
|
func (_c *MockSegment_Search_Call) Run(run func(ctx context.Context, searchReq *SearchRequest)) *MockSegment_Search_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*SearchRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Search_Call) Return(_a0 *SearchResult, _a1 error) *MockSegment_Search_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Search_Call) RunAndReturn(run func(context.Context, *SearchRequest) (*SearchResult, error)) *MockSegment_Search_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Shard provides a mock function with given fields:
|
|
func (_m *MockSegment) Shard() metautil.Channel {
|
|
ret := _m.Called()
|
|
|
|
var r0 metautil.Channel
|
|
if rf, ok := ret.Get(0).(func() metautil.Channel); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(metautil.Channel)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_Shard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shard'
|
|
type MockSegment_Shard_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Shard is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) Shard() *MockSegment_Shard_Call {
|
|
return &MockSegment_Shard_Call{Call: _e.mock.On("Shard")}
|
|
}
|
|
|
|
func (_c *MockSegment_Shard_Call) Run(run func()) *MockSegment_Shard_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Shard_Call) Return(_a0 metautil.Channel) *MockSegment_Shard_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Shard_Call) RunAndReturn(run func() metautil.Channel) *MockSegment_Shard_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// StartPosition provides a mock function with given fields:
|
|
func (_m *MockSegment) StartPosition() *msgpb.MsgPosition {
|
|
ret := _m.Called()
|
|
|
|
var r0 *msgpb.MsgPosition
|
|
if rf, ok := ret.Get(0).(func() *msgpb.MsgPosition); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*msgpb.MsgPosition)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_StartPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartPosition'
|
|
type MockSegment_StartPosition_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// StartPosition is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) StartPosition() *MockSegment_StartPosition_Call {
|
|
return &MockSegment_StartPosition_Call{Call: _e.mock.On("StartPosition")}
|
|
}
|
|
|
|
func (_c *MockSegment_StartPosition_Call) Run(run func()) *MockSegment_StartPosition_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_StartPosition_Call) Return(_a0 *msgpb.MsgPosition) *MockSegment_StartPosition_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_StartPosition_Call) RunAndReturn(run func() *msgpb.MsgPosition) *MockSegment_StartPosition_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// TestLocations provides a mock function with given fields: pk, loc
|
|
func (_m *MockSegment) TestLocations(pk storage.PrimaryKey, loc []uint64) bool {
|
|
ret := _m.Called(pk, loc)
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func(storage.PrimaryKey, []uint64) bool); ok {
|
|
r0 = rf(pk, loc)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_TestLocations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestLocations'
|
|
type MockSegment_TestLocations_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// TestLocations is a helper method to define mock.On call
|
|
// - pk storage.PrimaryKey
|
|
// - loc []uint64
|
|
func (_e *MockSegment_Expecter) TestLocations(pk interface{}, loc interface{}) *MockSegment_TestLocations_Call {
|
|
return &MockSegment_TestLocations_Call{Call: _e.mock.On("TestLocations", pk, loc)}
|
|
}
|
|
|
|
func (_c *MockSegment_TestLocations_Call) Run(run func(pk storage.PrimaryKey, loc []uint64)) *MockSegment_TestLocations_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(storage.PrimaryKey), args[1].([]uint64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_TestLocations_Call) Return(_a0 bool) *MockSegment_TestLocations_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_TestLocations_Call) RunAndReturn(run func(storage.PrimaryKey, []uint64) bool) *MockSegment_TestLocations_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Type provides a mock function with given fields:
|
|
func (_m *MockSegment) Type() commonpb.SegmentState {
|
|
ret := _m.Called()
|
|
|
|
var r0 commonpb.SegmentState
|
|
if rf, ok := ret.Get(0).(func() commonpb.SegmentState); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(commonpb.SegmentState)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_Type_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Type'
|
|
type MockSegment_Type_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Type is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) Type() *MockSegment_Type_Call {
|
|
return &MockSegment_Type_Call{Call: _e.mock.On("Type")}
|
|
}
|
|
|
|
func (_c *MockSegment_Type_Call) Run(run func()) *MockSegment_Type_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Type_Call) Return(_a0 commonpb.SegmentState) *MockSegment_Type_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Type_Call) RunAndReturn(run func() commonpb.SegmentState) *MockSegment_Type_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Unpin provides a mock function with given fields:
|
|
func (_m *MockSegment) Unpin() {
|
|
_m.Called()
|
|
}
|
|
|
|
// MockSegment_Unpin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unpin'
|
|
type MockSegment_Unpin_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Unpin is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) Unpin() *MockSegment_Unpin_Call {
|
|
return &MockSegment_Unpin_Call{Call: _e.mock.On("Unpin")}
|
|
}
|
|
|
|
func (_c *MockSegment_Unpin_Call) Run(run func()) *MockSegment_Unpin_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Unpin_Call) Return() *MockSegment_Unpin_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Unpin_Call) RunAndReturn(run func()) *MockSegment_Unpin_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateBloomFilter provides a mock function with given fields: pks
|
|
func (_m *MockSegment) UpdateBloomFilter(pks []storage.PrimaryKey) {
|
|
_m.Called(pks)
|
|
}
|
|
|
|
// MockSegment_UpdateBloomFilter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBloomFilter'
|
|
type MockSegment_UpdateBloomFilter_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateBloomFilter is a helper method to define mock.On call
|
|
// - pks []storage.PrimaryKey
|
|
func (_e *MockSegment_Expecter) UpdateBloomFilter(pks interface{}) *MockSegment_UpdateBloomFilter_Call {
|
|
return &MockSegment_UpdateBloomFilter_Call{Call: _e.mock.On("UpdateBloomFilter", pks)}
|
|
}
|
|
|
|
func (_c *MockSegment_UpdateBloomFilter_Call) Run(run func(pks []storage.PrimaryKey)) *MockSegment_UpdateBloomFilter_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].([]storage.PrimaryKey))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_UpdateBloomFilter_Call) Return() *MockSegment_UpdateBloomFilter_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_UpdateBloomFilter_Call) RunAndReturn(run func([]storage.PrimaryKey)) *MockSegment_UpdateBloomFilter_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Version provides a mock function with given fields:
|
|
func (_m *MockSegment) Version() int64 {
|
|
ret := _m.Called()
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockSegment_Version_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Version'
|
|
type MockSegment_Version_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Version is a helper method to define mock.On call
|
|
func (_e *MockSegment_Expecter) Version() *MockSegment_Version_Call {
|
|
return &MockSegment_Version_Call{Call: _e.mock.On("Version")}
|
|
}
|
|
|
|
func (_c *MockSegment_Version_Call) Run(run func()) *MockSegment_Version_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Version_Call) Return(_a0 int64) *MockSegment_Version_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockSegment_Version_Call) RunAndReturn(run func() int64) *MockSegment_Version_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockSegment creates a new instance of MockSegment. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewMockSegment(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockSegment {
|
|
mock := &MockSegment{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|