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

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

internal/query/action.go

@@ -130,19 +130,19 @@ func (q *Queries) SearchActions(ctx context.Context, queries *ActionSearchQuerie
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-SDgwg", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		actions, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-SDfr52", "Errors.Internal")
 	}
-	actions, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	actions.LatestSequence, err = q.latestSequence(ctx, actionTable)
 	return actions, err
 }
 
-func (q *Queries) GetActionByID(ctx context.Context, id string, orgID string, withOwnerRemoved bool) (_ *Action, err error) {
+func (q *Queries) GetActionByID(ctx context.Context, id string, orgID string, withOwnerRemoved bool) (action *Action, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -160,8 +160,11 @@ func (q *Queries) GetActionByID(ctx context.Context, id string, orgID string, wi
 		return nil, errors.ThrowInternal(err, "QUERY-Dgff3", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		action, err = scan(row)
+		return err
+	}, query, args...)
+	return action, err
 }
 
 func NewActionResourceOwnerQuery(id string) (SearchQuery, error) {

internal/query/action_flow.go

@@ -67,7 +67,7 @@ type Flow struct {
 	TriggerActions map[domain.TriggerType][]*Action
 }
 
-func (q *Queries) GetFlow(ctx context.Context, flowType domain.FlowType, orgID string, withOwnerRemoved bool) (_ *Flow, err error) {
+func (q *Queries) GetFlow(ctx context.Context, flowType domain.FlowType, orgID string, withOwnerRemoved bool) (flow *Flow, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -85,14 +85,14 @@ func (q *Queries) GetFlow(ctx context.Context, flowType domain.FlowType, orgID s
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-HBRh3", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "QUERY-Gg42f", "Errors.Internal")
-	}
-	return scan(rows)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		flow, err = scan(rows)
+		return err
+	}, stmt, args...)
+	return flow, err
 }
 
-func (q *Queries) GetActiveActionsByFlowAndTriggerType(ctx context.Context, flowType domain.FlowType, triggerType domain.TriggerType, orgID string, withOwnerRemoved bool) (_ []*Action, err error) {
+func (q *Queries) GetActiveActionsByFlowAndTriggerType(ctx context.Context, flowType domain.FlowType, triggerType domain.TriggerType, orgID string, withOwnerRemoved bool) (actions []*Action, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -112,14 +112,14 @@ func (q *Queries) GetActiveActionsByFlowAndTriggerType(ctx context.Context, flow
 		return nil, errors.ThrowInternal(err, "QUERY-Dgff3", "Errors.Query.SQLStatement")
 	}
 
-	rows, err := q.client.QueryContext(ctx, query, args...)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "QUERY-SDf52", "Errors.Internal")
-	}
-	return scan(rows)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		actions, err = scan(rows)
+		return err
+	}, query, args...)
+	return actions, err
 }
 
-func (q *Queries) GetFlowTypesOfActionID(ctx context.Context, actionID string, withOwnerRemoved bool) (_ []domain.FlowType, err error) {
+func (q *Queries) GetFlowTypesOfActionID(ctx context.Context, actionID string, withOwnerRemoved bool) (types []domain.FlowType, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -136,12 +136,11 @@ func (q *Queries) GetFlowTypesOfActionID(ctx context.Context, actionID string, w
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-Dh311", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, query, args...)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "QUERY-Bhj4w", "Errors.Internal")
-	}
-
-	return scan(rows)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		types, err = scan(rows)
+		return err
+	}, query, args...)
+	return types, err
 }
 
 func prepareFlowTypesQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Rows) ([]domain.FlowType, error)) {

internal/query/action_flow_test.go

@@ -33,8 +33,8 @@ var (
 		` projections.flow_triggers2.sequence,` +
 		` projections.flow_triggers2.resource_owner` +
 		` FROM projections.flow_triggers2` +
-		` LEFT JOIN projections.actions3 ON projections.flow_triggers2.action_id = projections.actions3.id AND projections.flow_triggers2.instance_id = projections.actions3.instance_id` +
-		` AS OF SYSTEM TIME '-1 ms'`
+		` LEFT JOIN projections.actions3 ON projections.flow_triggers2.action_id = projections.actions3.id AND projections.flow_triggers2.instance_id = projections.actions3.instance_id`
+		// ` AS OF SYSTEM TIME '-1 ms'`
 	prepareFlowCols = []string{
 		"id",
 		"creation_date",
@@ -66,8 +66,8 @@ var (
 		` projections.actions3.allowed_to_fail,` +
 		` projections.actions3.timeout` +
 		` FROM projections.flow_triggers2` +
-		` LEFT JOIN projections.actions3 ON projections.flow_triggers2.action_id = projections.actions3.id AND projections.flow_triggers2.instance_id = projections.actions3.instance_id` +
-		` AS OF SYSTEM TIME '-1 ms'`
+		` LEFT JOIN projections.actions3 ON projections.flow_triggers2.action_id = projections.actions3.id AND projections.flow_triggers2.instance_id = projections.actions3.instance_id`
+		// ` AS OF SYSTEM TIME '-1 ms'`
 
 	prepareTriggerActionCols = []string{
 		"id",
@@ -83,8 +83,8 @@ var (
 	}
 
 	prepareFlowTypeStmt = `SELECT projections.flow_triggers2.flow_type` +
-		` FROM projections.flow_triggers2` +
-		` AS OF SYSTEM TIME '-1 ms'`
+		` FROM projections.flow_triggers2`
+		// ` AS OF SYSTEM TIME '-1 ms'`
 
 	prepareFlowTypeCols = []string{
 		"flow_type",

internal/query/action_test.go

@@ -25,8 +25,8 @@ var (
 		` projections.actions3.timeout,` +
 		` projections.actions3.allowed_to_fail,` +
 		` COUNT(*) OVER ()` +
-		` FROM projections.actions3` +
-		` AS OF SYSTEM TIME '-1 ms'`
+		` FROM projections.actions3`
+		// ` AS OF SYSTEM TIME '-1 ms'`
 	prepareActionsCols = []string{
 		"id",
 		"creation_date",
@@ -51,8 +51,8 @@ var (
 		` projections.actions3.script,` +
 		` projections.actions3.timeout,` +
 		` projections.actions3.allowed_to_fail` +
-		` FROM projections.actions3` +
-		` AS OF SYSTEM TIME '-1 ms'`
+		` FROM projections.actions3`
+		// ` AS OF SYSTEM TIME '-1 ms'`
 	prepareActionCols = []string{
 		"id",
 		"creation_date",
@@ -215,13 +215,13 @@ func Test_ActionPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Action)(nil),
 		},
 		{
 			name:    "prepareActionQuery no result",
 			prepare: prepareActionQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(prepareActionStmt),
 					nil,
 					nil,
@@ -284,7 +284,7 @@ func Test_ActionPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Action)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/app.go

@@ -248,7 +248,7 @@ var (
 	}
 )
 
-func (q *Queries) AppByProjectAndAppID(ctx context.Context, shouldTriggerBulk bool, projectID, appID string, withOwnerRemoved bool) (_ *App, err error) {
+func (q *Queries) AppByProjectAndAppID(ctx context.Context, shouldTriggerBulk bool, projectID, appID string, withOwnerRemoved bool) (app *App, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -270,11 +270,14 @@ func (q *Queries) AppByProjectAndAppID(ctx context.Context, shouldTriggerBulk bo
 		return nil, errors.ThrowInternal(err, "QUERY-AFDgg", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		app, err = scan(row)
+		return err
+	}, query, args...)
+	return app, err
 }
 
-func (q *Queries) AppByID(ctx context.Context, appID string, withOwnerRemoved bool) (_ *App, err error) {
+func (q *Queries) AppByID(ctx context.Context, appID string, withOwnerRemoved bool) (app *App, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -291,11 +294,14 @@ func (q *Queries) AppByID(ctx context.Context, appID string, withOwnerRemoved bo
 		return nil, errors.ThrowInternal(err, "QUERY-immt9", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		app, err = scan(row)
+		return err
+	}, query, args...)
+	return app, err
 }
 
-func (q *Queries) AppBySAMLEntityID(ctx context.Context, entityID string, withOwnerRemoved bool) (_ *App, err error) {
+func (q *Queries) AppBySAMLEntityID(ctx context.Context, entityID string, withOwnerRemoved bool) (app *App, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -312,11 +318,14 @@ func (q *Queries) AppBySAMLEntityID(ctx context.Context, entityID string, withOw
 		return nil, errors.ThrowInternal(err, "QUERY-JgUop", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		app, err = scan(row)
+		return err
+	}, query, args...)
+	return app, err
 }
 
-func (q *Queries) ProjectByClientID(ctx context.Context, appID string, withOwnerRemoved bool) (_ *Project, err error) {
+func (q *Queries) ProjectByClientID(ctx context.Context, appID string, withOwnerRemoved bool) (project *Project, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -337,11 +346,14 @@ func (q *Queries) ProjectByClientID(ctx context.Context, appID string, withOwner
 		return nil, errors.ThrowInternal(err, "QUERY-XhJi3", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		project, err = scan(row)
+		return err
+	}, query, args...)
+	return project, err
 }
 
-func (q *Queries) ProjectIDFromOIDCClientID(ctx context.Context, appID string, withOwnerRemoved bool) (_ string, err error) {
+func (q *Queries) ProjectIDFromOIDCClientID(ctx context.Context, appID string, withOwnerRemoved bool) (id string, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -358,11 +370,14 @@ func (q *Queries) ProjectIDFromOIDCClientID(ctx context.Context, appID string, w
 		return "", errors.ThrowInternal(err, "QUERY-7d92U", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		id, err = scan(row)
+		return err
+	}, query, args...)
+	return id, err
 }
 
-func (q *Queries) ProjectIDFromClientID(ctx context.Context, appID string, withOwnerRemoved bool) (_ string, err error) {
+func (q *Queries) ProjectIDFromClientID(ctx context.Context, appID string, withOwnerRemoved bool) (id string, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -384,11 +399,14 @@ func (q *Queries) ProjectIDFromClientID(ctx context.Context, appID string, withO
 		return "", errors.ThrowInternal(err, "QUERY-SDfg3", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		id, err = scan(row)
+		return err
+	}, query, args...)
+	return id, err
 }
 
-func (q *Queries) ProjectByOIDCClientID(ctx context.Context, id string, withOwnerRemoved bool) (_ *Project, err error) {
+func (q *Queries) ProjectByOIDCClientID(ctx context.Context, id string, withOwnerRemoved bool) (project *Project, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -405,11 +423,14 @@ func (q *Queries) ProjectByOIDCClientID(ctx context.Context, id string, withOwne
 		return nil, errors.ThrowInternal(err, "QUERY-XhJi4", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		project, err = scan(row)
+		return err
+	}, query, args...)
+	return project, err
 }
 
-func (q *Queries) AppByOIDCClientID(ctx context.Context, clientID string, withOwnerRemoved bool) (_ *App, err error) {
+func (q *Queries) AppByOIDCClientID(ctx context.Context, clientID string, withOwnerRemoved bool) (app *App, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -426,11 +447,14 @@ func (q *Queries) AppByOIDCClientID(ctx context.Context, clientID string, withOw
 		return nil, errors.ThrowInternal(err, "QUERY-JgVop", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		app, err = scan(row)
+		return err
+	}, query, args...)
+	return app, err
 }
 
-func (q *Queries) AppByClientID(ctx context.Context, clientID string, withOwnerRemoved bool) (_ *App, err error) {
+func (q *Queries) AppByClientID(ctx context.Context, clientID string, withOwnerRemoved bool) (app *App, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -450,11 +474,14 @@ func (q *Queries) AppByClientID(ctx context.Context, clientID string, withOwnerR
 		return nil, errors.ThrowInternal(err, "QUERY-Dfge2", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		app, err = scan(row)
+		return err
+	}, query, args...)
+	return app, err
 }
 
-func (q *Queries) SearchApps(ctx context.Context, queries *AppSearchQueries, withOwnerRemoved bool) (_ *Apps, err error) {
+func (q *Queries) SearchApps(ctx context.Context, queries *AppSearchQueries, withOwnerRemoved bool) (apps *Apps, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -468,19 +495,18 @@ func (q *Queries) SearchApps(ctx context.Context, queries *AppSearchQueries, wit
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-fajp8", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		apps, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-aJnZL", "Errors.Internal")
 	}
-	apps, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
 	apps.LatestSequence, err = q.latestSequence(ctx, appsTable)
 	return apps, err
 }
 
-func (q *Queries) SearchClientIDs(ctx context.Context, queries *AppSearchQueries, withOwnerRemoved bool) (_ []string, err error) {
+func (q *Queries) SearchClientIDs(ctx context.Context, queries *AppSearchQueries, withOwnerRemoved bool) (ids []string, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -494,11 +520,14 @@ func (q *Queries) SearchClientIDs(ctx context.Context, queries *AppSearchQueries
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-fajp8", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		ids, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-aJnZL", "Errors.Internal")
 	}
-	return scan(rows)
+	return ids, nil
 }
 
 func NewAppNameSearchQuery(method TextComparison, value string) (SearchQuery, error) {

internal/query/app_test.go

@@ -1115,7 +1115,7 @@ func Test_AppsPrepare(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*App)(nil),
 		},
 	}
 	for _, tt := range tests {
@@ -1140,7 +1140,7 @@ func Test_AppPrepare(t *testing.T) {
 			name:    "prepareAppQuery no result",
 			prepare: prepareAppQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					expectedAppQuery,
 					nil,
 					nil,
@@ -1747,7 +1747,7 @@ func Test_AppPrepare(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*App)(nil),
 		},
 	}
 	for _, tt := range tests {
@@ -1833,7 +1833,7 @@ func Test_AppIDsPrepare(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*App)(nil),
 		},
 	}
 	for _, tt := range tests {
@@ -1858,7 +1858,7 @@ func Test_ProjectIDByAppPrepare(t *testing.T) {
 			name:    "prepareProjectIDByAppQuery no result",
 			prepare: prepareProjectIDByAppQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					expectedProjectIDByAppQuery,
 					nil,
 					nil,
@@ -1899,7 +1899,7 @@ func Test_ProjectIDByAppPrepare(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: "",
 		},
 	}
 	for _, tt := range tests {
@@ -1924,7 +1924,7 @@ func Test_ProjectByAppPrepare(t *testing.T) {
 			name:    "prepareProjectByAppQuery no result",
 			prepare: prepareProjectByAppQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					expectedProjectByAppQuery,
 					nil,
 					nil,
@@ -2097,7 +2097,7 @@ func Test_ProjectByAppPrepare(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Project)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/auth_request.go

@@ -60,12 +60,16 @@ func (q *Queries) AuthRequestByID(ctx context.Context, shouldTriggerBulk bool, i
 	)
 
 	dst := new(AuthRequest)
-	err = q.client.DB.QueryRowContext(
-		ctx, q.authRequestByIDQuery(ctx),
+	err = q.client.QueryRowContext(
+		ctx,
+		func(row *sql.Row) error {
+			return row.Scan(
+				&dst.ID, &dst.CreationDate, &dst.LoginClient, &dst.ClientID, &scope, &dst.RedirectURI,
+				&prompt, &locales, &dst.LoginHint, &dst.MaxAge, &dst.HintUserID,
+			)
+		},
+		q.authRequestByIDQuery(ctx),
 		id, authz.GetInstance(ctx).InstanceID(),
-	).Scan(
-		&dst.ID, &dst.CreationDate, &dst.LoginClient, &dst.ClientID, &scope, &dst.RedirectURI,
-		&prompt, &locales, &dst.LoginHint, &dst.MaxAge, &dst.HintUserID,
 	)
 	if errs.Is(err, sql.ErrNoRows) {
 		return nil, errors.ThrowNotFound(err, "QUERY-Thee9", "Errors.AuthRequest.NotExisting")

internal/query/auth_request_test.go

@@ -125,7 +125,7 @@ func TestQueries_AuthRequestByID(t *testing.T) {
 				shouldTriggerBulk: false,
 				id:                "123",
 			},
-			expect:  mockQuery(expQuery, cols, nil, "123", "instanceID"),
+			expect:  mockQueryScanErr(expQuery, cols, nil, "123", "instanceID"),
 			wantErr: errors.ThrowNotFound(sql.ErrNoRows, "QUERY-Thee9", "Errors.AuthRequest.NotExisting"),
 		},
 		{

internal/query/authn_key.go

@@ -144,14 +144,14 @@ func (q *Queries) SearchAuthNKeys(ctx context.Context, queries *AuthNKeySearchQu
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-SAf3f", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		authNKeys, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-Dbg53", "Errors.Internal")
 	}
-	authNKeys, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	authNKeys.LatestSequence, err = q.latestSequence(ctx, authNKeyTable)
 	return authNKeys, err
 }
@@ -174,19 +174,18 @@ func (q *Queries) SearchAuthNKeysData(ctx context.Context, queries *AuthNKeySear
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-SAg3f", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		authNKeys, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-Dbi53", "Errors.Internal")
 	}
-	authNKeys, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
 	authNKeys.LatestSequence, err = q.latestSequence(ctx, authNKeyTable)
 	return authNKeys, err
 }
 
-func (q *Queries) GetAuthNKeyByID(ctx context.Context, shouldTriggerBulk bool, id string, withOwnerRemoved bool, queries ...SearchQuery) (_ *AuthNKey, err error) {
+func (q *Queries) GetAuthNKeyByID(ctx context.Context, shouldTriggerBulk bool, id string, withOwnerRemoved bool, queries ...SearchQuery) (key *AuthNKey, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -211,11 +210,14 @@ func (q *Queries) GetAuthNKeyByID(ctx context.Context, shouldTriggerBulk bool, i
 		return nil, errors.ThrowInternal(err, "QUERY-AGhg4", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		key, err = scan(row)
+		return err
+	}, stmt, args...)
+	return key, err
 }
 
-func (q *Queries) GetAuthNKeyPublicKeyByIDAndIdentifier(ctx context.Context, id string, identifier string, withOwnerRemoved bool) (_ []byte, err error) {
+func (q *Queries) GetAuthNKeyPublicKeyByIDAndIdentifier(ctx context.Context, id string, identifier string, withOwnerRemoved bool) (key []byte, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -250,8 +252,11 @@ func (q *Queries) GetAuthNKeyPublicKeyByIDAndIdentifier(ctx context.Context, id
 		return nil, errors.ThrowInternal(err, "QUERY-DAb32", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		key, err = scan(row)
+		return err
+	}, query, args...)
+	return key, err
 }
 
 func NewAuthNKeyResourceOwnerQuery(id string) (SearchQuery, error) {

internal/query/authn_key_test.go

@@ -349,13 +349,13 @@ func Test_AuthNKeyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*AuthNKey)(nil),
 		},
 		{
 			name:    "prepareAuthNKeyQuery no result",
 			prepare: prepareAuthNKeyQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(prepareAuthNKeyStmt),
 					nil,
 					nil,
@@ -412,13 +412,13 @@ func Test_AuthNKeyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*AuthNKey)(nil),
 		},
 		{
 			name:    "prepareAuthNKeyPublicKeyQuery no result",
 			prepare: prepareAuthNKeyPublicKeyQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(prepareAuthNKeyPublicKeyStmt),
 					nil,
 					nil,
@@ -461,7 +461,7 @@ func Test_AuthNKeyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: ([]byte)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/certificate.go

@@ -66,7 +66,7 @@ var (
 	}
 )
 
-func (q *Queries) ActiveCertificates(ctx context.Context, t time.Time, usage domain.KeyUsage) (_ *Certificates, err error) {
+func (q *Queries) ActiveCertificates(ctx context.Context, t time.Time, usage domain.KeyUsage) (certs *Certificates, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -88,19 +88,19 @@ func (q *Queries) ActiveCertificates(ctx context.Context, t time.Time, usage dom
 		return nil, errors.ThrowInternal(err, "QUERY-SDfkg", "Errors.Query.SQLStatement")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		certs, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-Sgan4", "Errors.Internal")
 	}
-	keys, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
-	keys.LatestSequence, err = q.latestSequence(ctx, keyTable)
+
+	certs.LatestSequence, err = q.latestSequence(ctx, keyTable)
 	if !errors.IsNotFound(err) {
-		return keys, err
+		return certs, err
 	}
-	return keys, nil
+	return certs, nil
 }
 
 func prepareCertificateQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Rows) (*Certificates, error)) {

internal/query/certificate_test.go

@@ -138,7 +138,7 @@ func Test_CertificatePrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Certificate)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/current_sequence.go

@@ -66,14 +66,17 @@ func (q *Queries) SearchCurrentSequences(ctx context.Context, queries *CurrentSe
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-MmFef", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		failedEvents, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-22H8f", "Errors.Internal")
 	}
-	return scan(rows)
+	return failedEvents, nil
 }
 
-func (q *Queries) latestSequence(ctx context.Context, projections ...table) (_ *LatestSequence, err error) {
+func (q *Queries) latestSequence(ctx context.Context, projections ...table) (seq *LatestSequence, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -91,8 +94,12 @@ func (q *Queries) latestSequence(ctx context.Context, projections ...table) (_ *
 		return nil, errors.ThrowInternal(err, "QUERY-5CfX9", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		seq, err = scan(row)
+		return err
+	}, stmt, args...)
+
+	return seq, err
 }
 
 func (q *Queries) ClearCurrentSequence(ctx context.Context, projectionName string) (err error) {
@@ -129,11 +136,17 @@ func (q *Queries) checkAndLock(ctx context.Context, projectionName string) error
 	if err != nil {
 		return errors.ThrowInternal(err, "QUERY-Dfwf2", "Errors.ProjectionName.Invalid")
 	}
-	row := q.client.QueryRowContext(ctx, projectionQuery, args...)
 	var count int
-	if err := row.Scan(&count); err != nil || count == 0 {
-		return errors.ThrowInternal(err, "QUERY-ej8fn", "Errors.ProjectionName.Invalid")
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		if err := row.Scan(&count); err != nil || count == 0 {
+			return errors.ThrowInternal(err, "QUERY-ej8fn", "Errors.ProjectionName.Invalid")
+		}
+		return err
+	}, projectionQuery, args...)
+	if err != nil {
+		return err
 	}
+
 	lock := fmt.Sprintf(lockStmtFormat, locksTable.identifier())
 	if err != nil {
 		return errors.ThrowInternal(err, "QUERY-DVfg3", "Errors.RemoveFailed")

internal/query/current_sequence_test.go

@@ -132,7 +132,7 @@ func Test_CurrentSequencesPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*CurrentSequences)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/custom_text.go

@@ -104,14 +104,14 @@ func (q *Queries) CustomTextList(ctx context.Context, aggregateID, template, lan
 		return nil, errors.ThrowInternal(err, "QUERY-M9gse", "Errors.Query.SQLStatement")
 	}
 
-	rows, err := q.client.QueryContext(ctx, query, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		texts, err = scan(rows)
+		return err
+	}, query, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-2j00f", "Errors.Internal")
 	}
-	texts, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	texts.LatestSequence, err = q.latestSequence(ctx, projectsTable)
 	return texts, err
 }
@@ -134,14 +134,14 @@ func (q *Queries) CustomTextListByTemplate(ctx context.Context, aggregateID, tem
 		return nil, errors.ThrowInternal(err, "QUERY-M49fs", "Errors.Query.SQLStatement")
 	}
 
-	rows, err := q.client.QueryContext(ctx, query, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		texts, err = scan(rows)
+		return err
+	}, query, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-3n9ge", "Errors.Internal")
 	}
-	texts, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	texts.LatestSequence, err = q.latestSequence(ctx, projectsTable)
 	return texts, err
 }

internal/query/custom_text_test.go

@@ -180,7 +180,7 @@ func Test_CustomTextPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*CustomText)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/device_auth.go

@@ -70,7 +70,7 @@ var (
 	}
 )
 
-func (q *Queries) DeviceAuthByDeviceCode(ctx context.Context, clientID, deviceCode string) (_ *domain.DeviceAuth, err error) {
+func (q *Queries) DeviceAuthByDeviceCode(ctx context.Context, clientID, deviceCode string) (deviceAuth *domain.DeviceAuth, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -85,10 +85,14 @@ func (q *Queries) DeviceAuthByDeviceCode(ctx context.Context, clientID, deviceCo
 		return nil, errors.ThrowInternal(err, "QUERY-uk1Oh", "Errors.Query.SQLStatement")
 	}
 
-	return scan(q.client.QueryRowContext(ctx, query, args...))
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		deviceAuth, err = scan(row)
+		return err
+	}, query, args...)
+	return deviceAuth, err
 }
 
-func (q *Queries) DeviceAuthByUserCode(ctx context.Context, userCode string) (_ *domain.DeviceAuth, err error) {
+func (q *Queries) DeviceAuthByUserCode(ctx context.Context, userCode string) (deviceAuth *domain.DeviceAuth, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -102,7 +106,11 @@ func (q *Queries) DeviceAuthByUserCode(ctx context.Context, userCode string) (_
 		return nil, errors.ThrowInternal(err, "QUERY-Axu7l", "Errors.Query.SQLStatement")
 	}
 
-	return scan(q.client.QueryRowContext(ctx, query, args...))
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		deviceAuth, err = scan(row)
+		return err
+	}, query, args...)
+	return deviceAuth, err
 }
 
 var deviceAuthSelectColumns = []string{

internal/query/device_auth_test.go

@@ -67,9 +67,11 @@ func TestQueries_DeviceAuthByDeviceCode(t *testing.T) {
 	}
 	defer client.Close()
 
+	mock.ExpectBegin()
 	mock.ExpectQuery(expectedDeviceAuthWhereDeviceCodeQuery).WillReturnRows(
 		sqlmock.NewRows(deviceAuthSelectColumns).AddRow(expectedDeviceAuthValues...),
 	)
+	mock.ExpectCommit()
 	q := Queries{
 		client: &database.DB{DB: client},
 	}
@@ -86,9 +88,11 @@ func TestQueries_DeviceAuthByUserCode(t *testing.T) {
 	}
 	defer client.Close()
 
+	mock.ExpectBegin()
 	mock.ExpectQuery(expectedDeviceAuthWhereUserCodeQuery).WillReturnRows(
 		sqlmock.NewRows(deviceAuthSelectColumns).AddRow(expectedDeviceAuthValues...),
 	)
+	mock.ExpectCommit()
 	q := Queries{
 		client: &database.DB{DB: client},
 	}
@@ -133,6 +137,7 @@ func Test_prepareDeviceAuthQuery(t *testing.T) {
 					return nil, true
 				},
 			},
+			object: (*domain.DeviceAuth)(nil),
 		},
 		{
 			name: "other error",
@@ -148,6 +153,7 @@ func Test_prepareDeviceAuthQuery(t *testing.T) {
 					return nil, true
 				},
 			},
+			object: (*domain.DeviceAuth)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/domain_policy.go

@@ -86,7 +86,7 @@ var (
 	}
 )
 
-func (q *Queries) DomainPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (_ *DomainPolicy, err error) {
+func (q *Queries) DomainPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (policy *DomainPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -120,11 +120,14 @@ func (q *Queries) DomainPolicyByOrg(ctx context.Context, shouldTriggerBulk bool,
 		return nil, errors.ThrowInternal(err, "QUERY-D3CqT", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
-func (q *Queries) DefaultDomainPolicy(ctx context.Context) (_ *DomainPolicy, err error) {
+func (q *Queries) DefaultDomainPolicy(ctx context.Context) (policy *DomainPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -139,8 +142,11 @@ func (q *Queries) DefaultDomainPolicy(ctx context.Context) (_ *DomainPolicy, err
 		return nil, errors.ThrowInternal(err, "QUERY-pM7lP", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
 func prepareDomainPolicyQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Row) (*DomainPolicy, error)) {

internal/query/domain_policy_test.go

@@ -54,7 +54,7 @@ func Test_DomainPolicyPrepares(t *testing.T) {
 			name:    "prepareDomainPolicyQuery no result",
 			prepare: prepareDomainPolicyQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(prepareDomainPolicyStmt),
 					nil,
 					nil,
@@ -117,7 +117,7 @@ func Test_DomainPolicyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*DomainPolicy)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/failed_events.go

@@ -77,11 +77,14 @@ func (q *Queries) SearchFailedEvents(ctx context.Context, queries *FailedEventSe
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-n8rjJ", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		failedEvents, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-3j99J", "Errors.Internal")
 	}
-	return scan(rows)
+	return failedEvents, nil
 }
 
 func (q *Queries) RemoveFailedEvent(ctx context.Context, projectionName, instanceID string, sequence uint64) (err error) {

internal/query/failed_events_test.go

@@ -146,7 +146,7 @@ func Test_FailedEventsPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*FailedEvents)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/iam_member.go

@@ -76,7 +76,7 @@ func addIamMemberWithoutOwnerRemoved(eq map[string]interface{}) {
 	eq[InstanceMemberOwnerRemovedUser.identifier()] = false
 }
 
-func (q *Queries) IAMMembers(ctx context.Context, queries *IAMMembersQuery, withOwnerRemoved bool) (_ *Members, err error) {
+func (q *Queries) IAMMembers(ctx context.Context, queries *IAMMembersQuery, withOwnerRemoved bool) (members *Members, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -96,14 +96,13 @@ func (q *Queries) IAMMembers(ctx context.Context, queries *IAMMembersQuery, with
 		return nil, err
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		members, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-Pdg1I", "Errors.Internal")
 	}
-	members, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
 	members.LatestSequence = currentSequence
 	return members, err
 }

internal/query/iam_member_test.go

@@ -280,7 +280,7 @@ func Test_IAMMemberPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*IAMMembership)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/idp.go

@@ -188,7 +188,7 @@ var (
 )
 
 // IDPByIDAndResourceOwner searches for the requested id in the context of the resource owner and IAM
-func (q *Queries) IDPByIDAndResourceOwner(ctx context.Context, shouldTriggerBulk bool, id, resourceOwner string, withOwnerRemoved bool) (_ *IDP, err error) {
+func (q *Queries) IDPByIDAndResourceOwner(ctx context.Context, shouldTriggerBulk bool, id, resourceOwner string, withOwnerRemoved bool) (idp *IDP, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -216,8 +216,11 @@ func (q *Queries) IDPByIDAndResourceOwner(ctx context.Context, shouldTriggerBulk
 		return nil, errors.ThrowInternal(err, "QUERY-0gocI", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		idp, err = scan(row)
+		return err
+	}, query, args...)
+	return idp, err
 }
 
 // IDPs searches idps matching the query
@@ -237,14 +240,13 @@ func (q *Queries) IDPs(ctx context.Context, queries *IDPSearchQueries, withOwner
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-X6X7y", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		idps, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-xPlVH", "Errors.Internal")
 	}
-	idps, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
 	idps.LatestSequence, err = q.latestSequence(ctx, idpTable)
 	return idps, err
 }

internal/query/idp_login_policy_link.go

@@ -105,13 +105,13 @@ func (q *Queries) IDPLoginPolicyLinks(ctx context.Context, resourceOwner string,
 	if err != nil {
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-FDbKW", "Errors.Query.InvalidRequest")
 	}
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
-	if err != nil || rows.Err() != nil {
-		return nil, errors.ThrowInternal(err, "QUERY-ZkKUc", "Errors.Internal")
-	}
-	idps, err = scan(rows)
+
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		idps, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
-		return nil, err
+		return nil, errors.ThrowInternal(err, "QUERY-ZkKUc", "Errors.Internal")
 	}
 	idps.LatestSequence, err = q.latestSequence(ctx, idpLoginPolicyLinkTable)
 	return idps, err

internal/query/idp_login_policy_link_test.go

@@ -128,7 +128,7 @@ func Test_IDPLoginPolicyLinkPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*IDPs)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/idp_template.go

@@ -606,7 +606,7 @@ var (
 )
 
 // IDPTemplateByID searches for the requested id
-func (q *Queries) IDPTemplateByID(ctx context.Context, shouldTriggerBulk bool, id string, withOwnerRemoved bool, queries ...SearchQuery) (_ *IDPTemplate, err error) {
+func (q *Queries) IDPTemplateByID(ctx context.Context, shouldTriggerBulk bool, id string, withOwnerRemoved bool, queries ...SearchQuery) (template *IDPTemplate, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -630,8 +630,11 @@ func (q *Queries) IDPTemplateByID(ctx context.Context, shouldTriggerBulk bool, i
 		return nil, errors.ThrowInternal(err, "QUERY-SFefg", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		template, err = scan(row)
+		return err
+	}, stmt, args...)
+	return template, err
 }
 
 // IDPTemplates searches idp templates matching the query
@@ -651,14 +654,13 @@ func (q *Queries) IDPTemplates(ctx context.Context, queries *IDPTemplateSearchQu
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-SAF34", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		idps, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-BDFrq", "Errors.Internal")
 	}
-	idps, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
 	idps.LatestSequence, err = q.latestSequence(ctx, idpTemplateTable)
 	return idps, err
 }

internal/query/idp_template_test.go

@@ -443,7 +443,7 @@ func Test_IDPTemplateTemplatesPrepares(t *testing.T) {
 			name:    "prepareIDPTemplateByIDQuery no result",
 			prepare: prepareIDPTemplateByIDQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(idpTemplateQuery),
 					nil,
 					nil,
@@ -1646,7 +1646,7 @@ func Test_IDPTemplateTemplatesPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*IDPTemplate)(nil),
 		},
 		{
 			name:    "prepareIDPTemplatesQuery no result",
@@ -2606,7 +2606,7 @@ func Test_IDPTemplateTemplatesPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*IDPTemplates)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/idp_test.go

@@ -144,7 +144,7 @@ func Test_IDPPrepares(t *testing.T) {
 			name:    "prepareIDPByIDQuery no result",
 			prepare: prepareIDPByIDQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(idpQuery),
 					nil,
 					nil,
@@ -341,7 +341,7 @@ func Test_IDPPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*IDP)(nil),
 		},
 		{
 			name:    "prepareIDPsQuery no result",
@@ -728,7 +728,7 @@ func Test_IDPPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*IDPs)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/idp_user_link.go

@@ -103,14 +103,13 @@ func (q *Queries) IDPUserLinks(ctx context.Context, queries *IDPUserLinksSearchQ
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-4zzFK", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		idps, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-C1E4D", "Errors.Internal")
 	}
-	idps, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
 	idps.LatestSequence, err = q.latestSequence(ctx, idpUserLinkTable)
 	return idps, err
 }

internal/query/idp_user_link_test.go

@@ -135,7 +135,7 @@ func Test_IDPUserLinkPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*IDPUserLinks)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/instance.go

@@ -166,18 +166,17 @@ func (q *Queries) SearchInstances(ctx context.Context, queries *InstanceSearchQu
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-M9fow", "Errors.Query.SQLStatement")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		instances, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-3j98f", "Errors.Internal")
 	}
-	instances, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
 	return instances, err
 }
 
-func (q *Queries) Instance(ctx context.Context, shouldTriggerBulk bool) (_ *Instance, err error) {
+func (q *Queries) Instance(ctx context.Context, shouldTriggerBulk bool) (instance *Instance, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -193,14 +192,14 @@ func (q *Queries) Instance(ctx context.Context, shouldTriggerBulk bool) (_ *Inst
 		return nil, errors.ThrowInternal(err, "QUERY-d9ngs", "Errors.Query.SQLStatement")
 	}
 
-	row, err := q.client.QueryContext(ctx, query, args...)
-	if err != nil {
-		return nil, err
-	}
-	return scan(row)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		instance, err = scan(rows)
+		return err
+	}, query, args...)
+	return instance, err
 }
 
-func (q *Queries) InstanceByHost(ctx context.Context, host string) (_ authz.Instance, err error) {
+func (q *Queries) InstanceByHost(ctx context.Context, host string) (instance authz.Instance, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -213,11 +212,11 @@ func (q *Queries) InstanceByHost(ctx context.Context, host string) (_ authz.Inst
 		return nil, errors.ThrowInternal(err, "QUERY-SAfg2", "Errors.Query.SQLStatement")
 	}
 
-	row, err := q.client.QueryContext(ctx, query, args...)
-	if err != nil {
-		return nil, err
-	}
-	return scan(row)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		instance, err = scan(rows)
+		return err
+	}, query, args...)
+	return instance, err
 }
 
 func (q *Queries) InstanceByID(ctx context.Context) (_ authz.Instance, err error) {

internal/query/instance_domain.go

@@ -88,11 +88,10 @@ func (q *Queries) SearchInstanceDomainsGlobal(ctx context.Context, queries *Inst
 }
 
 func (q *Queries) queryInstanceDomains(ctx context.Context, stmt string, scan func(*sql.Rows) (*InstanceDomains, error), args ...interface{}) (domains *InstanceDomains, err error) {
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "QUERY-Dh9Ap", "Errors.Internal")
-	}
-	domains, err = scan(rows)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		domains, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}

internal/query/instance_domain_test.go

@@ -162,7 +162,7 @@ func Test_InstanceDomainPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Domains)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/instance_test.go

@@ -97,7 +97,7 @@ func Test_InstancePrepares(t *testing.T) {
 			additionalArgs: []reflect.Value{reflect.ValueOf("")},
 			prepare:        prepareInstanceQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(instanceQuery),
 					nil,
 					nil,
@@ -160,7 +160,7 @@ func Test_InstancePrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Instance)(nil),
 		},
 		{
 			name: "prepareInstancesQuery no result",

internal/query/key.go

@@ -177,7 +177,7 @@ var (
 	}
 )
 
-func (q *Queries) ActivePublicKeys(ctx context.Context, t time.Time) (_ *PublicKeys, err error) {
+func (q *Queries) ActivePublicKeys(ctx context.Context, t time.Time) (keys *PublicKeys, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -194,14 +194,14 @@ func (q *Queries) ActivePublicKeys(ctx context.Context, t time.Time) (_ *PublicK
 		return nil, errors.ThrowInternal(err, "QUERY-SDFfg", "Errors.Query.SQLStatement")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		keys, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-Sghn4", "Errors.Internal")
 	}
-	keys, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	keys.LatestSequence, err = q.latestSequence(ctx, keyTable)
 	if !errors.IsNotFound(err) {
 		return keys, err
@@ -209,7 +209,7 @@ func (q *Queries) ActivePublicKeys(ctx context.Context, t time.Time) (_ *PublicK
 	return keys, nil
 }
 
-func (q *Queries) ActivePrivateSigningKey(ctx context.Context, t time.Time) (_ *PrivateKeys, err error) {
+func (q *Queries) ActivePrivateSigningKey(ctx context.Context, t time.Time) (keys *PrivateKeys, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -229,14 +229,13 @@ func (q *Queries) ActivePrivateSigningKey(ctx context.Context, t time.Time) (_ *
 		return nil, errors.ThrowInternal(err, "QUERY-SDff2", "Errors.Query.SQLStatement")
 	}
 
-	rows, err := q.client.QueryContext(ctx, query, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		keys, err = scan(rows)
+		return err
+	}, query, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-WRFG4", "Errors.Internal")
 	}
-	keys, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
 	keys.LatestSequence, err = q.latestSequence(ctx, keyTable)
 	if !errors.IsNotFound(err) {
 		return keys, err

internal/query/key_test.go

@@ -147,7 +147,7 @@ func Test_KeyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*PublicKeys)(nil),
 		},
 		{
 			name:    "preparePrivateKeysQuery no result",
@@ -230,7 +230,7 @@ func Test_KeyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*PrivateKeys)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/label_policy.go

@@ -42,7 +42,7 @@ type Theme struct {
 	IconURL         string
 }
 
-func (q *Queries) ActiveLabelPolicyByOrg(ctx context.Context, orgID string, withOwnerRemoved bool) (_ *LabelPolicy, err error) {
+func (q *Queries) ActiveLabelPolicyByOrg(ctx context.Context, orgID string, withOwnerRemoved bool) (policy *LabelPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -68,11 +68,14 @@ func (q *Queries) ActiveLabelPolicyByOrg(ctx context.Context, orgID string, with
 		return nil, errors.ThrowInternal(err, "QUERY-V22un", "unable to create sql stmt")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
-func (q *Queries) PreviewLabelPolicyByOrg(ctx context.Context, orgID string) (_ *LabelPolicy, err error) {
+func (q *Queries) PreviewLabelPolicyByOrg(ctx context.Context, orgID string) (policy *LabelPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -98,11 +101,14 @@ func (q *Queries) PreviewLabelPolicyByOrg(ctx context.Context, orgID string) (_
 		return nil, errors.ThrowInternal(err, "QUERY-AG5eq", "unable to create sql stmt")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
-func (q *Queries) DefaultActiveLabelPolicy(ctx context.Context) (_ *LabelPolicy, err error) {
+func (q *Queries) DefaultActiveLabelPolicy(ctx context.Context) (policy *LabelPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -118,11 +124,14 @@ func (q *Queries) DefaultActiveLabelPolicy(ctx context.Context) (_ *LabelPolicy,
 		return nil, errors.ThrowInternal(err, "QUERY-mN0Ci", "unable to create sql stmt")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
-func (q *Queries) DefaultPreviewLabelPolicy(ctx context.Context) (_ *LabelPolicy, err error) {
+func (q *Queries) DefaultPreviewLabelPolicy(ctx context.Context) (policy *LabelPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -138,8 +147,11 @@ func (q *Queries) DefaultPreviewLabelPolicy(ctx context.Context) (_ *LabelPolicy
 		return nil, errors.ThrowInternal(err, "QUERY-B3JQR", "unable to create sql stmt")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
 var (

internal/query/lockout_policy.go

@@ -81,7 +81,7 @@ var (
 	}
 )
 
-func (q *Queries) LockoutPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (_ *LockoutPolicy, err error) {
+func (q *Queries) LockoutPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (policy *LockoutPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -110,11 +110,14 @@ func (q *Queries) LockoutPolicyByOrg(ctx context.Context, shouldTriggerBulk bool
 		return nil, errors.ThrowInternal(err, "QUERY-SKR6X", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
-func (q *Queries) DefaultLockoutPolicy(ctx context.Context) (_ *LockoutPolicy, err error) {
+func (q *Queries) DefaultLockoutPolicy(ctx context.Context) (policy *LockoutPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -129,8 +132,11 @@ func (q *Queries) DefaultLockoutPolicy(ctx context.Context) (_ *LockoutPolicy, e
 		return nil, errors.ThrowInternal(err, "QUERY-mN0Ci", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
 func prepareLockoutPolicyQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Row) (*LockoutPolicy, error)) {

internal/query/lockout_policy_test.go

@@ -53,7 +53,7 @@ func Test_LockoutPolicyPrepares(t *testing.T) {
 			name:    "prepareLockoutPolicyQuery no result",
 			prepare: prepareLockoutPolicyQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(prepareLockoutPolicyStmt),
 					nil,
 					nil,
@@ -114,7 +114,7 @@ func Test_LockoutPolicyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*LockoutPolicy)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/login_policy.go

@@ -166,7 +166,7 @@ var (
 	}
 )
 
-func (q *Queries) LoginPolicyByID(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (_ *LoginPolicy, err error) {
+func (q *Queries) LoginPolicyByID(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (policy *LoginPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -191,11 +191,14 @@ func (q *Queries) LoginPolicyByID(ctx context.Context, shouldTriggerBulk bool, o
 		return nil, errors.ThrowInternal(err, "QUERY-scVHo", "Errors.Query.SQLStatement")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		policy, err = q.scanAndAddLinksToLoginPolicy(ctx, rows, scan)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-SWgr3", "Errors.Internal")
 	}
-	return q.scanAndAddLinksToLoginPolicy(ctx, rows, scan)
+	return policy, nil
 }
 
 func (q *Queries) scanAndAddLinksToLoginPolicy(ctx context.Context, rows *sql.Rows, scan func(*sql.Rows) (*LoginPolicy, error)) (*LoginPolicy, error) {
@@ -214,7 +217,7 @@ func (q *Queries) scanAndAddLinksToLoginPolicy(ctx context.Context, rows *sql.Ro
 	return policy, nil
 }
 
-func (q *Queries) DefaultLoginPolicy(ctx context.Context) (_ *LoginPolicy, err error) {
+func (q *Queries) DefaultLoginPolicy(ctx context.Context) (policy *LoginPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -227,14 +230,17 @@ func (q *Queries) DefaultLoginPolicy(ctx context.Context) (_ *LoginPolicy, err e
 		return nil, errors.ThrowInternal(err, "QUERY-t4TBK", "Errors.Query.SQLStatement")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		policy, err = q.scanAndAddLinksToLoginPolicy(ctx, rows, scan)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-SArt2", "Errors.Internal")
 	}
-	return q.scanAndAddLinksToLoginPolicy(ctx, rows, scan)
+	return policy, nil
 }
 
-func (q *Queries) SecondFactorsByOrg(ctx context.Context, orgID string) (_ *SecondFactors, err error) {
+func (q *Queries) SecondFactorsByOrg(ctx context.Context, orgID string) (factors *SecondFactors, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -259,8 +265,10 @@ func (q *Queries) SecondFactorsByOrg(ctx context.Context, orgID string) (_ *Seco
 		return nil, errors.ThrowInternal(err, "QUERY-scVHo", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	factors, err := scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		factors, err = scan(row)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -268,7 +276,7 @@ func (q *Queries) SecondFactorsByOrg(ctx context.Context, orgID string) (_ *Seco
 	return factors, err
 }
 
-func (q *Queries) DefaultSecondFactors(ctx context.Context) (_ *SecondFactors, err error) {
+func (q *Queries) DefaultSecondFactors(ctx context.Context) (factors *SecondFactors, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -281,8 +289,10 @@ func (q *Queries) DefaultSecondFactors(ctx context.Context) (_ *SecondFactors, e
 		return nil, errors.ThrowInternal(err, "QUERY-CZ2Nv", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	factors, err := scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		factors, err = scan(row)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -290,7 +300,7 @@ func (q *Queries) DefaultSecondFactors(ctx context.Context) (_ *SecondFactors, e
 	return factors, err
 }
 
-func (q *Queries) MultiFactorsByOrg(ctx context.Context, orgID string) (_ *MultiFactors, err error) {
+func (q *Queries) MultiFactorsByOrg(ctx context.Context, orgID string) (factors *MultiFactors, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -315,8 +325,10 @@ func (q *Queries) MultiFactorsByOrg(ctx context.Context, orgID string) (_ *Multi
 		return nil, errors.ThrowInternal(err, "QUERY-B4o7h", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	factors, err := scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		factors, err = scan(row)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -324,7 +336,7 @@ func (q *Queries) MultiFactorsByOrg(ctx context.Context, orgID string) (_ *Multi
 	return factors, err
 }
 
-func (q *Queries) DefaultMultiFactors(ctx context.Context) (_ *MultiFactors, err error) {
+func (q *Queries) DefaultMultiFactors(ctx context.Context) (factors *MultiFactors, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -337,8 +349,10 @@ func (q *Queries) DefaultMultiFactors(ctx context.Context) (_ *MultiFactors, err
 		return nil, errors.ThrowInternal(err, "QUERY-WxYjr", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	factors, err := scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		factors, err = scan(row)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}

internal/query/login_policy_test.go

@@ -98,7 +98,7 @@ func Test_LoginPolicyPrepares(t *testing.T) {
 			name:    "prepareLoginPolicyQuery no result",
 			prepare: prepareLoginPolicyQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(loginPolicyQuery),
 					nil,
 					nil,
@@ -189,13 +189,13 @@ func Test_LoginPolicyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*LoginPolicy)(nil),
 		},
 		{
 			name:    "prepareLoginPolicy2FAsQuery no result",
 			prepare: prepareLoginPolicy2FAsQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(prepareLoginPolicy2FAsStmt),
 					prepareLoginPolicy2FAsCols,
 					nil,
@@ -257,13 +257,13 @@ func Test_LoginPolicyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*SecondFactors)(nil),
 		},
 		{
 			name:    "prepareLoginPolicyMFAsQuery no result",
 			prepare: prepareLoginPolicyMFAsQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(prepareLoginPolicyMFAsStmt),
 					prepareLoginPolicyMFAsCols,
 					nil,
@@ -325,7 +325,7 @@ func Test_LoginPolicyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*MultiFactors)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/mail_template.go

@@ -70,7 +70,7 @@ var (
 	}
 )
 
-func (q *Queries) MailTemplateByOrg(ctx context.Context, orgID string, withOwnerRemoved bool) (_ *MailTemplate, err error) {
+func (q *Queries) MailTemplateByOrg(ctx context.Context, orgID string, withOwnerRemoved bool) (template *MailTemplate, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -93,11 +93,14 @@ func (q *Queries) MailTemplateByOrg(ctx context.Context, orgID string, withOwner
 		return nil, errors.ThrowInternal(err, "QUERY-m0sJg", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		template, err = scan(row)
+		return err
+	}, query, args...)
+	return template, err
 }
 
-func (q *Queries) DefaultMailTemplate(ctx context.Context) (_ *MailTemplate, err error) {
+func (q *Queries) DefaultMailTemplate(ctx context.Context) (template *MailTemplate, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -112,8 +115,11 @@ func (q *Queries) DefaultMailTemplate(ctx context.Context) (_ *MailTemplate, err
 		return nil, errors.ThrowInternal(err, "QUERY-2m0fH", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		template, err = scan(row)
+		return err
+	}, query, args...)
+	return template, err
 }
 
 func prepareMailTemplateQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Row) (*MailTemplate, error)) {

internal/query/message_text.go

@@ -126,7 +126,7 @@ var (
 	}
 )
 
-func (q *Queries) DefaultMessageText(ctx context.Context) (_ *MessageText, err error) {
+func (q *Queries) DefaultMessageText(ctx context.Context) (text *MessageText, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -140,8 +140,11 @@ func (q *Queries) DefaultMessageText(ctx context.Context) (_ *MessageText, err e
 		return nil, errors.ThrowInternal(err, "QUERY-1b9mf", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		text, err = scan(row)
+		return err
+	}, query, args...)
+	return text, err
 }
 
 func (q *Queries) DefaultMessageTextByTypeAndLanguageFromFileSystem(ctx context.Context, messageType, language string) (_ *MessageText, err error) {
@@ -159,7 +162,7 @@ func (q *Queries) DefaultMessageTextByTypeAndLanguageFromFileSystem(ctx context.
 	return messageTexts.GetMessageTextByType(messageType), nil
 }
 
-func (q *Queries) CustomMessageTextByTypeAndLanguage(ctx context.Context, aggregateID, messageType, language string, withOwnerRemoved bool) (_ *MessageText, err error) {
+func (q *Queries) CustomMessageTextByTypeAndLanguage(ctx context.Context, aggregateID, messageType, language string, withOwnerRemoved bool) (msg *MessageText, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -179,8 +182,10 @@ func (q *Queries) CustomMessageTextByTypeAndLanguage(ctx context.Context, aggreg
 		return nil, errors.ThrowInternal(err, "QUERY-1b9mf", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	msg, err := scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		msg, err = scan(row)
+		return err
+	}, query, args...)
 	if errors.IsNotFound(err) {
 		return q.IAMMessageTextByTypeAndLanguage(ctx, messageType, language)
 	}

internal/query/message_text_test.go

@@ -64,7 +64,7 @@ func Test_MessageTextPrepares(t *testing.T) {
 			name:    "prepareMessageTextQuery no result",
 			prepare: prepareMessageTextQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(prepareMessageTextStmt),
 					nil,
 					nil,
@@ -135,7 +135,7 @@ func Test_MessageTextPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*MessageText)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/milestone.go

@@ -69,7 +69,7 @@ var (
 )
 
 // SearchMilestones tries to defer the instanceID from the passed context if no instanceIDs are passed
-func (q *Queries) SearchMilestones(ctx context.Context, instanceIDs []string, queries *MilestonesSearchQueries) (_ *Milestones, err error) {
+func (q *Queries) SearchMilestones(ctx context.Context, instanceIDs []string, queries *MilestonesSearchQueries) (milestones *Milestones, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 	query, scan := prepareMilestonesQuery(ctx, q.client)
@@ -80,22 +80,14 @@ func (q *Queries) SearchMilestones(ctx context.Context, instanceIDs []string, qu
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-A9i5k", "Errors.Query.SQLStatement")
 	}
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		milestones, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}
-	defer func() {
-		if closeErr := rows.Close(); closeErr != nil && err == nil {
-			err = errors.ThrowInternal(closeErr, "QUERY-CK9mI", "Errors.Query.CloseRows")
-		}
-	}()
-	milestones, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
-	if err = rows.Err(); err != nil {
-		return nil, errors.ThrowInternal(err, "QUERY-asLsI", "Errors.Internal")
-	}
+
 	milestones.LatestSequence, err = q.latestSequence(ctx, milestonesTable)
 	return milestones, err
 

internal/query/milestone_test.go

@@ -178,7 +178,7 @@ func Test_MilestonesPrepare(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Milestones)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/notification_policy.go

@@ -76,7 +76,7 @@ var (
 	}
 )
 
-func (q *Queries) NotificationPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (_ *NotificationPolicy, err error) {
+func (q *Queries) NotificationPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (policy *NotificationPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -104,11 +104,14 @@ func (q *Queries) NotificationPolicyByOrg(ctx context.Context, shouldTriggerBulk
 		return nil, errors.ThrowInternal(err, "QUERY-Xuoapqm", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
-func (q *Queries) DefaultNotificationPolicy(ctx context.Context, shouldTriggerBulk bool) (_ *NotificationPolicy, err error) {
+func (q *Queries) DefaultNotificationPolicy(ctx context.Context, shouldTriggerBulk bool) (policy *NotificationPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -130,8 +133,11 @@ func (q *Queries) DefaultNotificationPolicy(ctx context.Context, shouldTriggerBu
 		return nil, errors.ThrowInternal(err, "QUERY-xlqp209", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
 func prepareNotificationPolicyQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Row) (*NotificationPolicy, error)) {

internal/query/notification_policy_test.go

@@ -50,7 +50,7 @@ func Test_NotificationPolicyPrepares(t *testing.T) {
 			name:    "prepareNotificationPolicyQuery no result",
 			prepare: prepareNotificationPolicyQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					notificationPolicyStmt,
 					nil,
 					nil,
@@ -109,7 +109,7 @@ func Test_NotificationPolicyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*NotificationPolicy)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/notification_provider.go

@@ -70,7 +70,7 @@ var (
 	}
 )
 
-func (q *Queries) NotificationProviderByIDAndType(ctx context.Context, aggID string, providerType domain.NotificationProviderType) (_ *DebugNotificationProvider, err error) {
+func (q *Queries) NotificationProviderByIDAndType(ctx context.Context, aggID string, providerType domain.NotificationProviderType) (provider *DebugNotificationProvider, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -90,8 +90,11 @@ func (q *Queries) NotificationProviderByIDAndType(ctx context.Context, aggID str
 		return nil, errors.ThrowInternal(err, "QUERY-f9jSf", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		provider, err = scan(row)
+		return err
+	}, stmt, args...)
+	return provider, err
 }
 
 func prepareDebugNotificationProviderQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Row) (*DebugNotificationProvider, error)) {

internal/query/notification_provider_test.go

@@ -50,7 +50,7 @@ func Test_NotificationProviderPrepares(t *testing.T) {
 			name:    "prepareNotificationProviderQuery no result",
 			prepare: prepareDebugNotificationProviderQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(prepareNotificationProviderStmt),
 					nil,
 					nil,
@@ -109,7 +109,7 @@ func Test_NotificationProviderPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*DebugNotificationProvider)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/oidc_settings.go

@@ -75,7 +75,7 @@ type OIDCSettings struct {
 	RefreshTokenExpiration     time.Duration
 }
 
-func (q *Queries) OIDCSettingsByAggID(ctx context.Context, aggregateID string) (_ *OIDCSettings, err error) {
+func (q *Queries) OIDCSettingsByAggID(ctx context.Context, aggregateID string) (settings *OIDCSettings, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -88,8 +88,11 @@ func (q *Queries) OIDCSettingsByAggID(ctx context.Context, aggregateID string) (
 		return nil, errors.ThrowInternal(err, "QUERY-s9nle", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		settings, err = scan(row)
+		return err
+	}, query, args...)
+	return settings, err
 }
 
 func prepareOIDCSettingsQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Row) (*OIDCSettings, error)) {

internal/query/oidc_settings_test.go

@@ -52,7 +52,7 @@ func Test_OIDCConfigsPrepares(t *testing.T) {
 			name:    "prepareOIDCSettingsQuery no result",
 			prepare: prepareOIDCSettingsQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					prepareOIDCSettingsStmt,
 					nil,
 					nil,
@@ -113,7 +113,7 @@ func Test_OIDCConfigsPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*OIDCSettings)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/org.go

@@ -89,7 +89,7 @@ func (q *OrgSearchQueries) toQuery(query sq.SelectBuilder) sq.SelectBuilder {
 	return query
 }
 
-func (q *Queries) OrgByID(ctx context.Context, shouldTriggerBulk bool, id string) (_ *Org, err error) {
+func (q *Queries) OrgByID(ctx context.Context, shouldTriggerBulk bool, id string) (org *Org, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -106,11 +106,14 @@ func (q *Queries) OrgByID(ctx context.Context, shouldTriggerBulk bool, id string
 		return nil, errors.ThrowInternal(err, "QUERY-AWx52", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		org, err = scan(row)
+		return err
+	}, query, args...)
+	return org, err
 }
 
-func (q *Queries) OrgByPrimaryDomain(ctx context.Context, domain string) (_ *Org, err error) {
+func (q *Queries) OrgByPrimaryDomain(ctx context.Context, domain string) (org *Org, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -124,11 +127,14 @@ func (q *Queries) OrgByPrimaryDomain(ctx context.Context, domain string) (_ *Org
 		return nil, errors.ThrowInternal(err, "QUERY-TYUCE", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		org, err = scan(row)
+		return err
+	}, query, args...)
+	return org, err
 }
 
-func (q *Queries) OrgByVerifiedDomain(ctx context.Context, domain string) (_ *Org, err error) {
+func (q *Queries) OrgByVerifiedDomain(ctx context.Context, domain string) (org *Org, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -142,8 +148,11 @@ func (q *Queries) OrgByVerifiedDomain(ctx context.Context, domain string) (_ *Or
 		return nil, errors.ThrowInternal(err, "QUERY-TYUCE", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		org, err = scan(row)
+		return err
+	}, query, args...)
+	return org, err
 }
 
 func (q *Queries) IsOrgUnique(ctx context.Context, name, domain string) (isUnique bool, err error) {
@@ -176,8 +185,11 @@ func (q *Queries) IsOrgUnique(ctx context.Context, name, domain string) (isUniqu
 		return false, errors.ThrowInternal(err, "QUERY-Dgbe2", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		isUnique, err = scan(row)
+		return err
+	}, stmt, args...)
+	return isUnique, err
 }
 
 func (q *Queries) ExistsOrg(ctx context.Context, id, domain string) (verifiedID string, err error) {
@@ -209,14 +221,14 @@ func (q *Queries) SearchOrgs(ctx context.Context, queries *OrgSearchQueries) (or
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-wQ3by", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		orgs, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-M6mYN", "Errors.Internal")
 	}
-	orgs, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	orgs.LatestSequence, err = q.latestSequence(ctx, orgsTable)
 	return orgs, err
 }

internal/query/org_domain.go

@@ -70,14 +70,14 @@ func (q *Queries) SearchOrgDomains(ctx context.Context, queries *OrgDomainSearch
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-ZRfj1", "Errors.Query.SQLStatement")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		domains, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-M6mYN", "Errors.Internal")
 	}
-	domains, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	domains.LatestSequence, err = q.latestSequence(ctx, orgDomainsTable)
 	return domains, err
 }

internal/query/org_domain_test.go

@@ -172,7 +172,7 @@ func Test_OrgDomainPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Domains)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/org_member.go

@@ -78,7 +78,7 @@ func addOrgMemberWithoutOwnerRemoved(eq map[string]interface{}) {
 	eq[OrgMemberOwnerRemovedUser.identifier()] = false
 }
 
-func (q *Queries) OrgMembers(ctx context.Context, queries *OrgMembersQuery, withOwnerRemoved bool) (_ *Members, err error) {
+func (q *Queries) OrgMembers(ctx context.Context, queries *OrgMembersQuery, withOwnerRemoved bool) (members *Members, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -98,14 +98,14 @@ func (q *Queries) OrgMembers(ctx context.Context, queries *OrgMembersQuery, with
 		return nil, err
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		members, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-5g4yV", "Errors.Internal")
 	}
-	members, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	members.LatestSequence = currentSequence
 	return members, err
 }

internal/query/org_member_test.go

@@ -284,7 +284,7 @@ func Test_OrgMemberPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*OrgMembership)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/org_metadata.go

@@ -77,7 +77,7 @@ var (
 	}
 )
 
-func (q *Queries) GetOrgMetadataByKey(ctx context.Context, shouldTriggerBulk bool, orgID string, key string, withOwnerRemoved bool, queries ...SearchQuery) (_ *OrgMetadata, err error) {
+func (q *Queries) GetOrgMetadataByKey(ctx context.Context, shouldTriggerBulk bool, orgID string, key string, withOwnerRemoved bool, queries ...SearchQuery) (metadata *OrgMetadata, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -102,11 +102,14 @@ func (q *Queries) GetOrgMetadataByKey(ctx context.Context, shouldTriggerBulk boo
 		return nil, errors.ThrowInternal(err, "QUERY-aDaG2", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		metadata, err = scan(row)
+		return err
+	}, stmt, args...)
+	return metadata, err
 }
 
-func (q *Queries) SearchOrgMetadata(ctx context.Context, shouldTriggerBulk bool, orgID string, queries *OrgMetadataSearchQueries, withOwnerRemoved bool) (_ *OrgMetadataList, err error) {
+func (q *Queries) SearchOrgMetadata(ctx context.Context, shouldTriggerBulk bool, orgID string, queries *OrgMetadataSearchQueries, withOwnerRemoved bool) (metadata *OrgMetadataList, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -126,14 +129,14 @@ func (q *Queries) SearchOrgMetadata(ctx context.Context, shouldTriggerBulk bool,
 		return nil, errors.ThrowInternal(err, "QUERY-Egbld", "Errors.Query.SQLStatment")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		metadata, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-Ho2wf", "Errors.Internal")
 	}
-	metadata, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	metadata.LatestSequence, err = q.latestSequence(ctx, orgMetadataTable)
 	return metadata, err
 }

internal/query/org_metadata_test.go

@@ -63,7 +63,7 @@ func Test_OrgMetadataPrepares(t *testing.T) {
 			name:    "prepareOrgMetadataQuery no result",
 			prepare: prepareOrgMetadataQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(orgMetadataQuery),
 					nil,
 					nil,
@@ -118,7 +118,7 @@ func Test_OrgMetadataPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*OrgMetadata)(nil),
 		},
 		{
 			name:    "prepareOrgMetadataListQuery no result",
@@ -239,7 +239,7 @@ func Test_OrgMetadataPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*OrgMetadataList)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/org_test.go

@@ -209,13 +209,13 @@ func Test_OrgPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Orgs)(nil),
 		},
 		{
 			name:    "prepareOrgQuery no result",
 			prepare: prepareOrgQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(prepareOrgQueryStmt),
 					nil,
 					nil,
@@ -274,13 +274,13 @@ func Test_OrgPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Org)(nil),
 		},
 		{
 			name:    "prepareOrgUniqueQuery no result",
 			prepare: prepareOrgUniqueQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(prepareOrgUniqueStmt),
 					nil,
 					nil,
@@ -323,7 +323,7 @@ func Test_OrgPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: false,
 		},
 	}
 	for _, tt := range tests {

internal/query/password_age_policy.go

@@ -81,7 +81,7 @@ var (
 	}
 )
 
-func (q *Queries) PasswordAgePolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (_ *PasswordAgePolicy, err error) {
+func (q *Queries) PasswordAgePolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (policy *PasswordAgePolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -107,11 +107,14 @@ func (q *Queries) PasswordAgePolicyByOrg(ctx context.Context, shouldTriggerBulk
 		return nil, errors.ThrowInternal(err, "QUERY-SKR6X", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
-func (q *Queries) DefaultPasswordAgePolicy(ctx context.Context, shouldTriggerBulk bool) (_ *PasswordAgePolicy, err error) {
+func (q *Queries) DefaultPasswordAgePolicy(ctx context.Context, shouldTriggerBulk bool) (policy *PasswordAgePolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -129,8 +132,11 @@ func (q *Queries) DefaultPasswordAgePolicy(ctx context.Context, shouldTriggerBul
 		return nil, errors.ThrowInternal(err, "QUERY-mN0Ci", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
 func preparePasswordAgePolicyQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Row) (*PasswordAgePolicy, error)) {

internal/query/password_age_policy_test.go

@@ -52,7 +52,7 @@ func Test_PasswordAgePolicyPrepares(t *testing.T) {
 			name:    "preparePasswordAgePolicyQuery no result",
 			prepare: preparePasswordAgePolicyQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(preparePasswordAgePolicyStmt),
 					nil,
 					nil,
@@ -113,7 +113,7 @@ func Test_PasswordAgePolicyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*PasswordAgePolicy)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/password_complexity_policy.go

@@ -33,7 +33,7 @@ type PasswordComplexityPolicy struct {
 	IsDefault bool
 }
 
-func (q *Queries) PasswordComplexityPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (_ *PasswordComplexityPolicy, err error) {
+func (q *Queries) PasswordComplexityPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (policy *PasswordComplexityPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -59,11 +59,14 @@ func (q *Queries) PasswordComplexityPolicyByOrg(ctx context.Context, shouldTrigg
 		return nil, errors.ThrowInternal(err, "QUERY-lDnrk", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
-func (q *Queries) DefaultPasswordComplexityPolicy(ctx context.Context, shouldTriggerBulk bool) (_ *PasswordComplexityPolicy, err error) {
+func (q *Queries) DefaultPasswordComplexityPolicy(ctx context.Context, shouldTriggerBulk bool) (policy *PasswordComplexityPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -82,8 +85,11 @@ func (q *Queries) DefaultPasswordComplexityPolicy(ctx context.Context, shouldTri
 		return nil, errors.ThrowInternal(err, "QUERY-h4Uyr", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
 var (

internal/query/password_complexity_policy_test.go

@@ -58,7 +58,7 @@ func Test_PasswordComplexityPolicyPrepares(t *testing.T) {
 			name:    "preparePasswordComplexityPolicyQuery no result",
 			prepare: preparePasswordComplexityPolicyQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(preparePasswordComplexityPolicyStmt),
 					nil,
 					nil,
@@ -125,7 +125,7 @@ func Test_PasswordComplexityPolicyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*PasswordComplexityPolicy)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/prepare_test.go

@@ -15,6 +15,7 @@ import (
 	sq "github.com/Masterminds/squirrel"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/zitadel/zitadel/internal/database"
 )
 
 var (
@@ -53,14 +54,15 @@ func assertPrepare(t *testing.T, prepareFunc, expectedObject interface{}, sqlExp
 		}
 		return isErr(err)
 	}
-	object, ok := execScan(client, builder, scan, errCheck)
+	object, ok, didScan := execScan(&database.DB{DB: client}, builder, scan, errCheck)
 	if !ok {
 		t.Error(object)
 		return false
 	}
-
-	if !assert.Equal(t, expectedObject, object) {
-		return false
+	if didScan {
+		if !assert.Equal(t, expectedObject, object) {
+			return false
+		}
 	}
 
 	if err := mock.ExpectationsWereMet(); err != nil {
@@ -77,7 +79,23 @@ type sqlExpectation func(sqlmock.Sqlmock) sqlmock.Sqlmock
 
 func mockQuery(stmt string, cols []string, row []driver.Value, args ...driver.Value) func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
 	return func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
+		m.ExpectBegin()
 		q := m.ExpectQuery(stmt).WithArgs(args...)
+		m.ExpectCommit()
+		result := sqlmock.NewRows(cols)
+		if len(row) > 0 {
+			result.AddRow(row...)
+		}
+		q.WillReturnRows(result)
+		return m
+	}
+}
+
+func mockQueryScanErr(stmt string, cols []string, row []driver.Value, args ...driver.Value) func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
+	return func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
+		m.ExpectBegin()
+		q := m.ExpectQuery(stmt).WithArgs(args...)
+		m.ExpectRollback()
 		result := sqlmock.NewRows(cols)
 		if len(row) > 0 {
 			result.AddRow(row...)
@@ -89,7 +107,28 @@ func mockQuery(stmt string, cols []string, row []driver.Value, args ...driver.Va
 
 func mockQueries(stmt string, cols []string, rows [][]driver.Value, args ...driver.Value) func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
 	return func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
+		m.ExpectBegin()
 		q := m.ExpectQuery(stmt).WithArgs(args...)
+		m.ExpectCommit()
+		result := sqlmock.NewRows(cols)
+		count := uint64(len(rows))
+		for _, row := range rows {
+			if cols[len(cols)-1] == "count" {
+				row = append(row, count)
+			}
+			result.AddRow(row...)
+		}
+		q.WillReturnRows(result)
+		q.RowsWillBeClosed()
+		return m
+	}
+}
+
+func mockQueriesScanErr(stmt string, cols []string, rows [][]driver.Value, args ...driver.Value) func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
+	return func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
+		m.ExpectBegin()
+		q := m.ExpectQuery(stmt).WithArgs(args...)
+		m.ExpectRollback()
 		result := sqlmock.NewRows(cols)
 		count := uint64(len(rows))
 		for _, row := range rows {
@@ -106,8 +145,10 @@ func mockQueries(stmt string, cols []string, rows [][]driver.Value, args ...driv
 
 func mockQueryErr(stmt string, err error, args ...driver.Value) func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
 	return func(m sqlmock.Sqlmock) sqlmock.Sqlmock {
+		m.ExpectBegin()
 		q := m.ExpectQuery(stmt).WithArgs(args...)
 		q.WillReturnError(err)
+		m.ExpectRollback()
 		return m
 	}
 }
@@ -127,52 +168,65 @@ var (
 	selectBuilderType = reflect.TypeOf(sq.SelectBuilder{})
 )
 
-func execScan(client *sql.DB, builder sq.SelectBuilder, scan interface{}, errCheck checkErr) (interface{}, bool) {
+func execScan(client *database.DB, builder sq.SelectBuilder, scan interface{}, errCheck checkErr) (object interface{}, ok bool, didScan bool) {
 	scanType := reflect.TypeOf(scan)
 	err := validateScan(scanType)
 	if err != nil {
-		return err, false
+		return err, false, false
 	}
 
 	stmt, args, err := builder.ToSql()
 	if err != nil {
-		return fmt.Errorf("unexpeted error from sql builder: %w", err), false
+		return fmt.Errorf("unexpeted error from sql builder: %w", err), false, false
 	}
 
 	//resultSet represents *sql.Row or *sql.Rows,
 	// depending on whats assignable to the scan function
-	var resultSet interface{}
+	var res []reflect.Value
 
 	//execute sql stmt
 	// if scan(*sql.Rows)...
 	if scanType.In(0).AssignableTo(rowsType) {
-		resultSet, err = client.Query(stmt, args...)
-		if err != nil {
-			return errCheck(err)
-		}
+		err = client.Query(func(rows *sql.Rows) error {
+			didScan = true
+			res = reflect.ValueOf(scan).Call([]reflect.Value{reflect.ValueOf(rows)})
+			if err, ok := res[1].Interface().(error); ok {
+				return err
+			}
+			return nil
+		}, stmt, args...)
 
 		// if scan(*sql.Row)...
 	} else if scanType.In(0).AssignableTo(rowType) {
-		row := client.QueryRow(stmt, args...)
-		if row.Err() != nil {
-			return errCheck(row.Err())
-		}
-		resultSet = row
+		err = client.QueryRow(func(r *sql.Row) error {
+			didScan = true
+			res = reflect.ValueOf(scan).Call([]reflect.Value{reflect.ValueOf(r)})
+			if err, ok := res[1].Interface().(error); ok {
+				return err
+			}
+			return nil
+		}, stmt, args...)
+
 	} else {
-		return errors.New("scan: parameter must be *sql.Row or *sql.Rows"), false
+		return errors.New("scan: parameter must be *sql.Row or *sql.Rows"), false, false
 	}
 
-	// res contains object and error
-	res := reflect.ValueOf(scan).Call([]reflect.Value{reflect.ValueOf(resultSet)})
+	if err != nil {
+		err, ok := errCheck(err)
+		if didScan {
+			return res[0].Interface(), ok, didScan
+		}
+		return err, ok, didScan
+	}
 
 	//check for error
 	if res[1].Interface() != nil {
 		if err, ok := errCheck(res[1].Interface().(error)); !ok {
-			return fmt.Errorf("scan failed: %w", err), false
+			return fmt.Errorf("scan failed: %w", err), false, didScan
 		}
 	}
 
-	return res[0].Interface(), true
+	return res[0].Interface(), true, didScan
 }
 
 func validateScan(scanType reflect.Type) error {

internal/query/privacy_policy.go

@@ -91,7 +91,7 @@ var (
 	}
 )
 
-func (q *Queries) PrivacyPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (_ *PrivacyPolicy, err error) {
+func (q *Queries) PrivacyPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (policy *PrivacyPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -116,11 +116,14 @@ func (q *Queries) PrivacyPolicyByOrg(ctx context.Context, shouldTriggerBulk bool
 		return nil, errors.ThrowInternal(err, "QUERY-UXuPI", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
-func (q *Queries) DefaultPrivacyPolicy(ctx context.Context, shouldTriggerBulk bool) (_ *PrivacyPolicy, err error) {
+func (q *Queries) DefaultPrivacyPolicy(ctx context.Context, shouldTriggerBulk bool) (policy *PrivacyPolicy, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -139,8 +142,11 @@ func (q *Queries) DefaultPrivacyPolicy(ctx context.Context, shouldTriggerBulk bo
 		return nil, errors.ThrowInternal(err, "QUERY-LkFZ7", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
 func preparePrivacyPolicyQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Row) (*PrivacyPolicy, error)) {

internal/query/privacy_policy_test.go

@@ -56,7 +56,7 @@ func Test_PrivacyPolicyPrepares(t *testing.T) {
 			name:    "preparePrivacyPolicyQuery no result",
 			prepare: preparePrivacyPolicyQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(preparePrivacyPolicyStmt),
 					nil,
 					nil,
@@ -121,7 +121,7 @@ func Test_PrivacyPolicyPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*PrivacyPolicy)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/project.go

@@ -100,7 +100,7 @@ type ProjectSearchQueries struct {
 	Queries []SearchQuery
 }
 
-func (q *Queries) ProjectByID(ctx context.Context, shouldTriggerBulk bool, id string, withOwnerRemoved bool) (_ *Project, err error) {
+func (q *Queries) ProjectByID(ctx context.Context, shouldTriggerBulk bool, id string, withOwnerRemoved bool) (project *Project, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -121,8 +121,11 @@ func (q *Queries) ProjectByID(ctx context.Context, shouldTriggerBulk bool, id st
 		return nil, errors.ThrowInternal(err, "QUERY-2m00Q", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		project, err = scan(row)
+		return err
+	}, query, args...)
+	return project, err
 }
 
 func (q *Queries) SearchProjects(ctx context.Context, queries *ProjectSearchQueries, withOwnerRemoved bool) (projects *Projects, err error) {
@@ -139,14 +142,13 @@ func (q *Queries) SearchProjects(ctx context.Context, queries *ProjectSearchQuer
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-fn9ew", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		projects, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-2j00f", "Errors.Internal")
 	}
-	projects, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
 	projects.LatestSequence, err = q.latestSequence(ctx, projectsTable)
 	return projects, err
 }

internal/query/project_grant.go

@@ -111,7 +111,7 @@ type ProjectGrantSearchQueries struct {
 	Queries []SearchQuery
 }
 
-func (q *Queries) ProjectGrantByID(ctx context.Context, shouldTriggerBulk bool, id string, withOwnerRemoved bool) (_ *ProjectGrant, err error) {
+func (q *Queries) ProjectGrantByID(ctx context.Context, shouldTriggerBulk bool, id string, withOwnerRemoved bool) (grant *ProjectGrant, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -133,11 +133,14 @@ func (q *Queries) ProjectGrantByID(ctx context.Context, shouldTriggerBulk bool,
 		return nil, errors.ThrowInternal(err, "QUERY-Nf93d", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		grant, err = scan(row)
+		return err
+	}, query, args...)
+	return grant, err
 }
 
-func (q *Queries) ProjectGrantByIDAndGrantedOrg(ctx context.Context, id, grantedOrg string, withOwnerRemoved bool) (_ *ProjectGrant, err error) {
+func (q *Queries) ProjectGrantByIDAndGrantedOrg(ctx context.Context, id, grantedOrg string, withOwnerRemoved bool) (grant *ProjectGrant, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -156,11 +159,14 @@ func (q *Queries) ProjectGrantByIDAndGrantedOrg(ctx context.Context, id, granted
 		return nil, errors.ThrowInternal(err, "QUERY-MO9fs", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		grant, err = scan(row)
+		return err
+	}, query, args...)
+	return grant, err
 }
 
-func (q *Queries) SearchProjectGrants(ctx context.Context, queries *ProjectGrantSearchQueries, withOwnerRemoved bool) (projects *ProjectGrants, err error) {
+func (q *Queries) SearchProjectGrants(ctx context.Context, queries *ProjectGrantSearchQueries, withOwnerRemoved bool) (grants *ProjectGrants, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -177,16 +183,16 @@ func (q *Queries) SearchProjectGrants(ctx context.Context, queries *ProjectGrant
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-N9fsg", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		grants, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-PP02n", "Errors.Internal")
 	}
-	projects, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
-	projects.LatestSequence, err = q.latestSequence(ctx, projectGrantsTable)
-	return projects, err
+
+	grants.LatestSequence, err = q.latestSequence(ctx, projectGrantsTable)
+	return grants, err
 }
 
 func (q *Queries) SearchProjectGrantsByProjectIDAndRoleKey(ctx context.Context, projectID, roleKey string, withOwnerRemoved bool) (projects *ProjectGrants, err error) {

internal/query/project_grant_member.go

@@ -95,7 +95,7 @@ func addProjectGrantMemberWithoutOwnerRemoved(eq map[string]interface{}) {
 	eq[ProjectGrantMemberGrantedOrgRemoved.identifier()] = false
 }
 
-func (q *Queries) ProjectGrantMembers(ctx context.Context, queries *ProjectGrantMembersQuery, withOwnerRemoved bool) (*Members, error) {
+func (q *Queries) ProjectGrantMembers(ctx context.Context, queries *ProjectGrantMembersQuery, withOwnerRemoved bool) (members *Members, err error) {
 	query, scan := prepareProjectGrantMembersQuery(ctx, q.client)
 	eq := sq.Eq{ProjectGrantMemberInstanceID.identifier(): authz.GetInstance(ctx).InstanceID()}
 	if !withOwnerRemoved {
@@ -112,14 +112,14 @@ func (q *Queries) ProjectGrantMembers(ctx context.Context, queries *ProjectGrant
 		return nil, err
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		members, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-Pdg1I", "Errors.Internal")
 	}
-	members, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	members.LatestSequence = currentSequence
 	return members, err
 }

internal/query/project_grant_member_test.go

@@ -287,7 +287,7 @@ func Test_ProjectGrantMemberPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*ProjectGrantMembership)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/project_grant_test.go

@@ -381,13 +381,13 @@ func Test_ProjectGrantPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*ProjectGrants)(nil),
 		},
 		{
 			name:    "prepareProjectGrantQuery no result",
 			prepare: prepareProjectGrantQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					regexp.QuoteMeta(projectGrantQuery),
 					nil,
 					nil,
@@ -568,7 +568,7 @@ func Test_ProjectGrantPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*ProjectGrant)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/project_member.go

@@ -78,7 +78,7 @@ func addProjectMemberWithoutOwnerRemoved(eq map[string]interface{}) {
 	eq[ProjectMemberOwnerRemovedUser.identifier()] = false
 }
 
-func (q *Queries) ProjectMembers(ctx context.Context, queries *ProjectMembersQuery, withOwnerRemoved bool) (_ *Members, err error) {
+func (q *Queries) ProjectMembers(ctx context.Context, queries *ProjectMembersQuery, withOwnerRemoved bool) (members *Members, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -98,14 +98,14 @@ func (q *Queries) ProjectMembers(ctx context.Context, queries *ProjectMembersQue
 		return nil, err
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		members, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-uh6pj", "Errors.Internal")
 	}
-	members, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	members.LatestSequence = currentSequence
 	return members, err
 }

internal/query/project_member_test.go

@@ -284,7 +284,7 @@ func Test_ProjectMemberPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*ProjectMembership)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/project_role.go

@@ -83,7 +83,7 @@ type ProjectRoleSearchQueries struct {
 	Queries []SearchQuery
 }
 
-func (q *Queries) SearchProjectRoles(ctx context.Context, shouldTriggerBulk bool, queries *ProjectRoleSearchQueries, withOwnerRemoved bool) (projects *ProjectRoles, err error) {
+func (q *Queries) SearchProjectRoles(ctx context.Context, shouldTriggerBulk bool, queries *ProjectRoleSearchQueries, withOwnerRemoved bool) (roles *ProjectRoles, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -102,19 +102,18 @@ func (q *Queries) SearchProjectRoles(ctx context.Context, shouldTriggerBulk bool
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-3N9ff", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		roles, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-5Ngd9", "Errors.Internal")
 	}
-	projects, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
-	projects.LatestSequence, err = q.latestSequence(ctx, projectRolesTable)
-	return projects, err
+	roles.LatestSequence, err = q.latestSequence(ctx, projectRolesTable)
+	return roles, err
 }
 
-func (q *Queries) SearchGrantedProjectRoles(ctx context.Context, grantID, grantedOrg string, queries *ProjectRoleSearchQueries, withOwnerRemoved bool) (projects *ProjectRoles, err error) {
+func (q *Queries) SearchGrantedProjectRoles(ctx context.Context, grantID, grantedOrg string, queries *ProjectRoleSearchQueries, withOwnerRemoved bool) (roles *ProjectRoles, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -138,16 +137,16 @@ func (q *Queries) SearchGrantedProjectRoles(ctx context.Context, grantID, grante
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-3N9ff", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		roles, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-5Ngd9", "Errors.Internal")
 	}
-	projects, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
-	projects.LatestSequence, err = q.latestSequence(ctx, projectRolesTable)
-	return projects, err
+
+	roles.LatestSequence, err = q.latestSequence(ctx, projectRolesTable)
+	return roles, err
 }
 
 func NewProjectRoleProjectIDSearchQuery(value string) (SearchQuery, error) {

internal/query/project_role_test.go

@@ -170,7 +170,7 @@ func Test_ProjectRolePrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*ProjectRoles)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/project_test.go

@@ -238,13 +238,13 @@ func Test_ProjectPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Projects)(nil),
 		},
 		{
 			name:    "prepareProjectQuery no result",
 			prepare: prepareProjectQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					prepareProjectStmt,
 					nil,
 					nil,
@@ -309,7 +309,7 @@ func Test_ProjectPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Project)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/secret_generator_test.go

@@ -234,13 +234,13 @@ func Test_SecretGeneratorsPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*SecretGenerators)(nil),
 		},
 		{
 			name:    "prepareSecretGeneratorQuery no result",
 			prepare: prepareSecretGeneratorQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					prepareSecretGeneratorStmt,
 					nil,
 					nil,
@@ -307,7 +307,7 @@ func Test_SecretGeneratorsPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*SecretGenerator)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/secret_generators.go

@@ -134,7 +134,7 @@ func (q *Queries) InitHashGenerator(ctx context.Context, generatorType domain.Se
 	return crypto.NewHashGenerator(cryptoConfig, algorithm), nil
 }
 
-func (q *Queries) SecretGeneratorByType(ctx context.Context, generatorType domain.SecretGeneratorType) (_ *SecretGenerator, err error) {
+func (q *Queries) SecretGeneratorByType(ctx context.Context, generatorType domain.SecretGeneratorType) (generator *SecretGenerator, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -147,8 +147,11 @@ func (q *Queries) SecretGeneratorByType(ctx context.Context, generatorType domai
 		return nil, errors.ThrowInternal(err, "QUERY-3k99f", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		generator, err = scan(row)
+		return err
+	}, query, args...)
+	return generator, err
 }
 
 func (q *Queries) SearchSecretGenerators(ctx context.Context, queries *SecretGeneratorSearchQueries) (secretGenerators *SecretGenerators, err error) {
@@ -164,14 +167,13 @@ func (q *Queries) SearchSecretGenerators(ctx context.Context, queries *SecretGen
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-sn9lw", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		secretGenerators, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-4miii", "Errors.Internal")
 	}
-	secretGenerators, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
 	secretGenerators.LatestSequence, err = q.latestSequence(ctx, secretGeneratorsTable)
 	return secretGenerators, err
 }

internal/query/security_policy.go

@@ -57,7 +57,7 @@ type SecurityPolicy struct {
 	AllowedOrigins database.StringArray
 }
 
-func (q *Queries) SecurityPolicy(ctx context.Context) (*SecurityPolicy, error) {
+func (q *Queries) SecurityPolicy(ctx context.Context) (policy *SecurityPolicy, err error) {
 	stmt, scan := prepareSecurityPolicyQuery(ctx, q.client)
 	query, args, err := stmt.Where(sq.Eq{
 		SecurityPolicyColumnInstanceID.identifier(): authz.GetInstance(ctx).InstanceID(),
@@ -66,8 +66,11 @@ func (q *Queries) SecurityPolicy(ctx context.Context) (*SecurityPolicy, error) {
 		return nil, errors.ThrowInternal(err, "QUERY-Sf6d1", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		policy, err = scan(row)
+		return err
+	}, query, args...)
+	return policy, err
 }
 
 func prepareSecurityPolicyQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Row) (*SecurityPolicy, error)) {

internal/query/session.go

@@ -151,7 +151,7 @@ var (
 	}
 )
 
-func (q *Queries) SessionByID(ctx context.Context, shouldTriggerBulk bool, id, sessionToken string) (_ *Session, err error) {
+func (q *Queries) SessionByID(ctx context.Context, shouldTriggerBulk bool, id, sessionToken string) (session *Session, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -170,8 +170,11 @@ func (q *Queries) SessionByID(ctx context.Context, shouldTriggerBulk bool, id, s
 		return nil, errors.ThrowInternal(err, "QUERY-dn9JW", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	session, tokenID, err := scan(row)
+	var tokenID string
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		session, tokenID, err = scan(row)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -184,7 +187,7 @@ func (q *Queries) SessionByID(ctx context.Context, shouldTriggerBulk bool, id, s
 	return session, nil
 }
 
-func (q *Queries) SearchSessions(ctx context.Context, queries *SessionsSearchQueries) (_ *Sessions, err error) {
+func (q *Queries) SearchSessions(ctx context.Context, queries *SessionsSearchQueries) (sessions *Sessions, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -197,14 +200,14 @@ func (q *Queries) SearchSessions(ctx context.Context, queries *SessionsSearchQue
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-sn9Jf", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
-	if err != nil || rows.Err() != nil {
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		sessions, err = scan(rows)
+		return err
+	}, stmt, args...)
+	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-Sfg42", "Errors.Internal")
 	}
-	sessions, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	sessions.LatestSequence, err = q.latestSequence(ctx, sessionsTable)
 	return sessions, err
 }

internal/query/sessions_test.go

@@ -343,7 +343,7 @@ func Test_SessionsPrepare(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Sessions)(nil),
 		},
 	}
 	for _, tt := range tests {
@@ -368,7 +368,7 @@ func Test_SessionPrepare(t *testing.T) {
 			name:    "prepareSessionQuery no result",
 			prepare: prepareSessionQueryTesting(t, ""),
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					expectedSessionQuery,
 					nil,
 					nil,
@@ -460,7 +460,7 @@ func Test_SessionPrepare(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Session)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/sms.go

@@ -115,7 +115,7 @@ var (
 	}
 )
 
-func (q *Queries) SMSProviderConfigByID(ctx context.Context, id string) (_ *SMSConfig, err error) {
+func (q *Queries) SMSProviderConfigByID(ctx context.Context, id string) (config *SMSConfig, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -130,11 +130,14 @@ func (q *Queries) SMSProviderConfigByID(ctx context.Context, id string) (_ *SMSC
 		return nil, errors.ThrowInternal(err, "QUERY-dn9JW", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		config, err = scan(row)
+		return err
+	}, stmt, args...)
+	return config, err
 }
 
-func (q *Queries) SMSProviderConfig(ctx context.Context, queries ...SearchQuery) (_ *SMSConfig, err error) {
+func (q *Queries) SMSProviderConfig(ctx context.Context, queries ...SearchQuery) (config *SMSConfig, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -151,11 +154,14 @@ func (q *Queries) SMSProviderConfig(ctx context.Context, queries ...SearchQuery)
 		return nil, errors.ThrowInternal(err, "QUERY-dn9JW", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		config, err = scan(row)
+		return err
+	}, stmt, args...)
+	return config, err
 }
 
-func (q *Queries) SearchSMSConfigs(ctx context.Context, queries *SMSConfigsSearchQueries) (_ *SMSConfigs, err error) {
+func (q *Queries) SearchSMSConfigs(ctx context.Context, queries *SMSConfigsSearchQueries) (configs *SMSConfigs, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -168,16 +174,15 @@ func (q *Queries) SearchSMSConfigs(ctx context.Context, queries *SMSConfigsSearc
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-sn9Jf", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		configs, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-aJnZL", "Errors.Internal")
 	}
-	apps, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
-	apps.LatestSequence, err = q.latestSequence(ctx, smsConfigsTable)
-	return apps, err
+	configs.LatestSequence, err = q.latestSequence(ctx, smsConfigsTable)
+	return configs, err
 }
 
 func NewSMSProviderStateQuery(state domain.SMSConfigState) (SearchQuery, error) {

internal/query/sms_test.go

@@ -225,7 +225,7 @@ func Test_SMSConfigssPrepare(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*SMSConfigs)(nil),
 		},
 	}
 	for _, tt := range tests {
@@ -250,7 +250,7 @@ func Test_SMSConfigPrepare(t *testing.T) {
 			name:    "prepareSMSConfigQuery no result",
 			prepare: prepareSMSConfigQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					expectedSMSConfigQuery,
 					nil,
 					nil,
@@ -317,7 +317,7 @@ func Test_SMSConfigPrepare(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*SMSConfig)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/smtp.go

@@ -91,7 +91,7 @@ type SMTPConfig struct {
 	Password      *crypto.CryptoValue
 }
 
-func (q *Queries) SMTPConfigByAggregateID(ctx context.Context, aggregateID string) (_ *SMTPConfig, err error) {
+func (q *Queries) SMTPConfigByAggregateID(ctx context.Context, aggregateID string) (config *SMTPConfig, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -104,8 +104,11 @@ func (q *Queries) SMTPConfigByAggregateID(ctx context.Context, aggregateID strin
 		return nil, errors.ThrowInternal(err, "QUERY-3m9sl", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, query, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		config, err = scan(row)
+		return err
+	}, query, args...)
+	return config, err
 }
 
 func prepareSMTPConfigQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Row) (*SMTPConfig, error)) {

internal/query/smtp_test.go

@@ -56,7 +56,7 @@ func Test_SMTPConfigsPrepares(t *testing.T) {
 			name:    "prepareSMTPConfigQuery no result",
 			prepare: prepareSMTPConfigQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					prepareSMTPConfigStmt,
 					nil,
 					nil,
@@ -121,7 +121,7 @@ func Test_SMTPConfigsPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*SMTPConfig)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/user.go

@@ -333,7 +333,7 @@ func addUserWithoutOwnerRemoved(eq map[string]interface{}) {
 	eq[userPreferredLoginNameOwnerRemovedDomainCol.identifier()] = false
 }
 
-func (q *Queries) GetUserByID(ctx context.Context, shouldTriggerBulk bool, userID string, withOwnerRemoved bool, queries ...SearchQuery) (_ *User, err error) {
+func (q *Queries) GetUserByID(ctx context.Context, shouldTriggerBulk bool, userID string, withOwnerRemoved bool, queries ...SearchQuery) (user *User, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -358,11 +358,14 @@ func (q *Queries) GetUserByID(ctx context.Context, shouldTriggerBulk bool, userI
 		return nil, errors.ThrowInternal(err, "QUERY-FBg21", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		user, err = scan(row)
+		return err
+	}, stmt, args...)
+	return user, err
 }
 
-func (q *Queries) GetUser(ctx context.Context, shouldTriggerBulk bool, withOwnerRemoved bool, queries ...SearchQuery) (_ *User, err error) {
+func (q *Queries) GetUser(ctx context.Context, shouldTriggerBulk bool, withOwnerRemoved bool, queries ...SearchQuery) (user *User, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -386,11 +389,14 @@ func (q *Queries) GetUser(ctx context.Context, shouldTriggerBulk bool, withOwner
 		return nil, errors.ThrowInternal(err, "QUERY-Dnhr2", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		user, err = scan(row)
+		return err
+	}, stmt, args...)
+	return user, err
 }
 
-func (q *Queries) GetHumanProfile(ctx context.Context, userID string, withOwnerRemoved bool, queries ...SearchQuery) (_ *Profile, err error) {
+func (q *Queries) GetHumanProfile(ctx context.Context, userID string, withOwnerRemoved bool, queries ...SearchQuery) (profile *Profile, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -410,11 +416,14 @@ func (q *Queries) GetHumanProfile(ctx context.Context, userID string, withOwnerR
 		return nil, errors.ThrowInternal(err, "QUERY-Dgbg2", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		profile, err = scan(row)
+		return err
+	}, stmt, args...)
+	return profile, err
 }
 
-func (q *Queries) GetHumanEmail(ctx context.Context, userID string, withOwnerRemoved bool, queries ...SearchQuery) (_ *Email, err error) {
+func (q *Queries) GetHumanEmail(ctx context.Context, userID string, withOwnerRemoved bool, queries ...SearchQuery) (email *Email, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -434,11 +443,14 @@ func (q *Queries) GetHumanEmail(ctx context.Context, userID string, withOwnerRem
 		return nil, errors.ThrowInternal(err, "QUERY-BHhj3", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		email, err = scan(row)
+		return err
+	}, stmt, args...)
+	return email, err
 }
 
-func (q *Queries) GetHumanPhone(ctx context.Context, userID string, withOwnerRemoved bool, queries ...SearchQuery) (_ *Phone, err error) {
+func (q *Queries) GetHumanPhone(ctx context.Context, userID string, withOwnerRemoved bool, queries ...SearchQuery) (phone *Phone, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -458,11 +470,14 @@ func (q *Queries) GetHumanPhone(ctx context.Context, userID string, withOwnerRem
 		return nil, errors.ThrowInternal(err, "QUERY-Dg43g", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		phone, err = scan(row)
+		return err
+	}, stmt, args...)
+	return phone, err
 }
 
-func (q *Queries) GetNotifyUserByID(ctx context.Context, shouldTriggered bool, userID string, withOwnerRemoved bool, queries ...SearchQuery) (_ *NotifyUser, err error) {
+func (q *Queries) GetNotifyUserByID(ctx context.Context, shouldTriggered bool, userID string, withOwnerRemoved bool, queries ...SearchQuery) (user *NotifyUser, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -487,11 +502,14 @@ func (q *Queries) GetNotifyUserByID(ctx context.Context, shouldTriggered bool, u
 		return nil, errors.ThrowInternal(err, "QUERY-Err3g", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		user, err = scan(row)
+		return err
+	}, stmt, args...)
+	return user, err
 }
 
-func (q *Queries) GetNotifyUser(ctx context.Context, shouldTriggered bool, withOwnerRemoved bool, queries ...SearchQuery) (_ *NotifyUser, err error) {
+func (q *Queries) GetNotifyUser(ctx context.Context, shouldTriggered bool, withOwnerRemoved bool, queries ...SearchQuery) (user *NotifyUser, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -515,11 +533,14 @@ func (q *Queries) GetNotifyUser(ctx context.Context, shouldTriggered bool, withO
 		return nil, errors.ThrowInternal(err, "QUERY-Err3g", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		user, err = scan(row)
+		return err
+	}, stmt, args...)
+	return user, err
 }
 
-func (q *Queries) SearchUsers(ctx context.Context, queries *UserSearchQueries, withOwnerRemoved bool) (_ *Users, err error) {
+func (q *Queries) SearchUsers(ctx context.Context, queries *UserSearchQueries, withOwnerRemoved bool) (users *Users, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -534,19 +555,19 @@ func (q *Queries) SearchUsers(ctx context.Context, queries *UserSearchQueries, w
 		return nil, errors.ThrowInternal(err, "QUERY-Dgbg2", "Errors.Query.SQLStatment")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		users, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-AG4gs", "Errors.Internal")
 	}
-	users, err := scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	users.LatestSequence, err = q.latestSequence(ctx, userTable)
 	return users, err
 }
 
-func (q *Queries) IsUserUnique(ctx context.Context, username, email, resourceOwner string, withOwnerRemoved bool) (_ bool, err error) {
+func (q *Queries) IsUserUnique(ctx context.Context, username, email, resourceOwner string, withOwnerRemoved bool) (isUnique bool, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -584,8 +605,12 @@ func (q *Queries) IsUserUnique(ctx context.Context, username, email, resourceOwn
 	if err != nil {
 		return false, errors.ThrowInternal(err, "QUERY-Dg43g", "Errors.Query.SQLStatment")
 	}
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		isUnique, err = scan(row)
+		return err
+	}, stmt, args...)
+	return isUnique, err
 }
 
 func (q *UserSearchQueries) toQuery(query sq.SelectBuilder) sq.SelectBuilder {

internal/query/user_auth_method.go

@@ -130,11 +130,10 @@ func (q *Queries) SearchUserAuthMethods(ctx context.Context, queries *UserAuthMe
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-j9NJd", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "QUERY-3n99f", "Errors.Internal")
-	}
-	userAuthMethods, err = scan(rows)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		userAuthMethods, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -165,11 +164,10 @@ func (q *Queries) ListActiveUserAuthMethodTypes(ctx context.Context, userID stri
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-Sfdrg", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
-	if err != nil || rows.Err() != nil {
-		return nil, errors.ThrowInternal(err, "QUERY-SDgr3", "Errors.Internal")
-	}
-	userAuthMethodTypes, err = scan(rows)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		userAuthMethodTypes, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -200,11 +198,14 @@ func (q *Queries) ListUserAuthMethodTypesRequired(ctx context.Context, userID st
 		return nil, false, false, errors.ThrowInvalidArgument(err, "QUERY-E5ut4", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
-	if err != nil || rows.Err() != nil {
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		userAuthMethodTypes, forceMFA, forceMFALocalOnly, err = scan(rows)
+		return err
+	}, stmt, args...)
+	if err != nil {
 		return nil, false, false, errors.ThrowInternal(err, "QUERY-Dun75", "Errors.Internal")
 	}
-	return scan(rows)
+	return userAuthMethodTypes, forceMFA, forceMFALocalOnly, nil
 }
 
 func NewUserAuthMethodUserIDSearchQuery(value string) (SearchQuery, error) {

internal/query/user_auth_method_test.go

@@ -224,7 +224,7 @@ func Test_UserAuthMethodPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*AuthMethodTypes)(nil),
 		},
 		{
 			name:    "prepareActiveUserAuthMethodTypesQuery no result",
@@ -313,7 +313,7 @@ func Test_UserAuthMethodPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*AuthMethodTypes)(nil),
 		},
 		{
 			name: "prepareUserAuthMethodTypesRequiredQuery no result",

internal/query/user_grant.go

@@ -232,7 +232,7 @@ func addUserGrantWithoutOwnerRemoved(eq map[string]interface{}) {
 	addLoginNameWithoutOwnerRemoved(eq)
 }
 
-func (q *Queries) UserGrant(ctx context.Context, shouldTriggerBulk bool, withOwnerRemoved bool, queries ...SearchQuery) (_ *UserGrant, err error) {
+func (q *Queries) UserGrant(ctx context.Context, shouldTriggerBulk bool, withOwnerRemoved bool, queries ...SearchQuery) (grant *UserGrant, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -253,11 +253,14 @@ func (q *Queries) UserGrant(ctx context.Context, shouldTriggerBulk bool, withOwn
 		return nil, errors.ThrowInternal(err, "QUERY-Fa1KW", "Errors.Query.SQLStatement")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		grant, err = scan(row)
+		return err
+	}, stmt, args...)
+	return grant, err
 }
 
-func (q *Queries) UserGrants(ctx context.Context, queries *UserGrantsQueries, shouldTriggerBulk, withOwnerRemoved bool) (_ *UserGrants, err error) {
+func (q *Queries) UserGrants(ctx context.Context, queries *UserGrantsQueries, shouldTriggerBulk, withOwnerRemoved bool) (grants *UserGrants, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -280,11 +283,10 @@ func (q *Queries) UserGrants(ctx context.Context, queries *UserGrantsQueries, sh
 		return nil, err
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
-	if err != nil {
-		return nil, err
-	}
-	grants, err := scan(rows)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		grants, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}

internal/query/user_grant_test.go

@@ -122,7 +122,7 @@ func Test_UserGrantPrepares(t *testing.T) {
 			name:    "prepareUserGrantQuery no result",
 			prepare: prepareUserGrantQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQueriesScanErr(
 					userGrantStmt,
 					nil,
 					nil,
@@ -441,7 +441,7 @@ func Test_UserGrantPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*UserGrant)(nil),
 		},
 		{
 			name:    "prepareUserGrantsQuery no result",
@@ -920,7 +920,7 @@ func Test_UserGrantPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*UserGrants)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/user_membership.go

@@ -105,7 +105,7 @@ func (q *MembershipSearchQuery) toQuery(query sq.SelectBuilder) sq.SelectBuilder
 	return query
 }
 
-func (q *Queries) Memberships(ctx context.Context, queries *MembershipSearchQuery, withOwnerRemoved bool) (_ *Memberships, err error) {
+func (q *Queries) Memberships(ctx context.Context, queries *MembershipSearchQuery, withOwnerRemoved bool) (memberships *Memberships, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -121,11 +121,10 @@ func (q *Queries) Memberships(ctx context.Context, queries *MembershipSearchQuer
 	}
 	queryArgs = append(queryArgs, args...)
 
-	rows, err := q.client.QueryContext(ctx, stmt, queryArgs...)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "QUERY-eAV2x", "Errors.Internal")
-	}
-	memberships, err := scan(rows)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		memberships, err = scan(rows)
+		return err
+	}, stmt, queryArgs...)
 	if err != nil {
 		return nil, err
 	}

internal/query/user_membership_test.go

@@ -444,7 +444,7 @@ func Test_MembershipPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Memberships)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/user_metadata.go

@@ -77,7 +77,7 @@ var (
 	}
 )
 
-func (q *Queries) GetUserMetadataByKey(ctx context.Context, shouldTriggerBulk bool, userID, key string, withOwnerRemoved bool, queries ...SearchQuery) (_ *UserMetadata, err error) {
+func (q *Queries) GetUserMetadataByKey(ctx context.Context, shouldTriggerBulk bool, userID, key string, withOwnerRemoved bool, queries ...SearchQuery) (metadata *UserMetadata, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -102,11 +102,14 @@ func (q *Queries) GetUserMetadataByKey(ctx context.Context, shouldTriggerBulk bo
 		return nil, errors.ThrowInternal(err, "QUERY-aDGG2", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		metadata, err = scan(row)
+		return err
+	}, stmt, args...)
+	return metadata, err
 }
 
-func (q *Queries) SearchUserMetadata(ctx context.Context, shouldTriggerBulk bool, userID string, queries *UserMetadataSearchQueries, withOwnerRemoved bool) (_ *UserMetadataList, err error) {
+func (q *Queries) SearchUserMetadata(ctx context.Context, shouldTriggerBulk bool, userID string, queries *UserMetadataSearchQueries, withOwnerRemoved bool) (metadata *UserMetadataList, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -127,11 +130,10 @@ func (q *Queries) SearchUserMetadata(ctx context.Context, shouldTriggerBulk bool
 		return nil, errors.ThrowInternal(err, "QUERY-Egbgd", "Errors.Query.SQLStatment")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "QUERY-Hr2wf", "Errors.Internal")
-	}
-	metadata, err := scan(rows)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		metadata, err = scan(rows)
+		return err
+	}, stmt, args...)
 	if err != nil {
 		return nil, err
 	}

internal/query/user_metadata_test.go

@@ -62,7 +62,7 @@ func Test_UserMetadataPrepares(t *testing.T) {
 			name:    "prepareUserMetadataQuery no result",
 			prepare: prepareUserMetadataQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(userMetadataQuery),
 					nil,
 					nil,
@@ -117,7 +117,7 @@ func Test_UserMetadataPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*UserMetadata)(nil),
 		},
 		{
 			name:    "prepareUserMetadataListQuery no result",
@@ -238,7 +238,7 @@ func Test_UserMetadataPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*UserMetadataList)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/user_personal_access_token.go

@@ -85,7 +85,7 @@ type PersonalAccessTokenSearchQueries struct {
 	Queries []SearchQuery
 }
 
-func (q *Queries) PersonalAccessTokenByID(ctx context.Context, shouldTriggerBulk bool, id string, withOwnerRemoved bool, queries ...SearchQuery) (_ *PersonalAccessToken, err error) {
+func (q *Queries) PersonalAccessTokenByID(ctx context.Context, shouldTriggerBulk bool, id string, withOwnerRemoved bool, queries ...SearchQuery) (pat *PersonalAccessToken, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
@@ -109,8 +109,14 @@ func (q *Queries) PersonalAccessTokenByID(ctx context.Context, shouldTriggerBulk
 		return nil, errors.ThrowInternal(err, "QUERY-Dgfb4", "Errors.Query.SQLStatment")
 	}
 
-	row := q.client.QueryRowContext(ctx, stmt, args...)
-	return scan(row)
+	err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
+		pat, err = scan(row)
+		return err
+	}, stmt, args...)
+	if err != nil {
+		return nil, err
+	}
+	return pat, nil
 }
 
 func (q *Queries) SearchPersonalAccessTokens(ctx context.Context, queries *PersonalAccessTokenSearchQueries, withOwnerRemoved bool) (personalAccessTokens *PersonalAccessTokens, err error) {
@@ -129,14 +135,15 @@ func (q *Queries) SearchPersonalAccessTokens(ctx context.Context, queries *Perso
 		return nil, errors.ThrowInvalidArgument(err, "QUERY-Hjw2w", "Errors.Query.InvalidRequest")
 	}
 
-	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
+		personalAccessTokens, err = scan(rows)
+		return err
+
+	}, stmt, args...)
 	if err != nil {
 		return nil, errors.ThrowInternal(err, "QUERY-Bmz63", "Errors.Internal")
 	}
-	personalAccessTokens, err = scan(rows)
-	if err != nil {
-		return nil, err
-	}
+
 	personalAccessTokens.LatestSequence, err = q.latestSequence(ctx, personalAccessTokensTable)
 	return personalAccessTokens, err
 }

internal/query/user_personal_access_token_test.go

@@ -75,7 +75,7 @@ func Test_PersonalAccessTokenPrepares(t *testing.T) {
 			name:    "preparePersonalAccessTokenQuery no result",
 			prepare: preparePersonalAccessTokenQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					personalAccessTokenStmt,
 					nil,
 					nil,
@@ -134,7 +134,7 @@ func Test_PersonalAccessTokenPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*PersonalAccessToken)(nil),
 		},
 		{
 			name:    "preparePersonalAccessTokensQuery no result",
@@ -261,7 +261,7 @@ func Test_PersonalAccessTokenPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*PersonalAccessTokens)(nil),
 		},
 	}
 	for _, tt := range tests {

internal/query/user_test.go

@@ -333,7 +333,7 @@ func Test_UserPrepares(t *testing.T) {
 			name:    "prepareUserQuery no result",
 			prepare: prepareUserQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(userQuery),
 					nil,
 					nil,
@@ -489,13 +489,13 @@ func Test_UserPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*User)(nil),
 		},
 		{
 			name:    "prepareProfileQuery no result",
 			prepare: prepareProfileQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(profileQuery),
 					nil,
 					nil,
@@ -552,7 +552,7 @@ func Test_UserPrepares(t *testing.T) {
 			name:    "prepareProfileQuery not human found (error)",
 			prepare: prepareProfileQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(profileQuery),
 					profileCols,
 					[]driver.Value{
@@ -595,13 +595,13 @@ func Test_UserPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Profile)(nil),
 		},
 		{
 			name:    "prepareEmailQuery no result",
 			prepare: prepareEmailQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(emailQuery),
 					nil,
 					nil,
@@ -650,7 +650,7 @@ func Test_UserPrepares(t *testing.T) {
 			name:    "prepareEmailQuery not human found (error)",
 			prepare: prepareEmailQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(emailQuery),
 					emailCols,
 					[]driver.Value{
@@ -689,13 +689,13 @@ func Test_UserPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Email)(nil),
 		},
 		{
 			name:    "preparePhoneQuery no result",
 			prepare: preparePhoneQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(phoneQuery),
 					nil,
 					nil,
@@ -744,7 +744,7 @@ func Test_UserPrepares(t *testing.T) {
 			name:    "preparePhoneQuery not human found (error)",
 			prepare: preparePhoneQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(phoneQuery),
 					phoneCols,
 					[]driver.Value{
@@ -783,7 +783,7 @@ func Test_UserPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Phone)(nil),
 		},
 		{
 			name:    "prepareUserUniqueQuery no result",
@@ -837,13 +837,13 @@ func Test_UserPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: false,
 		},
 		{
 			name:    "prepareNotifyUserQuery no result",
 			prepare: prepareNotifyUserQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(notifyUserQuery),
 					nil,
 					nil,
@@ -924,7 +924,7 @@ func Test_UserPrepares(t *testing.T) {
 			name:    "prepareNotifyUserQuery not notify found (error)",
 			prepare: prepareNotifyUserQuery,
 			want: want{
-				sqlExpectations: mockQuery(
+				sqlExpectations: mockQueryScanErr(
 					regexp.QuoteMeta(notifyUserQuery),
 					notifyUserCols,
 					[]driver.Value{
@@ -980,13 +980,13 @@ func Test_UserPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*NotifyUser)(nil),
 		},
 		{
 			name:    "prepareUsersQuery no result",
 			prepare: prepareUsersQuery,
 			want: want{
-				sqlExpectations: mockQueries(
+				sqlExpectations: mockQuery(
 					regexp.QuoteMeta(usersQuery),
 					nil,
 					nil,
@@ -1214,7 +1214,7 @@ func Test_UserPrepares(t *testing.T) {
 					return nil, true
 				},
 			},
-			object: nil,
+			object: (*Users)(nil),
 		},
 	}
 	for _, tt := range tests {