TheArchive/zitadel
1
0
Fork 0
mirror of https://github.com/zitadel/zitadel.git synced 2025-08-12 01:47:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(storage): read only transactions (#6417)

Browse Source 
feat(storage): read only transactions for queries (#6415)

* fix: tests

* bastle wie en grosse

* fix(database): scan as callback

* fix tests

* fix merge failures

* remove as of system time

* refactor: remove unused test

* refacotr: remove unused lines
This commit is contained in:
Silvan
2023-08-22 14:49:02 +02:00
committed by GitHub
parent 7442492b8a
commit 22af4dcd97
128 changed files with 1355 additions and 897 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
internal/eventstore/v1/internal/repository/sql/db_mock_test.go
View File

@@ -127,9 +127,11 @@ func (db *dbMock) expectFilterEventsLimit(aggregateType string, limit uint64, ev
for i := 0; i < eventCount; i++ {
rows.AddRow(time.Now(), "eventType", Sequence(i+1), Sequence(i), nil, "svc", "hodor", "org", "instanceID", "aggType", "aggID", "v1.0.0")
}
db.mock.ExpectBegin()
db.mock.ExpectQuery(expectedFilterEventsLimitFormat).
WithArgs(aggregateType, limit).
WillReturnRows(rows)
db.mock.ExpectCommit()
return db
}
@@ -138,8 +140,10 @@ func (db *dbMock) expectFilterEventsDesc(aggregateType string, eventCount int) *
for i := eventCount; i > 0; i-- {
rows.AddRow(time.Now(), "eventType", Sequence(i+1), Sequence(i), nil, "svc", "hodor", "org", "instanceID", "aggType", "aggID", "v1.0.0")
}
db.mock.ExpectBegin()
db.mock.ExpectQuery(expectedFilterEventsDescFormat).
WillReturnRows(rows)
db.mock.ExpectCommit()
return db
}
@@ -148,9 +152,11 @@ func (db *dbMock) expectFilterEventsAggregateIDLimit(aggregateType, aggregateID
for i := limit; i > 0; i-- {
rows.AddRow(time.Now(), "eventType", Sequence(i+1), Sequence(i), nil, "svc", "hodor", "org", "instanceID", "aggType", "aggID", "v1.0.0")
}
db.mock.ExpectBegin()
db.mock.ExpectQuery(expectedFilterEventsAggregateIDLimit).
WithArgs(aggregateType, aggregateID, limit).
WillReturnRows(rows)
db.mock.ExpectCommit()
return db
}
@@ -159,28 +165,36 @@ func (db *dbMock) expectFilterEventsAggregateIDTypeLimit(aggregateType, aggregat
for i := limit; i > 0; i-- {
rows.AddRow(time.Now(), "eventType", Sequence(i+1), Sequence(i), nil, "svc", "hodor", "org", "instanceID", "aggType", "aggID", "v1.0.0")
}
db.mock.ExpectBegin()
db.mock.ExpectQuery(expectedFilterEventsAggregateIDTypeLimit).
WithArgs(aggregateType, aggregateID, limit).
WillReturnRows(rows)
db.mock.ExpectCommit()
return db
}
func (db *dbMock) expectFilterEventsError(returnedErr error) *dbMock {
db.mock.ExpectBegin()
db.mock.ExpectQuery(expectedGetAllEvents).
WillReturnError(returnedErr)
db.mock.ExpectRollback()
return db
}
func (db *dbMock) expectLatestSequenceFilter(aggregateType string, sequence Sequence) *dbMock {
db.mock.ExpectBegin()
db.mock.ExpectQuery(`SELECT MAX\(event_sequence\) FROM eventstore\.events AS OF SYSTEM TIME '-1 ms' WHERE \( aggregate_type = \$1 \)`).
WithArgs(aggregateType).
WillReturnRows(sqlmock.NewRows([]string{"max_sequence"}).AddRow(sequence))
db.mock.ExpectCommit()
return db
}
func (db *dbMock) expectLatestSequenceFilterError(aggregateType string, err error) *dbMock {
db.mock.ExpectBegin()
db.mock.ExpectQuery(`SELECT MAX\(event_sequence\) FROM eventstore\.events AS OF SYSTEM TIME '-1 ms' WHERE \( aggregate_type = \$1 \)`).
WithArgs(aggregateType).WillReturnError(err)
// db.mock.ExpectRollback()
return db
}

87
internal/eventstore/v1/internal/repository/sql/filter.go
View File

@@ -3,12 +3,13 @@ package sql
import (
"context"
"database/sql"
"errors"
"runtime/debug"
"github.com/zitadel/logging"
"github.com/zitadel/zitadel/internal/database"
"github.com/zitadel/zitadel/internal/errors"
errs "github.com/zitadel/zitadel/internal/errors"
es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/telemetry/tracing"
)
@@ -24,72 +25,74 @@ func (db *SQL) Filter(ctx context.Context, searchQuery *es_models.SearchQueryFac
return db.filter(ctx, db.client, searchQuery)
}
func (sql *SQL) filter(ctx context.Context, db *database.DB, searchQuery *es_models.SearchQueryFactory) (events []*es_models.Event, err error) {
query, limit, values, rowScanner := sql.buildQuery(ctx, db, searchQuery)
func (server *SQL) filter(ctx context.Context, db *database.DB, searchQuery *es_models.SearchQueryFactory) (events []*es_models.Event, err error) {
query, limit, values, rowScanner := server.buildQuery(ctx, db, searchQuery)
if query == "" {
return nil, errors.ThrowInvalidArgument(nil, "SQL-rWeBw", "invalid query factory")
return nil, errs.ThrowInvalidArgument(nil, "SQL-rWeBw", "invalid query factory")
}
rows, err := db.Query(query, values...)
if err != nil {
logging.New().WithError(err).Info("query failed")
return nil, errors.ThrowInternal(err, "SQL-IJuyR", "unable to filter events")
}
defer rows.Close()
events = make([]*es_models.Event, 0, limit)
err = db.QueryContext(ctx,
func(rows *sql.Rows) error {
for rows.Next() {
event := new(es_models.Event)
err := rowScanner(rows.Scan, event)
if err != nil {
return err
}
for rows.Next() {
event := new(es_models.Event)
err := rowScanner(rows.Scan, event)
if err != nil {
return nil, err
}
events = append(events, event)
events = append(events, event)
}
return nil
},
query, values...,
)
if err != nil {
logging.New().WithError(err).Info("query failed")
return nil, errs.ThrowInternal(err, "SQL-IJuyR", "unable to filter events")
}
return events, nil
}
func (db *SQL) LatestSequence(ctx context.Context, queryFactory *es_models.SearchQueryFactory) (uint64, error) {
query, _, values, rowScanner := db.buildQuery(ctx, db.client, queryFactory)
if query == "" {
return 0, errors.ThrowInvalidArgument(nil, "SQL-rWeBw", "invalid query factory")
return 0, errs.ThrowInvalidArgument(nil, "SQL-rWeBw", "invalid query factory")
}
row := db.client.QueryRow(query, values...)
sequence := new(Sequence)
err := rowScanner(row.Scan, sequence)
if err != nil {
err := db.client.QueryRowContext(ctx, func(row *sql.Row) error {
return rowScanner(row.Scan, sequence)
}, query, values...)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
logging.New().WithError(err).WithField("traceID", tracing.TraceIDFromCtx(ctx)).Info("query failed")
return 0, errors.ThrowInternal(err, "SQL-Yczyx", "unable to filter latest sequence")
return 0, errs.ThrowInternal(err, "SQL-Yczyx", "unable to filter latest sequence")
}
return uint64(*sequence), nil
}
func (db *SQL) InstanceIDs(ctx context.Context, queryFactory *es_models.SearchQueryFactory) ([]string, error) {
func (db *SQL) InstanceIDs(ctx context.Context, queryFactory *es_models.SearchQueryFactory) (ids []string, err error) {
query, _, values, rowScanner := db.buildQuery(ctx, db.client, queryFactory)
if query == "" {
return nil, errors.ThrowInvalidArgument(nil, "SQL-Sfwg2", "invalid query factory")
return nil, errs.ThrowInvalidArgument(nil, "SQL-Sfwg2", "invalid query factory")
}
rows, err := db.client.Query(query, values...)
err = db.client.QueryContext(ctx,
func(rows *sql.Rows) error {
for rows.Next() {
var id string
err := rowScanner(rows.Scan, &id)
if err != nil {
return err
}
ids = append(ids, id)
}
return nil
},
query, values...)
if err != nil {
logging.New().WithError(err).Info("query failed")
return nil, errors.ThrowInternal(err, "SQL-Sfg3r", "unable to filter instance ids")
}
defer rows.Close()
ids := make([]string, 0)
for rows.Next() {
var id string
err := rowScanner(rows.Scan, &id)
if err != nil {
return nil, err
}
ids = append(ids, id)
return nil, errs.ThrowInternal(err, "SQL-Sfg3r", "unable to filter instance ids")
}
return ids, nil

3
internal/eventstore/v1/internal/repository/sql/filter_test.go
View File

@@ -130,6 +130,7 @@ func TestSQL_Filter(t *testing.T) {
if (err != nil) != tt.res.wantErr {
t.Errorf("SQL.Filter() error = %v, wantErr %v", err, tt.res.wantErr)
}
if tt.res.eventsLen != 0 && len(events) != tt.res.eventsLen {
t.Errorf("events has wrong length got: %d want %d", len(events), tt.res.eventsLen)
}
@@ -221,10 +222,12 @@ func TestSQL_LatestSequence(t *testing.T) {
sql := &SQL{
client: &database.DB{DB: tt.fields.client.sqlClient, Database: new(testDB)},
}
sequence, err := sql.LatestSequence(context.Background(), tt.args.searchQuery)
if (err != nil) != tt.res.wantErr {
t.Errorf("SQL.Filter() error = %v, wantErr %v", err, tt.res.wantErr)
}
if tt.res.sequence != sequence {
t.Errorf("events has wrong length got: %d want %d", sequence, tt.res.sequence)
}