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.

internal/eventstore/search_query_test.go

@@ -1,17 +1,27 @@
 package eventstore
 
 import (
-	"math"
 	"reflect"
 	"testing"
-	"time"
-
-	"github.com/zitadel/zitadel/internal/database"
-	"github.com/zitadel/zitadel/internal/errors"
-	"github.com/zitadel/zitadel/internal/eventstore/repository"
 )
 
-func testAddQuery(queryFuncs ...func(*SearchQuery) *SearchQuery) func(*SearchQueryBuilder) *SearchQueryBuilder {
+func testSetQuery(queryFuncs ...func(*SearchQueryBuilder) *SearchQueryBuilder) func(*SearchQueryBuilder) *SearchQueryBuilder {
+	return func(builder *SearchQueryBuilder) *SearchQueryBuilder {
+		for _, queryFunc := range queryFuncs {
+			queryFunc(builder)
+		}
+		return builder
+	}
+}
+
+func testSetSequenceGreater(sequence uint64) func(*SearchQueryBuilder) *SearchQueryBuilder {
+	return func(builder *SearchQueryBuilder) *SearchQueryBuilder {
+		builder = builder.SequenceGreater(sequence)
+		return builder
+	}
+}
+
+func testAddSubQuery(queryFuncs ...func(*SearchQuery) *SearchQuery) func(*SearchQueryBuilder) *SearchQueryBuilder {
 	return func(builder *SearchQueryBuilder) *SearchQueryBuilder {
 		query := builder.AddQuery()
 		for _, queryFunc := range queryFuncs {
@@ -52,20 +62,6 @@ func testSetAggregateTypes(types ...AggregateType) func(*SearchQuery) *SearchQue
 	}
 }
 
-func testSetSequenceGreater(sequence uint64) func(*SearchQuery) *SearchQuery {
-	return func(query *SearchQuery) *SearchQuery {
-		query = query.SequenceGreater(sequence)
-		return query
-	}
-}
-
-func testSetSequenceLess(sequence uint64) func(*SearchQuery) *SearchQuery {
-	return func(query *SearchQuery) *SearchQuery {
-		query = query.SequenceLess(sequence)
-		return query
-	}
-}
-
 func testSetAggregateIDs(aggregateIDs ...string) func(*SearchQuery) *SearchQuery {
 	return func(query *SearchQuery) *SearchQuery {
 		query = query.AggregateIDs(aggregateIDs...)
@@ -87,13 +83,6 @@ func testSetResourceOwner(resourceOwner string) func(*SearchQueryBuilder) *Searc
 	}
 }
 
-func testSetCreationDateAfter(date time.Time) func(*SearchQuery) *SearchQuery {
-	return func(query *SearchQuery) *SearchQuery {
-		query = query.CreationDateAfter(date)
-		return query
-	}
-}
-
 func testSetSortOrder(asc bool) func(*SearchQueryBuilder) *SearchQueryBuilder {
 	return func(query *SearchQueryBuilder) *SearchQueryBuilder {
 		if asc {
@@ -121,16 +110,16 @@ func TestSearchQuerybuilderSetters(t *testing.T) {
 				columns: ColumnsEvent,
 			},
 			res: &SearchQueryBuilder{
-				columns: repository.Columns(ColumnsEvent),
+				columns: Columns(ColumnsEvent),
 			},
 		},
 		{
 			name: "set columns",
 			args: args{
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testSetColumns(repository.ColumnsMaxSequence)},
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testSetColumns(ColumnsMaxSequence)},
 			},
 			res: &SearchQueryBuilder{
-				columns: repository.ColumnsMaxSequence,
+				columns: ColumnsMaxSequence,
 			},
 		},
 		{
@@ -145,33 +134,18 @@ func TestSearchQuerybuilderSetters(t *testing.T) {
 		{
 			name: "set sequence greater",
 			args: args{
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddQuery(testSetSequenceGreater(90))},
-			},
-			res: &SearchQueryBuilder{
-				queries: []*SearchQuery{
-					{
-						eventSequenceGreater: 90,
-					},
+				setters: []func(b *SearchQueryBuilder) *SearchQueryBuilder{
+					testSetQuery(testSetSequenceGreater(90)),
 				},
 			},
-		},
-		{
-			name: "set sequence less",
-			args: args{
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddQuery(testSetSequenceLess(90))},
-			},
 			res: &SearchQueryBuilder{
-				queries: []*SearchQuery{
-					{
-						eventSequenceLess: 90,
-					},
-				},
+				eventSequenceGreater: 90,
 			},
 		},
 		{
 			name: "set aggregateIDs",
 			args: args{
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddQuery(testSetAggregateIDs("1235", "09824"))},
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddSubQuery(testSetAggregateIDs("1235", "09824"))},
 			},
 			res: &SearchQueryBuilder{
 				queries: []*SearchQuery{
@@ -184,7 +158,7 @@ func TestSearchQuerybuilderSetters(t *testing.T) {
 		{
 			name: "set eventTypes",
 			args: args{
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddQuery(testSetEventTypes("user.created", "user.updated"))},
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddSubQuery(testSetEventTypes("user.created", "user.updated"))},
 			},
 			res: &SearchQueryBuilder{
 				queries: []*SearchQuery{
@@ -206,7 +180,7 @@ func TestSearchQuerybuilderSetters(t *testing.T) {
 		{
 			name: "default search query",
 			args: args{
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddQuery(testSetAggregateTypes("user"), testSetAggregateIDs("1235", "024")), testSetSortOrder(false)},
+				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{testAddSubQuery(testSetAggregateTypes("user"), testSetAggregateIDs("1235", "024")), testSetSortOrder(false)},
 			},
 			res: &SearchQueryBuilder{
 				desc: true,
@@ -231,496 +205,6 @@ func TestSearchQuerybuilderSetters(t *testing.T) {
 	}
 }
 
-func TestSearchQuerybuilderBuild(t *testing.T) {
-	testNow := time.Now()
-	type args struct {
-		columns    Columns
-		setters    []func(*SearchQueryBuilder) *SearchQueryBuilder
-		instanceID string
-	}
-	type res struct {
-		isErr func(err error) bool
-		query *repository.SearchQuery
-	}
-	tests := []struct {
-		name string
-		args args
-		res  res
-	}{
-		{
-			name: "no aggregate types",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{},
-			},
-			res: res{
-				isErr: errors.IsPreconditionFailed,
-				query: nil,
-			},
-		},
-		{
-			name: "invalid column (too low)",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetColumns(Columns(-1)),
-					testAddQuery(testSetAggregateTypes("user")),
-				},
-			},
-			res: res{
-				isErr: errors.IsPreconditionFailed,
-			},
-		},
-		{
-			name: "invalid column (too high)",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetColumns(math.MaxInt32),
-					testAddQuery(testSetAggregateTypes("uesr")),
-				},
-			},
-			res: res{
-				isErr: errors.IsPreconditionFailed,
-			},
-		},
-		{
-			name: "filter aggregate type",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(testSetAggregateTypes("user")),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate types",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(testSetAggregateTypes("user", "org")),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, database.StringArray{"user", "org"}, repository.OperationIn),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type, limit, desc",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetLimit(5),
-					testSetSortOrder(false),
-					testAddQuery(
-						testSetSequenceGreater(100),
-						testSetAggregateTypes("user"),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    true,
-					Limit:   5,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldSequence, uint64(100), repository.OperationLess),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type, limit, asc",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetLimit(5),
-					testSetSortOrder(true),
-					testAddQuery(
-						testSetSequenceGreater(100),
-						testSetAggregateTypes("user"),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   5,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldSequence, uint64(100), repository.OperationGreater),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type, limit, desc, max event sequence cols",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetLimit(5),
-					testSetSortOrder(false),
-					testSetColumns(repository.ColumnsMaxSequence),
-					testAddQuery(
-						testSetSequenceGreater(100),
-						testSetAggregateTypes("user"),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsMaxSequence,
-					Desc:    true,
-					Limit:   5,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldSequence, uint64(100), repository.OperationLess),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type and aggregate id",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(
-						testSetAggregateTypes("user"),
-						testSetAggregateIDs("1234"),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldAggregateID, "1234", repository.OperationEquals),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter multiple aggregate type and aggregate id",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(
-						testSetAggregateTypes("user"),
-						testSetAggregateIDs("1234"),
-						testOr(
-							testSetAggregateTypes("org"),
-							testSetAggregateIDs("izu"),
-						),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldAggregateID, "1234", repository.OperationEquals),
-						},
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("org"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldAggregateID, "izu", repository.OperationEquals),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type and aggregate ids",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(
-						testSetAggregateTypes("user"),
-						testSetAggregateIDs("1234", "0815"),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldAggregateID, database.StringArray{"1234", "0815"}, repository.OperationIn),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type and sequence greater",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(
-						testSetAggregateTypes("user"),
-						testSetSequenceGreater(8),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldSequence, uint64(8), repository.OperationGreater),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type and event type",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(
-						testSetAggregateTypes("user"),
-						testSetEventTypes("user.created"),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldEventType, repository.EventType("user.created"), repository.OperationEquals),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type and event types",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(
-						testSetAggregateTypes("user"),
-						testSetEventTypes("user.created", "user.changed"),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldEventType, database.StringArray{"user.created", "user.changed"}, repository.OperationIn),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type resource owner",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testSetResourceOwner("hodor"),
-					testAddQuery(
-						testSetAggregateTypes("user"),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldResourceOwner, "hodor", repository.OperationEquals),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type and sequence between",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(
-						testSetAggregateTypes("user"),
-						testSetSequenceGreater(8),
-						testSetSequenceLess(16),
-					),
-				},
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldSequence, uint64(8), repository.OperationGreater),
-							repository.NewFilter(repository.FieldSequence, uint64(16), repository.OperationLess),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type and instanceID",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(
-						testSetAggregateTypes("user"),
-					),
-				},
-				instanceID: "instanceID",
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldInstanceID, "instanceID", repository.OperationEquals),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "filter aggregate type, instanceID and creation date after",
-			args: args{
-				columns: ColumnsEvent,
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(
-						testSetAggregateTypes("user"),
-						testSetCreationDateAfter(testNow),
-					),
-				},
-				instanceID: "instanceID",
-			},
-			res: res{
-				isErr: nil,
-				query: &repository.SearchQuery{
-					Columns: repository.ColumnsEvent,
-					Desc:    false,
-					Limit:   0,
-					Filters: [][]*repository.Filter{
-						{
-							repository.NewFilter(repository.FieldAggregateType, repository.AggregateType("user"), repository.OperationEquals),
-							repository.NewFilter(repository.FieldCreationDate, testNow, repository.OperationGreater),
-							repository.NewFilter(repository.FieldInstanceID, "instanceID", repository.OperationEquals),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "column invalid",
-			args: args{
-				columns: Columns(-1),
-				setters: []func(*SearchQueryBuilder) *SearchQueryBuilder{
-					testAddQuery(
-						testSetAggregateTypes("user"),
-					),
-				},
-			},
-			res: res{
-				isErr: errors.IsPreconditionFailed,
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			builder := NewSearchQueryBuilder(tt.args.columns)
-			for _, f := range tt.args.setters {
-				builder = f(builder)
-			}
-			query, err := builder.build(tt.args.instanceID)
-			if tt.res.isErr != nil && !tt.res.isErr(err) {
-				t.Errorf("wrong error(%T): %v", err, err)
-				return
-			}
-			if err != nil && tt.res.isErr == nil {
-				t.Errorf("no error expected: %v", err)
-				return
-			}
-
-			assertRepoQuery(t, tt.res.query, query)
-		})
-	}
-}
-
 func assertBuilder(t *testing.T, want, got *SearchQueryBuilder) {
 	t.Helper()
 
@@ -757,62 +241,14 @@ func assertQuery(t *testing.T, i int, want, got *SearchQuery) {
 	if !reflect.DeepEqual(got.eventData, want.eventData) {
 		t.Errorf("wrong eventData in query %d : got: %v want: %v", i, got.eventData, want.eventData)
 	}
-	if got.eventSequenceLess != want.eventSequenceLess {
-		t.Errorf("wrong eventSequenceLess in query %d : got: %v want: %v", i, got.eventSequenceLess, want.eventSequenceLess)
-	}
-	if got.eventSequenceGreater != want.eventSequenceGreater {
-		t.Errorf("wrong eventSequenceGreater in query %d : got: %v want: %v", i, got.eventSequenceGreater, want.eventSequenceGreater)
-	}
+	// if got.eventSequenceGreater != want.eventSequenceGreater {
+	// 	t.Errorf("wrong eventSequenceGreater in query %d : got: %v want: %v", i, got.eventSequenceGreater, want.eventSequenceGreater)
+	// }
 	if !reflect.DeepEqual(got.eventTypes, want.eventTypes) {
 		t.Errorf("wrong eventTypes in query %d : got: %v want: %v", i, got.eventTypes, want.eventTypes)
 	}
 }
 
-func assertRepoQuery(t *testing.T, want, got *repository.SearchQuery) {
-	t.Helper()
-
-	if want == nil && got == nil {
-		return
-	}
-
-	if !reflect.DeepEqual(got.Columns, want.Columns) {
-		t.Errorf("wrong columns in query: got: %v want: %v", got.Columns, want.Columns)
-	}
-	if got.Desc != want.Desc {
-		t.Errorf("wrong desc in query: got: %v want: %v", got.Desc, want.Desc)
-	}
-	if got.Limit != want.Limit {
-		t.Errorf("wrong limit in query: got: %v want: %v", got.Limit, want.Limit)
-	}
-
-	if len(got.Filters) != len(want.Filters) {
-		t.Errorf("wrong length of filters: got: %v want: %v", len(got.Filters), len(want.Filters))
-	}
-
-	for filterIdx, filter := range got.Filters {
-		if len(got.Filters) != len(want.Filters) {
-			t.Errorf("wrong length of subfilters: got: %v want: %v", len(filter), len(want.Filters[filterIdx]))
-		}
-		for subFilterIdx, f := range filter {
-			assertFilters(t, subFilterIdx, want.Filters[filterIdx][subFilterIdx], f)
-		}
-	}
-}
-
-func assertFilters(t *testing.T, i int, want, got *repository.Filter) {
-	t.Helper()
-
-	if want.Field != got.Field {
-		t.Errorf("wrong field in filter %d : got: %v want: %v", i, got.Field, want.Field)
-	}
-	if want.Operation != got.Operation {
-		t.Errorf("wrong operation in filter %d : got: %v want: %v", i, got.Operation, want.Operation)
-	}
-	if !reflect.DeepEqual(want.Value, got.Value) {
-		t.Errorf("wrong value in filter %d : got: %v want: %v", i, got.Value, want.Value)
-	}
-}
-
 func TestSearchQuery_matches(t *testing.T) {
 	type args struct {
 		event Event
@@ -823,27 +259,11 @@ func TestSearchQuery_matches(t *testing.T) {
 		event Event
 		want  bool
 	}{
-		{
-			name:  "sequence too low",
-			query: NewSearchQueryBuilder(ColumnsEvent).AddQuery().SequenceLess(10),
-			event: &BaseEvent{
-				sequence: 10,
-			},
-			want: false,
-		},
-		{
-			name:  "sequence too high",
-			query: NewSearchQueryBuilder(ColumnsEvent).AddQuery().SequenceGreater(60),
-			event: &BaseEvent{
-				sequence: 60,
-			},
-			want: false,
-		},
 		{
 			name:  "wrong aggregate type",
 			query: NewSearchQueryBuilder(ColumnsEvent).AddQuery().AggregateTypes("searched"),
 			event: &BaseEvent{
-				aggregate: Aggregate{
+				Agg: &Aggregate{
 					Type: "found",
 				},
 			},
@@ -853,7 +273,7 @@ func TestSearchQuery_matches(t *testing.T) {
 			name:  "wrong aggregate id",
 			query: NewSearchQueryBuilder(ColumnsEvent).AddQuery().AggregateIDs("1", "10", "100"),
 			event: &BaseEvent{
-				aggregate: Aggregate{
+				Agg: &Aggregate{
 					ID: "2",
 				},
 			},
@@ -864,16 +284,20 @@ func TestSearchQuery_matches(t *testing.T) {
 			query: NewSearchQueryBuilder(ColumnsEvent).AddQuery().EventTypes("event.searched.type"),
 			event: &BaseEvent{
 				EventType: "event.actual.type",
+				Agg:       &Aggregate{},
 			},
 			want: false,
 		},
 		{
 			name: "matching",
-			query: NewSearchQueryBuilder(ColumnsEvent).AddQuery().
-				SequenceLess(100).SequenceGreater(50).AggregateIDs("2").AggregateTypes("actual").EventTypes("event.actual.type"),
+			query: NewSearchQueryBuilder(ColumnsEvent).
+				AddQuery().
+				AggregateIDs("2").
+				AggregateTypes("actual").
+				EventTypes("event.actual.type"),
 			event: &BaseEvent{
-				sequence: 55,
-				aggregate: Aggregate{
+				Seq: 55,
+				Agg: &Aggregate{
 					ID:   "2",
 					Type: "actual",
 				},
@@ -885,8 +309,8 @@ func TestSearchQuery_matches(t *testing.T) {
 			name:  "matching empty query",
 			query: NewSearchQueryBuilder(ColumnsEvent).AddQuery(),
 			event: &BaseEvent{
-				sequence: 55,
-				aggregate: Aggregate{
+				Seq: 55,
+				Agg: &Aggregate{
 					ID:   "2",
 					Type: "actual",
 				},
@@ -898,12 +322,10 @@ func TestSearchQuery_matches(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			query := &SearchQuery{
-				aggregateTypes:       tt.query.aggregateTypes,
-				aggregateIDs:         tt.query.aggregateIDs,
-				eventSequenceGreater: tt.query.eventSequenceGreater,
-				eventSequenceLess:    tt.query.eventSequenceLess,
-				eventTypes:           tt.query.eventTypes,
-				eventData:            tt.query.eventData,
+				aggregateTypes: tt.query.aggregateTypes,
+				aggregateIDs:   tt.query.aggregateIDs,
+				eventTypes:     tt.query.eventTypes,
+				eventData:      tt.query.eventData,
 			}
 			if got := query.matches(tt.event); got != tt.want {
 				t.Errorf("SearchQuery.matches() = %v, want %v", got, tt.want)
@@ -923,6 +345,19 @@ func TestSearchQueryBuilder_Matches(t *testing.T) {
 		args    args
 		want    bool
 	}{
+		{
+			name:    "sequence too high",
+			builder: NewSearchQueryBuilder(ColumnsEvent).SequenceGreater(60),
+			args: args{
+				event: &BaseEvent{
+					Agg: &Aggregate{
+						InstanceID: "instance",
+					},
+					Seq: 60,
+				},
+			},
+			want: false,
+		},
 		{
 			name:    "limit exeeded",
 			builder: NewSearchQueryBuilder(ColumnsEvent).Limit(100),
@@ -937,7 +372,7 @@ func TestSearchQueryBuilder_Matches(t *testing.T) {
 			builder: NewSearchQueryBuilder(ColumnsEvent).ResourceOwner("query"),
 			args: args{
 				event: &BaseEvent{
-					aggregate: Aggregate{
+					Agg: &Aggregate{
 						ResourceOwner: "ro",
 					},
 				},
@@ -950,7 +385,7 @@ func TestSearchQueryBuilder_Matches(t *testing.T) {
 			builder: NewSearchQueryBuilder(ColumnsEvent).InstanceID("instance"),
 			args: args{
 				event: &BaseEvent{
-					aggregate: Aggregate{
+					Agg: &Aggregate{
 						InstanceID: "different instance",
 					},
 				},
@@ -959,14 +394,12 @@ func TestSearchQueryBuilder_Matches(t *testing.T) {
 			want: false,
 		},
 		{
-			name: "query failed",
-			builder: NewSearchQueryBuilder(ColumnsEvent).
-				AddQuery().
-				SequenceGreater(1000).
-				Builder(),
+			name:    "query failed",
+			builder: NewSearchQueryBuilder(ColumnsEvent).SequenceGreater(1000),
 			args: args{
 				event: &BaseEvent{
-					sequence: 999,
+					Seq: 999,
+					Agg: &Aggregate{},
 				},
 				existingLen: 0,
 			},
@@ -978,16 +411,14 @@ func TestSearchQueryBuilder_Matches(t *testing.T) {
 				Limit(1000).
 				ResourceOwner("ro").
 				InstanceID("instance").
-				AddQuery().
-				SequenceGreater(1000).
-				Builder(),
+				SequenceGreater(1000),
 			args: args{
 				event: &BaseEvent{
-					aggregate: Aggregate{
+					Agg: &Aggregate{
 						ResourceOwner: "ro",
 						InstanceID:    "instance",
 					},
-					sequence: 1001,
+					Seq: 1001,
 				},
 				existingLen: 999,
 			},
@@ -998,11 +429,11 @@ func TestSearchQueryBuilder_Matches(t *testing.T) {
 			builder: NewSearchQueryBuilder(ColumnsEvent),
 			args: args{
 				event: &BaseEvent{
-					aggregate: Aggregate{
+					Agg: &Aggregate{
 						ResourceOwner: "ro",
 						InstanceID:    "instance",
 					},
-					sequence: 1001,
+					Seq: 1001,
 				},
 				existingLen: 999,
 			},
@@ -1013,10 +444,10 @@ func TestSearchQueryBuilder_Matches(t *testing.T) {
 			builder: NewSearchQueryBuilder(ColumnsEvent),
 			args: args{
 				event: &BaseEvent{
-					aggregate: Aggregate{
+					Agg: &Aggregate{
 						ResourceOwner: "ro",
 					},
-					sequence: 1001,
+					Seq: 1001,
 				},
 				existingLen: 999,
 			},
@@ -1027,10 +458,10 @@ func TestSearchQueryBuilder_Matches(t *testing.T) {
 			builder: NewSearchQueryBuilder(ColumnsEvent),
 			args: args{
 				event: &BaseEvent{
-					aggregate: Aggregate{
+					Agg: &Aggregate{
 						InstanceID: "instance",
 					},
-					sequence: 1001,
+					Seq: 1001,
 				},
 				existingLen: 999,
 			},