chore: move the go code into a subfolder

apps/api/internal/eventstore/repository/sql/local_postgres_test.go

@@ -0,0 +1,115 @@
+package sql
+
+import (
+	"context"
+	"database/sql"
+	"os"
+	"testing"
+	"time"
+
+	pgxdecimal "github.com/jackc/pgx-shopspring-decimal"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/jackc/pgx/v5/stdlib"
+	"github.com/zitadel/logging"
+
+	"github.com/zitadel/zitadel/cmd/initialise"
+	"github.com/zitadel/zitadel/internal/database"
+	"github.com/zitadel/zitadel/internal/database/dialect"
+	"github.com/zitadel/zitadel/internal/database/postgres"
+	new_es "github.com/zitadel/zitadel/internal/eventstore/v3"
+)
+
+var (
+	testClient *sql.DB
+)
+
+func TestMain(m *testing.M) {
+	os.Exit(func() int {
+		config, cleanup := postgres.StartEmbedded()
+		defer cleanup()
+
+		connConfig, err := pgxpool.ParseConfig(config.GetConnectionURL())
+		logging.OnError(err).Fatal("unable to parse db url")
+
+		connConfig.AfterConnect = func(ctx context.Context, conn *pgx.Conn) error {
+			pgxdecimal.Register(conn.TypeMap())
+			return new_es.RegisterEventstoreTypes(ctx, conn)
+		}
+
+		pool, err := pgxpool.NewWithConfig(context.Background(), connConfig)
+		logging.OnError(err).Fatal("unable to create db pool")
+
+		testClient = stdlib.OpenDBFromPool(pool)
+
+		err = testClient.Ping()
+		logging.OnError(err).Fatal("unable to ping db")
+
+		defer func() {
+			logging.OnError(testClient.Close()).Error("unable to close db")
+		}()
+
+		err = initDB(context.Background(), &database.DB{DB: testClient, Database: &postgres.Config{Database: "zitadel"}})
+		logging.OnError(err).Fatal("migrations failed")
+
+		return m.Run()
+	}())
+}
+
+func initDB(ctx context.Context, db *database.DB) error {
+	config := new(database.Config)
+	config.SetConnector(&postgres.Config{User: postgres.User{Username: "zitadel"}, Database: "zitadel"})
+
+	if err := initialise.ReadStmts(); err != nil {
+		return err
+	}
+
+	err := initialise.Init(ctx, db,
+		initialise.VerifyUser(config.Username(), ""),
+		initialise.VerifyDatabase(config.DatabaseName()),
+		initialise.VerifyGrant(config.DatabaseName(), config.Username()))
+	if err != nil {
+		return err
+	}
+
+	err = initialise.VerifyZitadel(context.Background(), db, *config)
+	if err != nil {
+		return err
+	}
+
+	// create old events
+	_, err = db.Exec(oldEventsTable)
+	return err
+}
+
+type testDB struct{}
+
+func (_ *testDB) Timetravel(time.Duration) string { return " AS OF SYSTEM TIME '-1 ms' " }
+
+func (*testDB) DatabaseName() string { return "db" }
+
+func (*testDB) Username() string { return "user" }
+
+func (*testDB) Type() dialect.DatabaseType { return dialect.DatabaseTypePostgres }
+
+const oldEventsTable = `CREATE TABLE IF NOT EXISTS eventstore.events (
+	id UUID DEFAULT gen_random_uuid()
+	, event_type TEXT NOT NULL
+	, aggregate_type TEXT NOT NULL
+	, aggregate_id TEXT NOT NULL
+	, aggregate_version TEXT NOT NULL
+	, event_sequence BIGINT NOT NULL
+	, previous_aggregate_sequence BIGINT
+	, previous_aggregate_type_sequence INT8
+	, creation_date TIMESTAMPTZ NOT NULL DEFAULT now()
+	, created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
+	, event_data JSONB
+	, editor_user TEXT NOT NULL 
+	, editor_service TEXT
+	, resource_owner TEXT NOT NULL
+	, instance_id TEXT NOT NULL
+	, "position" DECIMAL NOT NULL
+	, in_tx_order INTEGER NOT NULL
+
+	, PRIMARY KEY (instance_id, aggregate_type, aggregate_id, event_sequence)
+);`

apps/api/internal/eventstore/repository/sql/postgres.go

@@ -0,0 +1,242 @@
+package sql
+
+import (
+	"context"
+	"errors"
+	"regexp"
+	"strconv"
+
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/shopspring/decimal"
+
+	"github.com/zitadel/zitadel/internal/database"
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/eventstore/repository"
+	"github.com/zitadel/zitadel/internal/telemetry/tracing"
+)
+
+// awaitOpenTransactions ensures event ordering, so we don't events younger that open transactions
+var (
+	awaitOpenTransactionsV1 = ` AND EXTRACT(EPOCH FROM created_at) < (SELECT COALESCE(EXTRACT(EPOCH FROM min(xact_start)), EXTRACT(EPOCH FROM now())) FROM pg_stat_activity WHERE datname = current_database() AND application_name = ANY(?) AND state <> 'idle')`
+	awaitOpenTransactionsV2 = ` AND "position" < (SELECT COALESCE(EXTRACT(EPOCH FROM min(xact_start)), EXTRACT(EPOCH FROM now())) FROM pg_stat_activity WHERE datname = current_database() AND application_name = ANY(?) AND state <> 'idle')`
+)
+
+func awaitOpenTransactions(useV1 bool) string {
+	if useV1 {
+		return awaitOpenTransactionsV1
+	}
+	return awaitOpenTransactionsV2
+}
+
+type Postgres struct {
+	*database.DB
+}
+
+func NewPostgres(client *database.DB) *Postgres {
+	return &Postgres{client}
+}
+
+func (db *Postgres) Health(ctx context.Context) error { return db.Ping() }
+
+// FilterToReducer finds all events matching the given search query and passes them to the reduce function.
+func (psql *Postgres) FilterToReducer(ctx context.Context, searchQuery *eventstore.SearchQueryBuilder, reduce eventstore.Reducer) (err error) {
+	ctx, span := tracing.NewSpan(ctx)
+	defer func() { span.EndWithError(err) }()
+
+	err = query(ctx, psql, searchQuery, reduce, false)
+	if err == nil {
+		return nil
+	}
+	pgErr := new(pgconn.PgError)
+	// check events2 not exists
+	if errors.As(err, &pgErr) && pgErr.Code == "42P01" {
+		return query(ctx, psql, searchQuery, reduce, true)
+	}
+	return err
+}
+
+// LatestPosition returns the latest position found by the search query
+func (db *Postgres) LatestPosition(ctx context.Context, searchQuery *eventstore.SearchQueryBuilder) (decimal.Decimal, error) {
+	var position decimal.Decimal
+	err := query(ctx, db, searchQuery, &position, false)
+	return position, err
+}
+
+// InstanceIDs returns the instance ids found by the search query
+func (db *Postgres) InstanceIDs(ctx context.Context, searchQuery *eventstore.SearchQueryBuilder) ([]string, error) {
+	var ids []string
+	err := query(ctx, db, searchQuery, &ids, false)
+	if err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+func (db *Postgres) Client() *database.DB {
+	return db.DB
+}
+
+func (db *Postgres) orderByEventSequence(desc, shouldOrderBySequence, useV1 bool) string {
+	if useV1 {
+		if desc {
+			return ` ORDER BY event_sequence DESC`
+		}
+		return ` ORDER BY event_sequence`
+	}
+	if shouldOrderBySequence {
+		if desc {
+			return ` ORDER BY "sequence" DESC`
+		}
+		return ` ORDER BY "sequence"`
+	}
+
+	if desc {
+		return ` ORDER BY "position" DESC, in_tx_order DESC`
+	}
+	return ` ORDER BY "position", in_tx_order`
+}
+
+func (db *Postgres) eventQuery(useV1 bool) string {
+	if useV1 {
+		return "SELECT" +
+			" creation_date" +
+			", event_type" +
+			", event_sequence" +
+			", event_data" +
+			", editor_user" +
+			", resource_owner" +
+			", instance_id" +
+			", aggregate_type" +
+			", aggregate_id" +
+			", aggregate_version" +
+			" FROM eventstore.events"
+	}
+	return "SELECT" +
+		" created_at" +
+		", event_type" +
+		`, "sequence"` +
+		`, "position"` +
+		", payload" +
+		", creator" +
+		`, "owner"` +
+		", instance_id" +
+		", aggregate_type" +
+		", aggregate_id" +
+		", revision" +
+		" FROM eventstore.events2"
+}
+
+func (db *Postgres) maxPositionQuery(useV1 bool) string {
+	if useV1 {
+		return `SELECT event_sequence FROM eventstore.events`
+	}
+	return `SELECT "position" FROM eventstore.events2`
+}
+
+func (db *Postgres) instanceIDsQuery(useV1 bool) string {
+	table := "eventstore.events2"
+	if useV1 {
+		table = "eventstore.events"
+	}
+	return "SELECT DISTINCT instance_id FROM " + table
+}
+
+func (db *Postgres) columnName(col repository.Field, useV1 bool) string {
+	switch col {
+	case repository.FieldAggregateID:
+		return "aggregate_id"
+	case repository.FieldAggregateType:
+		return "aggregate_type"
+	case repository.FieldSequence:
+		if useV1 {
+			return "event_sequence"
+		}
+		return `"sequence"`
+	case repository.FieldResourceOwner:
+		if useV1 {
+			return "resource_owner"
+		}
+		return `"owner"`
+	case repository.FieldInstanceID:
+		return "instance_id"
+	case repository.FieldEditorService:
+		if useV1 {
+			return "editor_service"
+		}
+		return ""
+	case repository.FieldEditorUser:
+		if useV1 {
+			return "editor_user"
+		}
+		return "creator"
+	case repository.FieldEventType:
+		return "event_type"
+	case repository.FieldEventData:
+		if useV1 {
+			return "event_data"
+		}
+		return "payload"
+	case repository.FieldCreationDate:
+		if useV1 {
+			return "creation_date"
+		}
+		return "created_at"
+	case repository.FieldPosition:
+		return `"position"`
+	default:
+		return ""
+	}
+}
+
+func (db *Postgres) conditionFormat(operation repository.Operation) string {
+	switch operation {
+	case repository.OperationIn:
+		return "%s %s ANY(?)"
+	case repository.OperationNotIn:
+		return "%s %s ALL(?)"
+	case repository.OperationEquals, repository.OperationGreater, repository.OperationLess, repository.OperationJSONContains:
+		fallthrough
+	default:
+		return "%s %s ?"
+	}
+}
+
+func (db *Postgres) operation(operation repository.Operation) string {
+	switch operation {
+	case repository.OperationEquals, repository.OperationIn:
+		return "="
+	case repository.OperationGreater:
+		return ">"
+	case repository.OperationGreaterOrEquals:
+		return ">="
+	case repository.OperationLess:
+		return "<"
+	case repository.OperationJSONContains:
+		return "@>"
+	case repository.OperationNotIn:
+		return "<>"
+	}
+	return ""
+}
+
+var (
+	placeholder = regexp.MustCompile(`\?`)
+)
+
+// placeholder replaces all "?" with postgres placeholders ($<NUMBER>)
+func (db *Postgres) placeholder(query string) string {
+	occurrences := placeholder.FindAllStringIndex(query, -1)
+	if len(occurrences) == 0 {
+		return query
+	}
+	replaced := query[:occurrences[0][0]]
+
+	for i, l := range occurrences {
+		nextIDX := len(query)
+		if i < len(occurrences)-1 {
+			nextIDX = occurrences[i+1][0]
+		}
+		replaced = replaced + "$" + strconv.Itoa(i+1) + query[l[1]:nextIDX]
+	}
+	return replaced
+}

apps/api/internal/eventstore/repository/sql/postgres_test.go

@@ -0,0 +1,325 @@
+package sql
+
+import (
+	"database/sql"
+	"testing"
+
+	"github.com/shopspring/decimal"
+
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/eventstore/repository"
+)
+
+func TestPostgres_placeholder(t *testing.T) {
+	type args struct {
+		query string
+	}
+	type res struct {
+		query string
+	}
+	tests := []struct {
+		name string
+		args args
+		res  res
+	}{
+		{
+			name: "no placeholders",
+			args: args{
+				query: "SELECT * FROM eventstore.events2",
+			},
+			res: res{
+				query: "SELECT * FROM eventstore.events2",
+			},
+		},
+		{
+			name: "one placeholder",
+			args: args{
+				query: "SELECT * FROM eventstore.events2 WHERE aggregate_type = ?",
+			},
+			res: res{
+				query: "SELECT * FROM eventstore.events2 WHERE aggregate_type = $1",
+			},
+		},
+		{
+			name: "multiple placeholders",
+			args: args{
+				query: "SELECT * FROM eventstore.events2 WHERE aggregate_type = ? AND aggregate_id = ? LIMIT ?",
+			},
+			res: res{
+				query: "SELECT * FROM eventstore.events2 WHERE aggregate_type = $1 AND aggregate_id = $2 LIMIT $3",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db := &Postgres{}
+			if query := db.placeholder(tt.args.query); query != tt.res.query {
+				t.Errorf("Postgres.placeholder() = %v, want %v", query, tt.res.query)
+			}
+		})
+	}
+}
+
+func TestPostgres_operation(t *testing.T) {
+	type res struct {
+		op string
+	}
+	type args struct {
+		operation repository.Operation
+	}
+	tests := []struct {
+		name string
+		args args
+		res  res
+	}{
+		{
+			name: "no op",
+			args: args{
+				operation: repository.Operation(-1),
+			},
+			res: res{
+				op: "",
+			},
+		},
+		{
+			name: "greater",
+			args: args{
+				operation: repository.OperationGreater,
+			},
+			res: res{
+				op: ">",
+			},
+		},
+		{
+			name: "less",
+			args: args{
+				operation: repository.OperationLess,
+			},
+			res: res{
+				op: "<",
+			},
+		},
+		{
+			name: "equals",
+			args: args{
+				operation: repository.OperationEquals,
+			},
+			res: res{
+				op: "=",
+			},
+		},
+		{
+			name: "in",
+			args: args{
+				operation: repository.OperationIn,
+			},
+			res: res{
+				op: "=",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db := &Postgres{}
+			if got := db.operation(tt.args.operation); got != tt.res.op {
+				t.Errorf("Postgres.operation() = %v, want %v", got, tt.res.op)
+			}
+		})
+	}
+}
+
+func TestPostgres_conditionFormat(t *testing.T) {
+	type res struct {
+		format string
+	}
+	type args struct {
+		operation repository.Operation
+	}
+	tests := []struct {
+		name string
+		args args
+		res  res
+	}{
+		{
+			name: "default",
+			args: args{
+				operation: repository.OperationEquals,
+			},
+			res: res{
+				format: "%s %s ?",
+			},
+		},
+		{
+			name: "in",
+			args: args{
+				operation: repository.OperationIn,
+			},
+			res: res{
+				format: "%s %s ANY(?)",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db := &Postgres{}
+			if got := db.conditionFormat(tt.args.operation); got != tt.res.format {
+				t.Errorf("Postgres.conditionFormat() = %v, want %v", got, tt.res.format)
+			}
+		})
+	}
+}
+
+func TestPostgres_columnName(t *testing.T) {
+	type res struct {
+		name string
+	}
+	type args struct {
+		field repository.Field
+		useV1 bool
+	}
+	tests := []struct {
+		name string
+		args args
+		res  res
+	}{
+		{
+			name: "invalid field",
+			args: args{
+				field: repository.Field(-1),
+			},
+			res: res{
+				name: "",
+			},
+		},
+		{
+			name: "aggregate id",
+			args: args{
+				field: repository.FieldAggregateID,
+			},
+			res: res{
+				name: "aggregate_id",
+			},
+		},
+		{
+			name: "aggregate type",
+			args: args{
+				field: repository.FieldAggregateType,
+			},
+			res: res{
+				name: "aggregate_type",
+			},
+		},
+		{
+			name: "editor service",
+			args: args{
+				field: repository.FieldEditorService,
+				useV1: true,
+			},
+			res: res{
+				name: "editor_service",
+			},
+		},
+		{
+			name: "editor service v2",
+			args: args{
+				field: repository.FieldEditorService,
+			},
+			res: res{
+				name: "",
+			},
+		},
+		{
+			name: "editor user",
+			args: args{
+				field: repository.FieldEditorUser,
+				useV1: true,
+			},
+			res: res{
+				name: "editor_user",
+			},
+		},
+		{
+			name: "editor user v2",
+			args: args{
+				field: repository.FieldEditorUser,
+			},
+			res: res{
+				name: "creator",
+			},
+		},
+		{
+			name: "event type",
+			args: args{
+				field: repository.FieldEventType,
+			},
+			res: res{
+				name: "event_type",
+			},
+		},
+		{
+			name: "latest sequence",
+			args: args{
+				field: repository.FieldSequence,
+				useV1: true,
+			},
+			res: res{
+				name: "event_sequence",
+			},
+		},
+		{
+			name: "latest sequence v2",
+			args: args{
+				field: repository.FieldSequence,
+			},
+			res: res{
+				name: `"sequence"`,
+			},
+		},
+		{
+			name: "resource owner",
+			args: args{
+				field: repository.FieldResourceOwner,
+				useV1: true,
+			},
+			res: res{
+				name: "resource_owner",
+			},
+		},
+		{
+			name: "resource owner v2",
+			args: args{
+				field: repository.FieldResourceOwner,
+			},
+			res: res{
+				name: `"owner"`,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db := &Postgres{}
+			if got := db.columnName(tt.args.field, tt.args.useV1); got != tt.res.name {
+				t.Errorf("Postgres.operation() = %v, want %v", got, tt.res.name)
+			}
+		})
+	}
+}
+
+func generateEvent(t *testing.T, aggregateID string, opts ...func(*repository.Event)) *repository.Event {
+	t.Helper()
+	e := &repository.Event{
+		AggregateID:   aggregateID,
+		AggregateType: eventstore.AggregateType(t.Name()),
+		EditorUser:    "user",
+		ResourceOwner: sql.NullString{String: "ro", Valid: true},
+		Typ:           "test.created",
+		Version:       "v1",
+		Pos:           decimal.NewFromInt(42),
+	}
+
+	for _, opt := range opts {
+		opt(e)
+	}
+
+	return e
+}

apps/api/internal/eventstore/repository/sql/query.go

@@ -0,0 +1,355 @@
+package sql
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/shopspring/decimal"
+	"github.com/zitadel/logging"
+
+	"github.com/zitadel/zitadel/internal/database"
+	"github.com/zitadel/zitadel/internal/database/dialect"
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/eventstore/repository"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+type querier interface {
+	columnName(field repository.Field, useV1 bool) string
+	operation(repository.Operation) string
+	conditionFormat(repository.Operation) string
+	placeholder(query string) string
+	eventQuery(useV1 bool) string
+	maxPositionQuery(useV1 bool) string
+	instanceIDsQuery(useV1 bool) string
+	Client() *database.DB
+	orderByEventSequence(desc, shouldOrderBySequence, useV1 bool) string
+	dialect.Database
+}
+
+type scan func(dest ...interface{}) error
+
+type tx struct {
+	*sql.Tx
+}
+
+func (t *tx) QueryContext(ctx context.Context, scan func(rows *sql.Rows) error, query string, args ...any) error {
+	rows, err := t.Tx.QueryContext(ctx, query, args...)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		closeErr := rows.Close()
+		logging.OnError(closeErr).Info("rows.Close failed")
+	}()
+
+	if err = scan(rows); err != nil {
+		return err
+	}
+	return rows.Err()
+}
+
+func query(ctx context.Context, criteria querier, searchQuery *eventstore.SearchQueryBuilder, dest interface{}, useV1 bool) error {
+	q, err := repository.QueryFromBuilder(searchQuery)
+	if err != nil {
+		return err
+	}
+
+	query, rowScanner := prepareColumns(criteria, q.Columns, useV1)
+	where, values := prepareConditions(criteria, q, useV1)
+	if where == "" || query == "" {
+		return zerrors.ThrowInvalidArgument(nil, "SQL-rWeBw", "invalid query factory")
+	}
+	query += where
+
+	// instead of using the max function of the database (which doesn't work for postgres)
+	// we select the most recent row
+	if q.Columns == eventstore.ColumnsMaxPosition {
+		q.Limit = 1
+		q.Desc = true
+	}
+
+	// if there is only one subquery we can optimize the query ordering by ordering by sequence
+	var shouldOrderBySequence bool
+	if len(q.SubQueries) == 1 {
+		for _, filter := range q.SubQueries[0] {
+			if filter.Field == repository.FieldAggregateID {
+				shouldOrderBySequence = filter.Operation == repository.OperationEquals
+			}
+		}
+	}
+
+	switch q.Columns {
+	case eventstore.ColumnsEvent,
+		eventstore.ColumnsMaxPosition:
+		query += criteria.orderByEventSequence(q.Desc, shouldOrderBySequence, useV1)
+	}
+
+	if q.Limit > 0 {
+		values = append(values, q.Limit)
+		query += " LIMIT ?"
+	}
+
+	if q.Offset > 0 {
+		values = append(values, q.Offset)
+		query += " OFFSET ?"
+	}
+
+	if q.LockRows {
+		query += " FOR UPDATE"
+		switch q.LockOption {
+		case eventstore.LockOptionWait: // default behavior
+		case eventstore.LockOptionNoWait:
+			query += " NOWAIT"
+		case eventstore.LockOptionSkipLocked:
+			query += " SKIP LOCKED"
+
+		}
+	}
+
+	query = criteria.placeholder(query)
+
+	var contextQuerier interface {
+		QueryContext(context.Context, func(rows *sql.Rows) error, string, ...interface{}) error
+	}
+	contextQuerier = criteria.Client()
+	if q.Tx != nil {
+		contextQuerier = &tx{Tx: q.Tx}
+	}
+
+	err = contextQuerier.QueryContext(ctx,
+		func(rows *sql.Rows) error {
+			for rows.Next() {
+				err := rowScanner(rows.Scan, dest)
+				if err != nil {
+					return err
+				}
+			}
+			return nil
+		}, query, values...)
+	if err != nil {
+		logging.New().WithError(err).Info("query failed")
+		return zerrors.ThrowInternal(err, "SQL-KyeAx", "unable to filter events")
+	}
+
+	return nil
+}
+
+func prepareColumns(criteria querier, columns eventstore.Columns, useV1 bool) (string, func(s scan, dest interface{}) error) {
+	switch columns {
+	case eventstore.ColumnsMaxPosition:
+		return criteria.maxPositionQuery(useV1), maxPositionScanner
+	case eventstore.ColumnsInstanceIDs:
+		return criteria.instanceIDsQuery(useV1), instanceIDsScanner
+	case eventstore.ColumnsEvent:
+		return criteria.eventQuery(useV1), eventsScanner(useV1)
+	default:
+		return "", nil
+	}
+}
+
+func maxPositionScanner(row scan, dest interface{}) (err error) {
+	position, ok := dest.(*decimal.Decimal)
+	if !ok {
+		return zerrors.ThrowInvalidArgumentf(nil, "SQL-NBjA9", "type must be pointer to decimal.Decimal got: %T", dest)
+	}
+	var res decimal.NullDecimal
+	err = row(&res)
+	if err == nil || errors.Is(err, sql.ErrNoRows) {
+		*position = res.Decimal
+		return nil
+	}
+	return zerrors.ThrowInternal(err, "SQL-bN5xg", "something went wrong")
+}
+
+func instanceIDsScanner(scanner scan, dest interface{}) (err error) {
+	ids, ok := dest.(*[]string)
+	if !ok {
+		return zerrors.ThrowInvalidArgument(nil, "SQL-Begh2", "type must be an array of string")
+	}
+	var id string
+	err = scanner(&id)
+	if err != nil {
+		logging.WithError(err).Warn("unable to scan row")
+		return zerrors.ThrowInternal(err, "SQL-DEFGe", "unable to scan row")
+	}
+	*ids = append(*ids, id)
+
+	return nil
+}
+
+func eventsScanner(useV1 bool) func(scanner scan, dest interface{}) (err error) {
+	return func(scanner scan, dest interface{}) (err error) {
+		reduce, ok := dest.(eventstore.Reducer)
+		if !ok {
+			return zerrors.ThrowInvalidArgumentf(nil, "SQL-4GP6F", "events scanner: invalid type %T", dest)
+		}
+		event := new(repository.Event)
+		position := new(decimal.NullDecimal)
+
+		if useV1 {
+			err = scanner(
+				&event.CreationDate,
+				&event.Typ,
+				&event.Seq,
+				&event.Data,
+				&event.EditorUser,
+				&event.ResourceOwner,
+				&event.InstanceID,
+				&event.AggregateType,
+				&event.AggregateID,
+				&event.Version,
+			)
+		} else {
+			var revision uint8
+			err = scanner(
+				&event.CreationDate,
+				&event.Typ,
+				&event.Seq,
+				position,
+				&event.Data,
+				&event.EditorUser,
+				&event.ResourceOwner,
+				&event.InstanceID,
+				&event.AggregateType,
+				&event.AggregateID,
+				&revision,
+			)
+			event.Version = eventstore.Version("v" + strconv.Itoa(int(revision)))
+		}
+
+		if err != nil {
+			logging.New().WithError(err).Warn("unable to scan row")
+			return zerrors.ThrowInternal(err, "SQL-M0dsf", "unable to scan row")
+		}
+		event.Pos = position.Decimal
+		return reduce(event)
+	}
+}
+
+func prepareConditions(criteria querier, query *repository.SearchQuery, useV1 bool) (_ string, args []any) {
+	clauses, args := prepareQuery(criteria, useV1, query.InstanceID, query.InstanceIDs, query.ExcludedInstances)
+	if clauses != "" && len(query.SubQueries) > 0 {
+		clauses += " AND "
+	}
+	subClauses := make([]string, len(query.SubQueries))
+	for i, filters := range query.SubQueries {
+		var subArgs []any
+		subClauses[i], subArgs = prepareQuery(criteria, useV1, filters...)
+		// an error is thrown in [query]
+		if subClauses[i] == "" {
+			return "", nil
+		}
+		if len(query.SubQueries) > 1 && len(subArgs) > 1 {
+			subClauses[i] = "(" + subClauses[i] + ")"
+		}
+		args = append(args, subArgs...)
+	}
+	if len(subClauses) == 1 {
+		clauses += subClauses[0]
+	} else if len(subClauses) > 1 {
+		clauses += "(" + strings.Join(subClauses, " OR ") + ")"
+	}
+
+	additionalClauses, additionalArgs := prepareQuery(criteria, useV1,
+		query.Position,
+		query.Owner,
+		query.Sequence,
+		query.CreatedAfter,
+		query.CreatedBefore,
+		query.Creator,
+	)
+	if additionalClauses != "" {
+		if clauses != "" {
+			clauses += " AND "
+		}
+		clauses += additionalClauses
+		args = append(args, additionalArgs...)
+	}
+
+	excludeAggregateIDs := query.ExcludeAggregateIDs
+	if len(excludeAggregateIDs) > 0 {
+		excludeAggregateIDs = append(excludeAggregateIDs, query.InstanceID, query.InstanceIDs, query.Position, query.CreatedAfter, query.CreatedBefore)
+	}
+	excludeAggregateIDsClauses, excludeAggregateIDsArgs := prepareQuery(criteria, useV1, excludeAggregateIDs...)
+	if excludeAggregateIDsClauses != "" {
+		if clauses != "" {
+			clauses += " AND "
+		}
+		if useV1 {
+			clauses += "aggregate_id NOT IN (SELECT aggregate_id FROM eventstore.events WHERE " + excludeAggregateIDsClauses + ")"
+		} else {
+			clauses += "aggregate_id NOT IN (SELECT aggregate_id FROM eventstore.events2 WHERE " + excludeAggregateIDsClauses + ")"
+		}
+		args = append(args, excludeAggregateIDsArgs...)
+	}
+
+	if query.AwaitOpenTransactions {
+		instanceIDs := make(database.TextArray[string], 0, 3)
+		if query.InstanceID != nil {
+			instanceIDs = append(instanceIDs, query.InstanceID.Value.(string))
+		} else if query.InstanceIDs != nil {
+			instanceIDs = append(instanceIDs, query.InstanceIDs.Value.(database.TextArray[string])...)
+		}
+
+		for i := range instanceIDs {
+			instanceIDs[i] = "zitadel_es_pusher_" + instanceIDs[i]
+		}
+
+		clauses += awaitOpenTransactions(useV1)
+		args = append(args, instanceIDs)
+	}
+
+	if clauses == "" {
+		return "", nil
+	}
+
+	return " WHERE " + clauses, args
+}
+
+func prepareQuery(criteria querier, useV1 bool, filters ...*repository.Filter) (_ string, args []any) {
+	clauses := make([]string, 0, len(filters))
+	args = make([]any, 0, len(filters))
+	for _, filter := range filters {
+		if filter == nil {
+			continue
+		}
+		arg := filter.Value
+
+		// marshal if payload filter
+		if filter.Field == repository.FieldEventData {
+			var err error
+			arg, err = json.Marshal(arg)
+			if err != nil {
+				logging.WithError(err).Warn("unable to marshal search value")
+				continue
+			}
+
+		}
+
+		clauses = append(clauses, getCondition(criteria, filter, useV1))
+		// if mapping failed an error is thrown in [query]
+		if clauses[len(clauses)-1] == "" {
+			return "", nil
+		}
+		args = append(args, arg)
+	}
+
+	return strings.Join(clauses, " AND "), args
+}
+
+func getCondition(cond querier, filter *repository.Filter, useV1 bool) (condition string) {
+	field := cond.columnName(filter.Field, useV1)
+	operation := cond.operation(filter.Operation)
+	if field == "" || operation == "" {
+		return ""
+	}
+	format := cond.conditionFormat(filter.Operation)
+
+	return fmt.Sprintf(format, field, operation)
+}