feat(eventstore): increase parallel write capabilities (#5940)

This implementation increases parallel write capabilities of the eventstore. Please have a look at the technical advisories: [05](https://zitadel.com/docs/support/advisory/a10005) and [06](https://zitadel.com/docs/support/advisory/a10006). The implementation of eventstore.push is rewritten and stored events are migrated to a new table `eventstore.events2`. If you are using cockroach: make sure that the database user of ZITADEL has `VIEWACTIVITY` grant. This is used to query events.
2025-08-12 01:47:33 +00:00 · 2023-10-19 12:19:10 +02:00
parent 259faba3f0
commit b5564572bc
791 changed files with 30326 additions and 43202 deletions
--- a/internal/eventstore/repository/mock/gen_mock.go
+++ b/internal/eventstore/repository/mock/gen_mock.go
@@ -1,3 +1,3 @@
 package mock

-//go:generate mockgen -package mock -destination ./repository.mock.go github.com/zitadel/zitadel/internal/eventstore/repository Repository
+//go:generate mockgen -package mock -destination ./repository.mock.go github.com/zitadel/zitadel/internal/eventstore Querier,Pusher
--- a/internal/eventstore/repository/mock/repository.mock.go
+++ b/internal/eventstore/repository/mock/repository.mock.go
@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/zitadel/zitadel/internal/eventstore/repository (interfaces: Repository)
+// Source: github.com/zitadel/zitadel/internal/eventstore (interfaces: Querier,Pusher)

 // Package mock is a generated GoMock package.
 package mock
@@ -9,63 +9,49 @@ import (
 	reflect "reflect"

 	gomock "github.com/golang/mock/gomock"
-	repository "github.com/zitadel/zitadel/internal/eventstore/repository"
+	eventstore "github.com/zitadel/zitadel/internal/eventstore"
 )

-// MockRepository is a mock of Repository interface.
-type MockRepository struct {
+// MockQuerier is a mock of Querier interface.
+type MockQuerier struct {
 	ctrl     *gomock.Controller
-	recorder *MockRepositoryMockRecorder
+	recorder *MockQuerierMockRecorder
 }

-// MockRepositoryMockRecorder is the mock recorder for MockRepository.
-type MockRepositoryMockRecorder struct {
-	mock *MockRepository
+// MockQuerierMockRecorder is the mock recorder for MockQuerier.
+type MockQuerierMockRecorder struct {
+	mock *MockQuerier
 }

-// NewMockRepository creates a new mock instance.
-func NewMockRepository(ctrl *gomock.Controller) *MockRepository {
-	mock := &MockRepository{ctrl: ctrl}
-	mock.recorder = &MockRepositoryMockRecorder{mock}
+// NewMockQuerier creates a new mock instance.
+func NewMockQuerier(ctrl *gomock.Controller) *MockQuerier {
+	mock := &MockQuerier{ctrl: ctrl}
+	mock.recorder = &MockQuerierMockRecorder{mock}
 	return mock
 }

 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder {
+func (m *MockQuerier) EXPECT() *MockQuerierMockRecorder {
 	return m.recorder
 }

-// CreateInstance mocks base method.
-func (m *MockRepository) CreateInstance(arg0 context.Context, arg1 string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateInstance", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// CreateInstance indicates an expected call of CreateInstance.
-func (mr *MockRepositoryMockRecorder) CreateInstance(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstance", reflect.TypeOf((*MockRepository)(nil).CreateInstance), arg0, arg1)
-}
-
 // Filter mocks base method.
-func (m *MockRepository) Filter(arg0 context.Context, arg1 *repository.SearchQuery) ([]*repository.Event, error) {
+func (m *MockQuerier) Filter(arg0 context.Context, arg1 *eventstore.SearchQueryBuilder) ([]eventstore.Event, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Filter", arg0, arg1)
-	ret0, _ := ret[0].([]*repository.Event)
+	ret0, _ := ret[0].([]eventstore.Event)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }

 // Filter indicates an expected call of Filter.
-func (mr *MockRepositoryMockRecorder) Filter(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockQuerierMockRecorder) Filter(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Filter", reflect.TypeOf((*MockRepository)(nil).Filter), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Filter", reflect.TypeOf((*MockQuerier)(nil).Filter), arg0, arg1)
 }

 // Health mocks base method.
-func (m *MockRepository) Health(arg0 context.Context) error {
+func (m *MockQuerier) Health(arg0 context.Context) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Health", arg0)
 	ret0, _ := ret[0].(error)
@@ -73,13 +59,13 @@ func (m *MockRepository) Health(arg0 context.Context) error {
 }

 // Health indicates an expected call of Health.
-func (mr *MockRepositoryMockRecorder) Health(arg0 interface{}) *gomock.Call {
+func (mr *MockQuerierMockRecorder) Health(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockRepository)(nil).Health), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockQuerier)(nil).Health), arg0)
 }

 // InstanceIDs mocks base method.
-func (m *MockRepository) InstanceIDs(arg0 context.Context, arg1 *repository.SearchQuery) ([]string, error) {
+func (m *MockQuerier) InstanceIDs(arg0 context.Context, arg1 *eventstore.SearchQueryBuilder) ([]string, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "InstanceIDs", arg0, arg1)
 	ret0, _ := ret[0].([]string)
@@ -88,41 +74,79 @@ func (m *MockRepository) InstanceIDs(arg0 context.Context, arg1 *repository.Sear
 }

 // InstanceIDs indicates an expected call of InstanceIDs.
-func (mr *MockRepositoryMockRecorder) InstanceIDs(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockQuerierMockRecorder) InstanceIDs(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDs", reflect.TypeOf((*MockRepository)(nil).InstanceIDs), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDs", reflect.TypeOf((*MockQuerier)(nil).InstanceIDs), arg0, arg1)
 }

 // LatestSequence mocks base method.
-func (m *MockRepository) LatestSequence(arg0 context.Context, arg1 *repository.SearchQuery) (uint64, error) {
+func (m *MockQuerier) LatestSequence(arg0 context.Context, arg1 *eventstore.SearchQueryBuilder) (float64, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "LatestSequence", arg0, arg1)
-	ret0, _ := ret[0].(uint64)
+	ret0, _ := ret[0].(float64)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }

 // LatestSequence indicates an expected call of LatestSequence.
-func (mr *MockRepositoryMockRecorder) LatestSequence(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockQuerierMockRecorder) LatestSequence(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestSequence", reflect.TypeOf((*MockRepository)(nil).LatestSequence), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestSequence", reflect.TypeOf((*MockQuerier)(nil).LatestSequence), arg0, arg1)
 }

-// Push mocks base method.
-func (m *MockRepository) Push(arg0 context.Context, arg1 []*repository.Event, arg2 ...*repository.UniqueConstraint) error {
+// MockPusher is a mock of Pusher interface.
+type MockPusher struct {
+	ctrl     *gomock.Controller
+	recorder *MockPusherMockRecorder
+}
+
+// MockPusherMockRecorder is the mock recorder for MockPusher.
+type MockPusherMockRecorder struct {
+	mock *MockPusher
+}
+
+// NewMockPusher creates a new mock instance.
+func NewMockPusher(ctrl *gomock.Controller) *MockPusher {
+	mock := &MockPusher{ctrl: ctrl}
+	mock.recorder = &MockPusherMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPusher) EXPECT() *MockPusherMockRecorder {
+	return m.recorder
+}
+
+// Health mocks base method.
+func (m *MockPusher) Health(arg0 context.Context) error {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "Push", varargs...)
+	ret := m.ctrl.Call(m, "Health", arg0)
 	ret0, _ := ret[0].(error)
 	return ret0
 }

-// Push indicates an expected call of Push.
-func (mr *MockRepositoryMockRecorder) Push(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// Health indicates an expected call of Health.
+func (mr *MockPusherMockRecorder) Health(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockRepository)(nil).Push), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockPusher)(nil).Health), arg0)
+}
+
+// Push mocks base method.
+func (m *MockPusher) Push(arg0 context.Context, arg1 ...eventstore.Command) ([]eventstore.Event, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0}
+	for _, a := range arg1 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Push", varargs...)
+	ret0, _ := ret[0].([]eventstore.Event)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Push indicates an expected call of Push.
+func (mr *MockPusherMockRecorder) Push(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockPusher)(nil).Push), varargs...)
 }
--- a/internal/eventstore/repository/mock/repository.mock.impl.go
+++ b/internal/eventstore/repository/mock/repository.mock.impl.go
@@ -2,92 +2,208 @@ package mock

 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"testing"
+	"time"

 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"

+	"github.com/zitadel/zitadel/internal/eventstore"
 	"github.com/zitadel/zitadel/internal/eventstore/repository"
 )

+type MockRepository struct {
+	*MockPusher
+	*MockQuerier
+}
+
 func NewRepo(t *testing.T) *MockRepository {
-	return NewMockRepository(gomock.NewController(t))
+	controller := gomock.NewController(t)
+	return &MockRepository{
+		MockPusher:  NewMockPusher(controller),
+		MockQuerier: NewMockQuerier(controller),
+	}
 }

 func (m *MockRepository) ExpectFilterNoEventsNoError() *MockRepository {
-	m.EXPECT().Filter(gomock.Any(), gomock.Any()).Return(nil, nil)
+	m.MockQuerier.ctrl.T.Helper()
+
+	m.MockQuerier.EXPECT().Filter(gomock.Any(), gomock.Any()).Return(nil, nil)
 	return m
 }

-func (m *MockRepository) ExpectFilterEvents(events ...*repository.Event) *MockRepository {
-	m.EXPECT().Filter(gomock.Any(), gomock.Any()).Return(events, nil)
+func (m *MockRepository) ExpectFilterEvents(events ...eventstore.Event) *MockRepository {
+	m.MockQuerier.ctrl.T.Helper()
+
+	m.MockQuerier.EXPECT().Filter(gomock.Any(), gomock.Any()).Return(events, nil)
 	return m
 }

 func (m *MockRepository) ExpectFilterEventsError(err error) *MockRepository {
-	m.EXPECT().Filter(gomock.Any(), gomock.Any()).Return(nil, err)
+	m.MockQuerier.ctrl.T.Helper()
+
+	m.MockQuerier.EXPECT().Filter(gomock.Any(), gomock.Any()).Return(nil, err)
 	return m
 }

 func (m *MockRepository) ExpectInstanceIDs(hasFilters []*repository.Filter, instanceIDs ...string) *MockRepository {
+	m.MockQuerier.ctrl.T.Helper()
+
 	matcher := gomock.Any()
 	if len(hasFilters) > 0 {
-		matcher = &filterQueryMatcher{Filters: [][]*repository.Filter{hasFilters}}
+		matcher = &filterQueryMatcher{SubQueries: [][]*repository.Filter{hasFilters}}
 	}
-	m.EXPECT().InstanceIDs(gomock.Any(), matcher).Return(instanceIDs, nil)
+	m.MockQuerier.EXPECT().InstanceIDs(gomock.Any(), matcher).Return(instanceIDs, nil)
 	return m
 }

 func (m *MockRepository) ExpectInstanceIDsError(err error) *MockRepository {
-	m.EXPECT().InstanceIDs(gomock.Any(), gomock.Any()).Return(nil, err)
+	m.MockQuerier.ctrl.T.Helper()
+
+	m.MockQuerier.EXPECT().InstanceIDs(gomock.Any(), gomock.Any()).Return(nil, err)
 	return m
 }

-func (m *MockRepository) ExpectPush(expectedEvents []*repository.Event, expectedUniqueConstraints ...*repository.UniqueConstraint) *MockRepository {
-	m.EXPECT().Push(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
-		func(ctx context.Context, events []*repository.Event, uniqueConstraints ...*repository.UniqueConstraint) error {
-			assert.Equal(m.ctrl.T, expectedEvents, events)
-			if expectedUniqueConstraints == nil {
-				expectedUniqueConstraints = []*repository.UniqueConstraint{}
+func (m *MockRepository) ExpectPush(expectedCommands []eventstore.Command) *MockRepository {
+	m.MockPusher.EXPECT().Push(gomock.Any(), gomock.Any()).DoAndReturn(
+		func(ctx context.Context, commands ...eventstore.Command) ([]eventstore.Event, error) {
+			m.MockPusher.ctrl.T.Helper()
+
+			if len(expectedCommands) != len(commands) {
+				return nil, fmt.Errorf("unexpected amount of commands: want %d, got %d", len(expectedCommands), len(commands))
 			}
-			assert.Equal(m.ctrl.T, expectedUniqueConstraints, uniqueConstraints)
-			return nil
-		},
-	)
-	return m
-}
+			for i, expectedCommand := range expectedCommands {
+				if !assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Aggregate(), commands[i].Aggregate()) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.Aggregate [%d]: expected: %#v got: %#v", i, expectedCommand.Aggregate(), commands[i].Aggregate())
+				}
+				if !assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Creator(), commands[i].Creator()) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.Creator [%d]: expected: %#v got: %#v", i, expectedCommand.Creator(), commands[i].Creator())
+				}
+				if !assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Type(), commands[i].Type()) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.Type [%d]: expected: %#v got: %#v", i, expectedCommand.Type(), commands[i].Type())
+				}
+				if !assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Revision(), commands[i].Revision()) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.Revision [%d]: expected: %#v got: %#v", i, expectedCommand.Revision(), commands[i].Revision())
+				}

-func (m *MockRepository) ExpectPushFailed(err error, expectedEvents []*repository.Event, expectedUniqueConstraints ...*repository.UniqueConstraint) *MockRepository {
-	m.EXPECT().Push(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
-		func(ctx context.Context, events []*repository.Event, uniqueConstraints ...*repository.UniqueConstraint) error {
-			assert.Equal(m.ctrl.T, expectedEvents, events)
-			if expectedUniqueConstraints == nil {
-				expectedUniqueConstraints = []*repository.UniqueConstraint{}
+				var expectedPayload []byte
+				expectedPayload, ok := expectedCommand.Payload().([]byte)
+				if !ok {
+					expectedPayload, _ = json.Marshal(expectedCommand.Payload())
+				}
+				if string(expectedPayload) == "" {
+					expectedPayload = []byte("null")
+				}
+				gotPayload, _ := json.Marshal(commands[i].Payload())
+
+				if !assert.Equal(m.MockPusher.ctrl.T, expectedPayload, gotPayload) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.Payload [%d]: expected: %#v got: %#v", i, expectedCommand.Payload(), commands[i].Payload())
+				}
+				if !assert.ElementsMatch(m.MockPusher.ctrl.T, expectedCommand.UniqueConstraints(), commands[i].UniqueConstraints()) {
+					m.MockPusher.ctrl.T.Errorf("invalid command.UniqueConstraints [%d]: expected: %#v got: %#v", i, expectedCommand.UniqueConstraints(), commands[i].UniqueConstraints())
+				}
 			}
-			assert.Equal(m.ctrl.T, expectedUniqueConstraints, uniqueConstraints)
-			return err
+			events := make([]eventstore.Event, len(commands))
+			for i, command := range commands {
+				events[i] = &mockEvent{
+					Command: command,
+				}
+			}
+			return events, nil
 		},
 	)
 	return m
 }

-func (m *MockRepository) ExpectRandomPush(expectedEvents []*repository.Event, expectedUniqueConstraints ...*repository.UniqueConstraint) *MockRepository {
-	m.EXPECT().Push(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
-		func(ctx context.Context, events []*repository.Event, uniqueConstraints ...*repository.UniqueConstraint) error {
-			assert.Len(m.ctrl.T, events, len(expectedEvents))
-			assert.Len(m.ctrl.T, expectedUniqueConstraints, len(uniqueConstraints))
-			return nil
+func (m *MockRepository) ExpectPushFailed(err error, expectedCommands []eventstore.Command) *MockRepository {
+	m.MockPusher.ctrl.T.Helper()
+
+	m.MockPusher.EXPECT().Push(gomock.Any(), gomock.Any()).DoAndReturn(
+		func(ctx context.Context, commands ...eventstore.Command) ([]eventstore.Event, error) {
+			if len(expectedCommands) != len(commands) {
+				return nil, fmt.Errorf("unexpected amount of commands: want %d, got %d", len(expectedCommands), len(commands))
+			}
+			for i, expectedCommand := range expectedCommands {
+				assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Aggregate(), commands[i].Aggregate())
+				assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Creator(), commands[i].Creator())
+				assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Type(), commands[i].Type())
+				assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Revision(), commands[i].Revision())
+				assert.Equal(m.MockPusher.ctrl.T, expectedCommand.Payload(), commands[i].Payload())
+				assert.ElementsMatch(m.MockPusher.ctrl.T, expectedCommand.UniqueConstraints(), commands[i].UniqueConstraints())
+			}
+
+			return nil, err
 		},
 	)
 	return m
 }

-func (m *MockRepository) ExpectRandomPushFailed(err error, expectedEvents []*repository.Event, expectedUniqueConstraints ...*repository.UniqueConstraint) *MockRepository {
-	m.EXPECT().Push(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
-		func(ctx context.Context, events []*repository.Event, uniqueConstraints ...*repository.UniqueConstraint) error {
-			assert.Len(m.ctrl.T, events, len(expectedEvents))
-			assert.Len(m.ctrl.T, expectedUniqueConstraints, len(uniqueConstraints))
-			return err
+type mockEvent struct {
+	eventstore.Command
+	sequence  uint64
+	createdAt time.Time
+}
+
+// DataAsBytes implements eventstore.Event
+func (e *mockEvent) DataAsBytes() []byte {
+	if e.Payload() == nil {
+		return nil
+	}
+	payload, err := json.Marshal(e.Payload())
+	if err != nil {
+		panic("unable to unmarshal")
+	}
+	return payload
+}
+
+func (e *mockEvent) Unmarshal(ptr any) error {
+	if e.Payload() == nil {
+		return nil
+	}
+	payload, err := json.Marshal(e.Payload())
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(payload, ptr)
+}
+
+func (e *mockEvent) Sequence() uint64 {
+	return e.sequence
+}
+
+func (e *mockEvent) Position() float64 {
+	return 0
+}
+
+func (e *mockEvent) CreatedAt() time.Time {
+	return e.createdAt
+}
+
+func (m *MockRepository) ExpectRandomPush(expectedCommands []eventstore.Command) *MockRepository {
+	m.MockPusher.EXPECT().Push(gomock.Any(), gomock.Any()).DoAndReturn(
+		func(ctx context.Context, commands ...eventstore.Command) ([]eventstore.Event, error) {
+			assert.Len(m.MockPusher.ctrl.T, commands, len(expectedCommands))
+
+			events := make([]eventstore.Event, len(commands))
+			for i, command := range commands {
+				events[i] = &mockEvent{
+					Command: command,
+				}
+			}
+
+			return events, nil
+		},
+	)
+	return m
+}
+
+func (m *MockRepository) ExpectRandomPushFailed(err error, expectedEvents []eventstore.Command) *MockRepository {
+	m.MockPusher.EXPECT().Push(gomock.Any(), gomock.Any()).DoAndReturn(
+		func(ctx context.Context, events ...eventstore.Command) ([]eventstore.Event, error) {
+			assert.Len(m.MockPusher.ctrl.T, events, len(expectedEvents))
+			return nil, err
 		},
 	)
 	return m
--- a/internal/eventstore/repository/mock/repository.mock.matcher.searchquery.go
+++ b/internal/eventstore/repository/mock/repository.mock.matcher.searchquery.go
@@ -11,7 +11,7 @@ type filterQueryMatcher repository.SearchQuery

 func (f *filterQueryMatcher) String() string {
 	var filterLists []string
-	for _, filterSlice := range f.Filters {
+	for _, filterSlice := range f.SubQueries {
 		var str string
 		for _, filter := range filterSlice {
 			str += "," + (*filterMatcher)(filter).String()
@@ -24,15 +24,15 @@ func (f *filterQueryMatcher) String() string {

 func (f *filterQueryMatcher) Matches(x interface{}) bool {
 	other := x.(*repository.SearchQuery)
-	if len(f.Filters) != len(other.Filters) {
+	if len(f.SubQueries) != len(other.SubQueries) {
 		return false
 	}
-	for filterSliceIdx, filterSlice := range f.Filters {
-		if len(filterSlice) != len(other.Filters[filterSliceIdx]) {
+	for filterSliceIdx, filterSlice := range f.SubQueries {
+		if len(filterSlice) != len(other.SubQueries[filterSliceIdx]) {
 			return false
 		}
-		for filterIdx, filter := range f.Filters[filterSliceIdx] {
-			if !(*filterMatcher)(filter).Matches(other.Filters[filterSliceIdx][filterIdx]) {
+		for filterIdx, filter := range f.SubQueries[filterSliceIdx] {
+			if !(*filterMatcher)(filter).Matches(other.SubQueries[filterSliceIdx][filterIdx]) {
 				return false
 			}
 		}