func (m *MockSQLExecutor) QueryStringsWithLog(ctx context.Context, query, purpose string, logger log.Logger) ([][]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryStringsWithLog", ctx, query, purpose, logger)
	ret0, _ := ret[0].([][]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
QueryStringsWithLog mocks base method
package mock
import (
	context "context"
	sql "database/sql"
	gomock "github.com/golang/mock/gomock"
	parser "github.com/pingcap/parser"
	model "github.com/pingcap/parser/model"
	checkpoints "github.com/pingcap/tidb-lightning/lightning/checkpoints"
	config "github.com/pingcap/tidb-lightning/lightning/config"
	glue "github.com/pingcap/tidb-lightning/lightning/glue"
	log "github.com/pingcap/tidb-lightning/lightning/log"
	reflect "reflect"
)
type MockGlue struct {
	ctrl     *gomock.Controller
	recorder *MockGlueMockRecorder
}
type MockGlueMockRecorder struct {
	mock *MockGlue
}
func NewMockGlue(ctrl *gomock.Controller) *MockGlue {
	mock := &MockGlue{ctrl: ctrl}
	mock.recorder = &MockGlueMockRecorder{mock}
	return mock
}
func (m *MockGlue) EXPECT() *MockGlueMockRecorder {
	return m.recorder
}
func (m *MockGlue) OwnsSQLExecutor() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OwnsSQLExecutor")
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockGlueMockRecorder) OwnsSQLExecutor() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OwnsSQLExecutor", reflect.TypeOf((*MockGlue)(nil).OwnsSQLExecutor))
}
func (m *MockGlue) GetSQLExecutor() glue.SQLExecutor {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSQLExecutor")
	ret0, _ := ret[0].(glue.SQLExecutor)
	return ret0
}
func (mr *MockGlueMockRecorder) GetSQLExecutor() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSQLExecutor", reflect.TypeOf((*MockGlue)(nil).GetSQLExecutor))
}
func (m *MockGlue) GetDB() (*sql.DB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDB")
	ret0, _ := ret[0].(*sql.DB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockGlueMockRecorder) GetDB() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDB", reflect.TypeOf((*MockGlue)(nil).GetDB))
}
func (m *MockGlue) GetParser() *parser.Parser {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetParser")
	ret0, _ := ret[0].(*parser.Parser)
	return ret0
}
func (mr *MockGlueMockRecorder) GetParser() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParser", reflect.TypeOf((*MockGlue)(nil).GetParser))
}
func (m *MockGlue) GetTables(arg0 context.Context, arg1 string) ([]*model.TableInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTables", arg0, arg1)
	ret0, _ := ret[0].([]*model.TableInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockGlueMockRecorder) GetTables(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTables", reflect.TypeOf((*MockGlue)(nil).GetTables), arg0, arg1)
}
func (m *MockGlue) GetSession(arg0 context.Context) (checkpoints.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSession", arg0)
	ret0, _ := ret[0].(checkpoints.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockGlueMockRecorder) GetSession(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSession", reflect.TypeOf((*MockGlue)(nil).GetSession), arg0)
}
func (m *MockGlue) OpenCheckpointsDB(arg0 context.Context, arg1 *config.Config) (checkpoints.CheckpointsDB, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenCheckpointsDB", arg0, arg1)
	ret0, _ := ret[0].(checkpoints.CheckpointsDB)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockGlueMockRecorder) OpenCheckpointsDB(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenCheckpointsDB", reflect.TypeOf((*MockGlue)(nil).OpenCheckpointsDB), arg0, arg1)
}
func (m *MockGlue) Record(arg0 string, arg1 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Record", arg0, arg1)
}
func (mr *MockGlueMockRecorder) Record(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Record", reflect.TypeOf((*MockGlue)(nil).Record), arg0, arg1)
}
type MockSQLExecutor struct {
	ctrl     *gomock.Controller
	recorder *MockSQLExecutorMockRecorder
}
type MockSQLExecutorMockRecorder struct {
	mock *MockSQLExecutor
}
func NewMockSQLExecutor(ctrl *gomock.Controller) *MockSQLExecutor {
	mock := &MockSQLExecutor{ctrl: ctrl}
	mock.recorder = &MockSQLExecutorMockRecorder{mock}
	return mock
}
func (m *MockSQLExecutor) EXPECT() *MockSQLExecutorMockRecorder {
	return m.recorder
}
func (m *MockSQLExecutor) ExecuteWithLog(ctx context.Context, query, purpose string, logger log.Logger) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteWithLog", ctx, query, purpose, logger)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSQLExecutorMockRecorder) ExecuteWithLog(ctx, query, purpose, logger interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteWithLog", reflect.TypeOf((*MockSQLExecutor)(nil).ExecuteWithLog), ctx, query, purpose, logger)
}
func (m *MockSQLExecutor) ObtainStringWithLog(ctx context.Context, query, purpose string, logger log.Logger) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObtainStringWithLog", ctx, query, purpose, logger)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockSQLExecutorMockRecorder) ObtainStringWithLog(ctx, query, purpose, logger interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObtainStringWithLog", reflect.TypeOf((*MockSQLExecutor)(nil).ObtainStringWithLog), ctx, query, purpose, logger)
}