From f432a1713becbc4ef3038f63c906da5d9ea21b94 Mon Sep 17 00:00:00 2001 From: Ryan McKinley Date: Fri, 16 Aug 2024 15:12:37 +0300 Subject: [PATCH] SQLTemplate: Swap the IFace with the concrete struct (#92008) --- pkg/registry/apis/dashboard/legacy/queries.go | 2 +- .../apis/dashboard/legacy/queries_test.go | 10 +- .../apis/dashboard/legacy/sql_dashboards.go | 4 +- .../apis/identity/legacy/legacy_sql.go | 14 +- pkg/registry/apis/identity/legacy/queries.go | 6 +- .../apis/identity/legacy/queries_test.go | 18 +- pkg/storage/unified/sql/backend.go | 112 ++++----- pkg/storage/unified/sql/dbutil/dbutil.go | 4 +- pkg/storage/unified/sql/dbutil/dbutil_test.go | 8 +- pkg/storage/unified/sql/queries.go | 16 +- pkg/storage/unified/sql/queries_test.go | 30 +-- pkg/storage/unified/sql/sqltemplate/args.go | 16 +- .../unified/sql/sqltemplate/args_test.go | 2 +- .../unified/sql/sqltemplate/example_test.go | 14 +- pkg/storage/unified/sql/sqltemplate/into.go | 12 +- .../unified/sql/sqltemplate/into_test.go | 2 +- .../sql/sqltemplate/mocks/SQLTemplateIface.go | 226 +++++++++--------- .../sql/sqltemplate/mocks/test_snapshots.go | 6 +- .../unified/sql/sqltemplate/sqltemplate.go | 40 ++-- 19 files changed, 271 insertions(+), 271 deletions(-) diff --git a/pkg/registry/apis/dashboard/legacy/queries.go b/pkg/registry/apis/dashboard/legacy/queries.go index af3af94b96e..38ebd4c67cd 100644 --- a/pkg/registry/apis/dashboard/legacy/queries.go +++ b/pkg/registry/apis/dashboard/legacy/queries.go @@ -29,7 +29,7 @@ var ( ) type sqlQuery struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate Query *DashboardQuery } diff --git a/pkg/registry/apis/dashboard/legacy/queries_test.go b/pkg/registry/apis/dashboard/legacy/queries_test.go index ca0c276bf95..2978c506e26 100644 --- a/pkg/registry/apis/dashboard/legacy/queries_test.go +++ b/pkg/registry/apis/dashboard/legacy/queries_test.go @@ -15,7 +15,7 @@ func TestQueries(t *testing.T) { { Name: "history_uid", Data: &sqlQuery{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &DashboardQuery{ OrgID: 2, UID: "UUU", @@ -25,7 +25,7 @@ func TestQueries(t *testing.T) { { Name: "history_uid_at_version", Data: &sqlQuery{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &DashboardQuery{ OrgID: 2, UID: "UUU", @@ -36,7 +36,7 @@ func TestQueries(t *testing.T) { { Name: "history_uid_second_page", Data: &sqlQuery{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &DashboardQuery{ OrgID: 2, UID: "UUU", @@ -47,7 +47,7 @@ func TestQueries(t *testing.T) { { Name: "dashboard", Data: &sqlQuery{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &DashboardQuery{ OrgID: 2, }, @@ -56,7 +56,7 @@ func TestQueries(t *testing.T) { { Name: "dashboard_next_page", Data: &sqlQuery{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &DashboardQuery{ OrgID: 2, LastID: 22, diff --git a/pkg/registry/apis/dashboard/legacy/sql_dashboards.go b/pkg/registry/apis/dashboard/legacy/sql_dashboards.go index 499930de6f7..93e6bbd401a 100644 --- a/pkg/registry/apis/dashboard/legacy/sql_dashboards.go +++ b/pkg/registry/apis/dashboard/legacy/sql_dashboards.go @@ -92,8 +92,8 @@ func (a *dashboardSqlAccess) getRows(ctx context.Context, query *DashboardQuery) } req := sqlQuery{ - SQLTemplateIface: sqltemplate.New(a.dialect), - Query: query, + SQLTemplate: sqltemplate.New(a.dialect), + Query: query, } tmpl := sqlQueryDashboards diff --git a/pkg/registry/apis/identity/legacy/legacy_sql.go b/pkg/registry/apis/identity/legacy/legacy_sql.go index 91cce7d61f0..22dab11ea25 100644 --- a/pkg/registry/apis/identity/legacy/legacy_sql.go +++ b/pkg/registry/apis/identity/legacy/legacy_sql.go @@ -55,8 +55,8 @@ func (s *legacySQLStore) ListTeams(ctx context.Context, ns claims.NamespaceInfo, } req := sqlQueryListTeams{ - SQLTemplateIface: sqltemplate.New(s.dialect), - Query: &query, + SQLTemplate: sqltemplate.New(s.dialect), + Query: &query, } rawQuery, err := sqltemplate.Execute(sqlQueryTeams, req) @@ -117,12 +117,12 @@ func (s *legacySQLStore) ListUsers(ctx context.Context, ns claims.NamespaceInfo, } return s.queryUsers(ctx, sqlQueryUsers, sqlQueryListUsers{ - SQLTemplateIface: sqltemplate.New(s.dialect), - Query: &query, + SQLTemplate: sqltemplate.New(s.dialect), + Query: &query, }, limit, query.UID != "") } -func (s *legacySQLStore) queryUsers(ctx context.Context, t *template.Template, req sqltemplate.ArgsIface, limit int, getRV bool) (*ListUserResult, error) { +func (s *legacySQLStore) queryUsers(ctx context.Context, t *template.Template, req sqltemplate.Args, limit int, getRV bool) (*ListUserResult, error) { rawQuery, err := sqltemplate.Execute(t, req) if err != nil { return nil, fmt.Errorf("execute template %q: %w", sqlQueryUsers.Name(), err) @@ -180,7 +180,7 @@ func (s *legacySQLStore) GetDisplay(ctx context.Context, ns claims.NamespaceInfo } return s.queryUsers(ctx, sqlQueryDisplay, sqlQueryGetDisplay{ - SQLTemplateIface: sqltemplate.New(s.dialect), - Query: &query, + SQLTemplate: sqltemplate.New(s.dialect), + Query: &query, }, 10000, false) } diff --git a/pkg/registry/apis/identity/legacy/queries.go b/pkg/registry/apis/identity/legacy/queries.go index 55bdd20e32c..98a7468719d 100644 --- a/pkg/registry/apis/identity/legacy/queries.go +++ b/pkg/registry/apis/identity/legacy/queries.go @@ -31,7 +31,7 @@ var ( ) type sqlQueryListUsers struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate Query *ListUserQuery } @@ -40,7 +40,7 @@ func (r sqlQueryListUsers) Validate() error { } type sqlQueryListTeams struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate Query *ListTeamQuery } @@ -49,7 +49,7 @@ func (r sqlQueryListTeams) Validate() error { } type sqlQueryGetDisplay struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate Query *GetUserDisplayQuery } diff --git a/pkg/registry/apis/identity/legacy/queries_test.go b/pkg/registry/apis/identity/legacy/queries_test.go index e49e36082f2..5c4b57e0c39 100644 --- a/pkg/registry/apis/identity/legacy/queries_test.go +++ b/pkg/registry/apis/identity/legacy/queries_test.go @@ -15,7 +15,7 @@ func TestQueries(t *testing.T) { { Name: "teams_uid", Data: &sqlQueryListTeams{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &ListTeamQuery{ UID: "abc", }, @@ -24,7 +24,7 @@ func TestQueries(t *testing.T) { { Name: "teams_page_1", Data: &sqlQueryListTeams{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &ListTeamQuery{ Limit: 5, }, @@ -33,7 +33,7 @@ func TestQueries(t *testing.T) { { Name: "teams_page_2", Data: &sqlQueryListTeams{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &ListTeamQuery{ ContinueID: 1, Limit: 2, @@ -45,7 +45,7 @@ func TestQueries(t *testing.T) { { Name: "users_uid", Data: &sqlQueryListUsers{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &ListUserQuery{ UID: "abc", }, @@ -54,7 +54,7 @@ func TestQueries(t *testing.T) { { Name: "users_page_1", Data: &sqlQueryListUsers{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &ListUserQuery{ Limit: 5, }, @@ -63,7 +63,7 @@ func TestQueries(t *testing.T) { { Name: "users_page_2", Data: &sqlQueryListUsers{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &ListUserQuery{ ContinueID: 1, Limit: 2, @@ -75,7 +75,7 @@ func TestQueries(t *testing.T) { { Name: "display_uids", Data: &sqlQueryGetDisplay{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &GetUserDisplayQuery{ OrgID: 2, UIDs: []string{"a", "b"}, @@ -85,7 +85,7 @@ func TestQueries(t *testing.T) { { Name: "display_ids", Data: &sqlQueryGetDisplay{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &GetUserDisplayQuery{ OrgID: 2, IDs: []int64{1, 2}, @@ -95,7 +95,7 @@ func TestQueries(t *testing.T) { { Name: "display_ids_uids", Data: &sqlQueryGetDisplay{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Query: &GetUserDisplayQuery{ OrgID: 2, UIDs: []string{"a", "b"}, diff --git a/pkg/storage/unified/sql/backend.go b/pkg/storage/unified/sql/backend.go index 99158184e51..d9157131ba9 100644 --- a/pkg/storage/unified/sql/backend.go +++ b/pkg/storage/unified/sql/backend.go @@ -136,18 +136,18 @@ func (b *backend) create(ctx context.Context, event resource.WriteEvent) (int64, // 1. Insert into resource if _, err := dbutil.Exec(ctx, tx, sqlResourceInsert, sqlResourceRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - WriteEvent: event, - GUID: guid, + SQLTemplate: sqltemplate.New(b.dialect), + WriteEvent: event, + GUID: guid, }); err != nil { return fmt.Errorf("insert into resource: %w", err) } // 2. Insert into resource history if _, err := dbutil.Exec(ctx, tx, sqlResourceHistoryInsert, sqlResourceRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - WriteEvent: event, - GUID: guid, + SQLTemplate: sqltemplate.New(b.dialect), + WriteEvent: event, + GUID: guid, }); err != nil { return fmt.Errorf("insert into resource history: %w", err) } @@ -162,17 +162,17 @@ func (b *backend) create(ctx context.Context, event resource.WriteEvent) (int64, // 5. Update the RV in both resource and resource_history if _, err = dbutil.Exec(ctx, tx, sqlResourceHistoryUpdateRV, sqlResourceUpdateRVRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - GUID: guid, - ResourceVersion: rv, + SQLTemplate: sqltemplate.New(b.dialect), + GUID: guid, + ResourceVersion: rv, }); err != nil { return fmt.Errorf("update resource_history rv: %w", err) } if _, err = dbutil.Exec(ctx, tx, sqlResourceUpdateRV, sqlResourceUpdateRVRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - GUID: guid, - ResourceVersion: rv, + SQLTemplate: sqltemplate.New(b.dialect), + GUID: guid, + ResourceVersion: rv, }); err != nil { return fmt.Errorf("update resource rv: %w", err) } @@ -194,9 +194,9 @@ func (b *backend) update(ctx context.Context, event resource.WriteEvent) (int64, // 1. Update resource _, err := dbutil.Exec(ctx, tx, sqlResourceUpdate, sqlResourceRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - WriteEvent: event, - GUID: guid, + SQLTemplate: sqltemplate.New(b.dialect), + WriteEvent: event, + GUID: guid, }) if err != nil { return fmt.Errorf("initial resource update: %w", err) @@ -204,9 +204,9 @@ func (b *backend) update(ctx context.Context, event resource.WriteEvent) (int64, // 2. Insert into resource history if _, err := dbutil.Exec(ctx, tx, sqlResourceHistoryInsert, sqlResourceRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - WriteEvent: event, - GUID: guid, + SQLTemplate: sqltemplate.New(b.dialect), + WriteEvent: event, + GUID: guid, }); err != nil { return fmt.Errorf("insert into resource history: %w", err) } @@ -221,17 +221,17 @@ func (b *backend) update(ctx context.Context, event resource.WriteEvent) (int64, // 5. Update the RV in both resource and resource_history if _, err = dbutil.Exec(ctx, tx, sqlResourceHistoryUpdateRV, sqlResourceUpdateRVRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - GUID: guid, - ResourceVersion: rv, + SQLTemplate: sqltemplate.New(b.dialect), + GUID: guid, + ResourceVersion: rv, }); err != nil { return fmt.Errorf("update history rv: %w", err) } if _, err = dbutil.Exec(ctx, tx, sqlResourceUpdateRV, sqlResourceUpdateRVRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - GUID: guid, - ResourceVersion: rv, + SQLTemplate: sqltemplate.New(b.dialect), + GUID: guid, + ResourceVersion: rv, }); err != nil { return fmt.Errorf("update resource rv: %w", err) } @@ -254,9 +254,9 @@ func (b *backend) delete(ctx context.Context, event resource.WriteEvent) (int64, // 1. delete from resource _, err := dbutil.Exec(ctx, tx, sqlResourceDelete, sqlResourceRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - WriteEvent: event, - GUID: guid, + SQLTemplate: sqltemplate.New(b.dialect), + WriteEvent: event, + GUID: guid, }) if err != nil { return fmt.Errorf("delete resource: %w", err) @@ -264,9 +264,9 @@ func (b *backend) delete(ctx context.Context, event resource.WriteEvent) (int64, // 2. Add event to resource history if _, err := dbutil.Exec(ctx, tx, sqlResourceHistoryInsert, sqlResourceRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - WriteEvent: event, - GUID: guid, + SQLTemplate: sqltemplate.New(b.dialect), + WriteEvent: event, + GUID: guid, }); err != nil { return fmt.Errorf("insert into resource history: %w", err) } @@ -281,9 +281,9 @@ func (b *backend) delete(ctx context.Context, event resource.WriteEvent) (int64, // 5. Update the RV in resource_history if _, err = dbutil.Exec(ctx, tx, sqlResourceHistoryUpdateRV, sqlResourceUpdateRVRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - GUID: guid, - ResourceVersion: rv, + SQLTemplate: sqltemplate.New(b.dialect), + GUID: guid, + ResourceVersion: rv, }); err != nil { return fmt.Errorf("update history rv: %w", err) } @@ -302,9 +302,9 @@ func (b *backend) ReadResource(ctx context.Context, req *resource.ReadRequest) * // TODO: validate key ? readReq := sqlResourceReadRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - Request: req, - readResponse: new(readResponse), + SQLTemplate: sqltemplate.New(b.dialect), + Request: req, + readResponse: new(readResponse), } sr := sqlResourceRead @@ -418,8 +418,8 @@ func (b *backend) listLatest(ctx context.Context, req *resource.ListRequest, cb } listReq := sqlResourceListRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), - Request: new(resource.ListRequest), + SQLTemplate: sqltemplate.New(b.dialect), + Request: new(resource.ListRequest), } listReq.Request = proto.Clone(req).(*resource.ListRequest) @@ -467,7 +467,7 @@ func (b *backend) listAtRevision(ctx context.Context, req *resource.ListRequest, limit = math.MaxInt64 // a limit is required for offset } listReq := sqlResourceHistoryListRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), + SQLTemplate: sqltemplate.New(b.dialect), Request: &historyListRequest{ ResourceVersion: iter.listRV, Limit: limit, @@ -554,7 +554,7 @@ func (b *backend) poller(ctx context.Context, since groupResourceRV, stream chan func (b *backend) listLatestRVs(ctx context.Context) (groupResourceRV, error) { since := groupResourceRV{} reqRVs := sqlResourceVersionListRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), + SQLTemplate: sqltemplate.New(b.dialect), groupResourceVersion: new(groupResourceVersion), } query, err := sqltemplate.Execute(sqlResourceVersionList, reqRVs) @@ -585,11 +585,11 @@ func (b *backend) listLatestRVs(ctx context.Context) (groupResourceRV, error) { // fetchLatestRV returns the current maximum RV in the resource table func fetchLatestRV(ctx context.Context, x db.ContextExecer, d sqltemplate.Dialect, group, resource string) (int64, error) { res, err := dbutil.QueryRow(ctx, x, sqlResourceVersionGet, sqlResourceVersionRequest{ - SQLTemplateIface: sqltemplate.New(d), - Group: group, - Resource: resource, - ReadOnly: true, - resourceVersion: new(resourceVersion), + SQLTemplate: sqltemplate.New(d), + Group: group, + Resource: resource, + ReadOnly: true, + resourceVersion: new(resourceVersion), }) if errors.Is(err, sql.ErrNoRows) { return 1, nil @@ -604,7 +604,7 @@ func (b *backend) poll(ctx context.Context, grp string, res string, since int64, defer span.End() pollReq := sqlResourceHistoryPollRequest{ - SQLTemplateIface: sqltemplate.New(b.dialect), + SQLTemplate: sqltemplate.New(b.dialect), Resource: res, Group: grp, SinceResourceVersion: since, @@ -661,19 +661,19 @@ func resourceVersionAtomicInc(ctx context.Context, x db.ContextExecer, d sqltemp // TODO: refactor this code to run in a multi-statement transaction in order to minimize the number of round trips. // 1 Lock the row for update rv, err := dbutil.QueryRow(ctx, x, sqlResourceVersionGet, sqlResourceVersionRequest{ - SQLTemplateIface: sqltemplate.New(d), - Group: key.Group, - Resource: key.Resource, - resourceVersion: new(resourceVersion), + SQLTemplate: sqltemplate.New(d), + Group: key.Group, + Resource: key.Resource, + resourceVersion: new(resourceVersion), }) if errors.Is(err, sql.ErrNoRows) { // if there wasn't a row associated with the given resource, we create one with // version 1 if _, err = dbutil.Exec(ctx, x, sqlResourceVersionInsert, sqlResourceVersionRequest{ - SQLTemplateIface: sqltemplate.New(d), - Group: key.Group, - Resource: key.Resource, + SQLTemplate: sqltemplate.New(d), + Group: key.Group, + Resource: key.Resource, }); err != nil { return 0, fmt.Errorf("insert into resource_version: %w", err) } @@ -687,9 +687,9 @@ func resourceVersionAtomicInc(ctx context.Context, x db.ContextExecer, d sqltemp // 2. Increment the resource version _, err = dbutil.Exec(ctx, x, sqlResourceVersionInc, sqlResourceVersionRequest{ - SQLTemplateIface: sqltemplate.New(d), - Group: key.Group, - Resource: key.Resource, + SQLTemplate: sqltemplate.New(d), + Group: key.Group, + Resource: key.Resource, resourceVersion: &resourceVersion{ ResourceVersion: nextRV, }, diff --git a/pkg/storage/unified/sql/dbutil/dbutil.go b/pkg/storage/unified/sql/dbutil/dbutil.go index fb2ec5a791e..3a23a6fec54 100644 --- a/pkg/storage/unified/sql/dbutil/dbutil.go +++ b/pkg/storage/unified/sql/dbutil/dbutil.go @@ -79,7 +79,7 @@ func Debug(err error) error { // Exec uses `req` as input for a non-data returning query generated with // `tmpl`, and executed in `x`. -func Exec(ctx context.Context, x db.ContextExecer, tmpl *template.Template, req sqltemplate.SQLTemplateIface) (sql.Result, error) { +func Exec(ctx context.Context, x db.ContextExecer, tmpl *template.Template, req sqltemplate.SQLTemplate) (sql.Result, error) { if err := req.Validate(); err != nil { return nil, fmt.Errorf("Exec: invalid request for template %q: %w", tmpl.Name(), err) @@ -108,7 +108,7 @@ func Exec(ctx context.Context, x db.ContextExecer, tmpl *template.Template, req // Query uses `req` as input for a single-statement, set-returning query // generated with `tmpl`, and executed in `x`. -func QueryRows(ctx context.Context, x db.ContextExecer, tmpl *template.Template, req sqltemplate.SQLTemplateIface) (*sql.Rows, error) { +func QueryRows(ctx context.Context, x db.ContextExecer, tmpl *template.Template, req sqltemplate.SQLTemplate) (*sql.Rows, error) { if err := req.Validate(); err != nil { return nil, fmt.Errorf("Query: invalid request for template %q: %w", tmpl.Name(), err) diff --git a/pkg/storage/unified/sql/dbutil/dbutil_test.go b/pkg/storage/unified/sql/dbutil/dbutil_test.go index 54bed2e8312..d6c2c5056d3 100644 --- a/pkg/storage/unified/sql/dbutil/dbutil_test.go +++ b/pkg/storage/unified/sql/dbutil/dbutil_test.go @@ -441,7 +441,7 @@ func TestExec(t *testing.T) { // test declarations ctx := testutil.NewDefaultTestContext(t) - req := sqltemplateMocks.NewSQLTemplateIface(t) + req := sqltemplateMocks.NewSQLTemplate(t) rdb := test.NewDBProviderNopSQL(t) // setup expectations @@ -460,7 +460,7 @@ func TestExec(t *testing.T) { // test declarations ctx := testutil.NewDefaultTestContext(t) - req := sqltemplateMocks.NewSQLTemplateIface(t) + req := sqltemplateMocks.NewSQLTemplate(t) rdb := test.NewDBProviderNopSQL(t) // setup expectations @@ -478,7 +478,7 @@ func TestExec(t *testing.T) { // test declarations ctx := testutil.NewDefaultTestContext(t) - req := sqltemplateMocks.NewSQLTemplateIface(t) + req := sqltemplateMocks.NewSQLTemplate(t) rdb := test.NewDBProviderNopSQL(t) // setup expectations @@ -496,7 +496,7 @@ func TestExec(t *testing.T) { // test declarations ctx := testutil.NewDefaultTestContext(t) - req := sqltemplateMocks.NewSQLTemplateIface(t) + req := sqltemplateMocks.NewSQLTemplate(t) rdb := test.NewDBProviderNopSQL(t) // setup expectations diff --git a/pkg/storage/unified/sql/queries.go b/pkg/storage/unified/sql/queries.go index 0357546a352..99f126672fb 100644 --- a/pkg/storage/unified/sql/queries.go +++ b/pkg/storage/unified/sql/queries.go @@ -58,7 +58,7 @@ var ( ) type sqlResourceRequest struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate GUID string WriteEvent resource.WriteEvent } @@ -80,7 +80,7 @@ func (r *historyPollResponse) Results() (*historyPollResponse, error) { type groupResourceRV map[string]map[string]int64 type sqlResourceHistoryPollRequest struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate Resource string Group string SinceResourceVersion int64 @@ -102,7 +102,7 @@ func (r *readResponse) Results() (*readResponse, error) { } type sqlResourceReadRequest struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate Request *resource.ReadRequest *readResponse } @@ -113,7 +113,7 @@ func (r sqlResourceReadRequest) Validate() error { // List type sqlResourceListRequest struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate Request *resource.ListRequest } @@ -126,7 +126,7 @@ type historyListRequest struct { Options *resource.ListOptions } type sqlResourceHistoryListRequest struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate Request *historyListRequest Response *resource.ResourceWrapper } @@ -150,7 +150,7 @@ func (r sqlResourceHistoryListRequest) Results() (*resource.ResourceWrapper, err // update RV type sqlResourceUpdateRVRequest struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate GUID string ResourceVersion int64 } @@ -174,7 +174,7 @@ func (r *resourceVersion) Results() (*resourceVersion, error) { } type sqlResourceVersionRequest struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate Group, Resource string ReadOnly bool *resourceVersion @@ -185,7 +185,7 @@ func (r sqlResourceVersionRequest) Validate() error { } type sqlResourceVersionListRequest struct { - sqltemplate.SQLTemplateIface + sqltemplate.SQLTemplate *groupResourceVersion } diff --git a/pkg/storage/unified/sql/queries_test.go b/pkg/storage/unified/sql/queries_test.go index da2c2665f2e..767b6a096fb 100644 --- a/pkg/storage/unified/sql/queries_test.go +++ b/pkg/storage/unified/sql/queries_test.go @@ -16,7 +16,7 @@ func TestQueries(t *testing.T) { { Name: "simple", Data: &sqlResourceRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), WriteEvent: resource.WriteEvent{ Key: &resource.ResourceKey{ Namespace: "nn", @@ -32,7 +32,7 @@ func TestQueries(t *testing.T) { { Name: "simple", Data: &sqlResourceRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), WriteEvent: resource.WriteEvent{ Key: &resource.ResourceKey{ Namespace: "nn", @@ -50,7 +50,7 @@ func TestQueries(t *testing.T) { { Name: "single path", Data: &sqlResourceRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), WriteEvent: resource.WriteEvent{ Key: &resource.ResourceKey{}, }, @@ -61,7 +61,7 @@ func TestQueries(t *testing.T) { { Name: "without_resource_version", Data: &sqlResourceReadRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Request: &resource.ReadRequest{ Key: &resource.ResourceKey{}, }, @@ -74,7 +74,7 @@ func TestQueries(t *testing.T) { { Name: "filter_on_namespace", Data: &sqlResourceListRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Request: &resource.ListRequest{ Limit: 10, Options: &resource.ListOptions{ @@ -91,7 +91,7 @@ func TestQueries(t *testing.T) { { Name: "single path", Data: &sqlResourceHistoryListRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Request: &historyListRequest{ Limit: 10, Options: &resource.ListOptions{ @@ -109,7 +109,7 @@ func TestQueries(t *testing.T) { { Name: "single path", Data: &sqlResourceUpdateRVRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), }, }, }, @@ -118,7 +118,7 @@ func TestQueries(t *testing.T) { { Name: "single path", Data: &sqlResourceReadRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), Request: &resource.ReadRequest{ ResourceVersion: 123, Key: &resource.ResourceKey{}, @@ -132,7 +132,7 @@ func TestQueries(t *testing.T) { { Name: "single path", Data: &sqlResourceUpdateRVRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), }, }, }, @@ -141,7 +141,7 @@ func TestQueries(t *testing.T) { { Name: "insert into resource_history", Data: &sqlResourceRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), WriteEvent: resource.WriteEvent{ Key: &resource.ResourceKey{}, }, @@ -153,9 +153,9 @@ func TestQueries(t *testing.T) { { Name: "single path", Data: &sqlResourceVersionRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), - resourceVersion: new(resourceVersion), - ReadOnly: false, + SQLTemplate: mocks.NewTestingSQLTemplate(), + resourceVersion: new(resourceVersion), + ReadOnly: false, }, }, }, @@ -164,7 +164,7 @@ func TestQueries(t *testing.T) { { Name: "increment resource version", Data: &sqlResourceVersionRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), resourceVersion: &resourceVersion{ ResourceVersion: 123, }, @@ -176,7 +176,7 @@ func TestQueries(t *testing.T) { { Name: "single path", Data: &sqlResourceVersionRequest{ - SQLTemplateIface: mocks.NewTestingSQLTemplate(), + SQLTemplate: mocks.NewTestingSQLTemplate(), }, }, }, diff --git a/pkg/storage/unified/sql/sqltemplate/args.go b/pkg/storage/unified/sql/sqltemplate/args.go index eac4452ea37..90c0f40e2f7 100644 --- a/pkg/storage/unified/sql/sqltemplate/args.go +++ b/pkg/storage/unified/sql/sqltemplate/args.go @@ -15,20 +15,20 @@ var ( // the right order. Add it to your data types passed to SQLTemplate, either by // embedding or with a named struct field if its Arg method would clash with // another struct field. -type Args struct { +type args struct { d interface{ ArgPlaceholder(argNum int) string } values []any } -func NewArgs(d Dialect) *Args { - return &Args{ +func NewArgs(d Dialect) Args { + return &args{ d: d, } } // Arg can be called from within templates to pass arguments to the SQL driver // to use in the execution of the query. -func (a *Args) Arg(x any) string { +func (a *args) Arg(x any) string { a.values = append(a.values, x) return a.d.ArgPlaceholder(len(a.values)) @@ -48,7 +48,7 @@ func (a *Args) Arg(x any) string { // DELETE FROM {{ .Ident "mytab" }} // WHERE id IN ( {{ argList . .IDs }} ) // ; -func (a *Args) ArgList(slice reflect.Value) (string, error) { +func (a *args) ArgList(slice reflect.Value) (string, error) { if !slice.IsValid() || slice.Kind() != reflect.Slice { return "", ErrInvalidArgList } @@ -69,15 +69,15 @@ func (a *Args) ArgList(slice reflect.Value) (string, error) { return b.String(), nil } -func (a *Args) Reset() { +func (a *args) Reset() { a.values = nil } -func (a *Args) GetArgs() []any { +func (a *args) GetArgs() []any { return a.values } -type ArgsIface interface { +type Args interface { Arg(x any) string ArgList(slice reflect.Value) (string, error) GetArgs() []any diff --git a/pkg/storage/unified/sql/sqltemplate/args_test.go b/pkg/storage/unified/sql/sqltemplate/args_test.go index 5399db21ae1..732b2c2915f 100644 --- a/pkg/storage/unified/sql/sqltemplate/args_test.go +++ b/pkg/storage/unified/sql/sqltemplate/args_test.go @@ -70,7 +70,7 @@ func TestArg_ArgList(t *testing.T) { }, } - var a Args + var a args a.d = argFmtSQL92 for i, tc := range testCases { a.Reset() diff --git a/pkg/storage/unified/sql/sqltemplate/example_test.go b/pkg/storage/unified/sql/sqltemplate/example_test.go index e8e8241f881..21d4e198cbc 100644 --- a/pkg/storage/unified/sql/sqltemplate/example_test.go +++ b/pkg/storage/unified/sql/sqltemplate/example_test.go @@ -47,7 +47,7 @@ type GetUserResponse struct { // the methods to achieve our purpose:: type GetUserQuery struct { - *SQLTemplate + SQLTemplate Request *GetUserRequest Response *GetUserResponse } @@ -109,11 +109,11 @@ func Example() { // As we're not actually running a database in this example, let's verify // that we find our arguments populated as expected instead: if len(queryData.GetArgs()) != 1 { - panic(fmt.Sprintf("unexpected number of args: %#v", queryData.Args)) + panic(fmt.Sprintf("unexpected number of args: %#v", queryData.GetArgs()...)) } id, ok := queryData.GetArgs()[0].(int) if !ok || id != queryData.Request.ID { - panic(fmt.Sprintf("unexpected args: %#v", queryData.Args)) + panic(fmt.Sprintf("unexpected args: %#v", queryData.GetArgs()...)) } // In your code you would now have "row" populated with the row data, @@ -127,19 +127,19 @@ func Example() { // the expected data, which should be pointers to each of the fields of // Response so that the Scan method can write to them: if len(queryData.GetScanDest()) != 3 { - panic(fmt.Sprintf("unexpected number of scan dest: %#v", queryData.ScanDest)) + panic(fmt.Sprintf("unexpected number of scan dest: %#v", queryData.GetScanDest()...)) } idPtr, ok := queryData.GetScanDest()[0].(*int) if !ok || idPtr != &queryData.Response.ID { - panic(fmt.Sprintf("unexpected response 'id' pointer: %#v", queryData.ScanDest)) + panic(fmt.Sprintf("unexpected response 'id' pointer: %#v", queryData.GetScanDest()...)) } typePtr, ok := queryData.GetScanDest()[1].(*string) if !ok || typePtr != &queryData.Response.Type { - panic(fmt.Sprintf("unexpected response 'type' pointer: %#v", queryData.ScanDest)) + panic(fmt.Sprintf("unexpected response 'type' pointer: %#v", queryData.GetScanDest()...)) } namePtr, ok := queryData.GetScanDest()[2].(*string) if !ok || namePtr != &queryData.Response.Name { - panic(fmt.Sprintf("unexpected response 'name' pointer: %#v", queryData.ScanDest)) + panic(fmt.Sprintf("unexpected response 'name' pointer: %#v", queryData.GetScanDest()...)) } // Remember the variable "query"? Well, we didn't check it. We will now make diff --git a/pkg/storage/unified/sql/sqltemplate/into.go b/pkg/storage/unified/sql/sqltemplate/into.go index 2896f89481c..a96de51d649 100644 --- a/pkg/storage/unified/sql/sqltemplate/into.go +++ b/pkg/storage/unified/sql/sqltemplate/into.go @@ -5,12 +5,12 @@ import ( "reflect" ) -type ScanDest struct { +type scanDest struct { values []any colNames []string } -func (i *ScanDest) Into(v reflect.Value, colName string) (string, error) { +func (i *scanDest) Into(v reflect.Value, colName string) (string, error) { if !v.IsValid() || !v.CanAddr() || !v.Addr().CanInterface() { return "", fmt.Errorf("invalid or unaddressable value: %v", colName) } @@ -21,19 +21,19 @@ func (i *ScanDest) Into(v reflect.Value, colName string) (string, error) { return colName, nil } -func (i *ScanDest) Reset() { +func (i *scanDest) Reset() { i.values = nil } -func (i *ScanDest) GetScanDest() []any { +func (i *scanDest) GetScanDest() []any { return i.values } -func (i *ScanDest) GetColNames() []string { +func (i *scanDest) GetColNames() []string { return i.colNames } -type ScanDestIface interface { +type ScanDest interface { Into(v reflect.Value, colName string) (string, error) GetScanDest() []any GetColNames() []string diff --git a/pkg/storage/unified/sql/sqltemplate/into_test.go b/pkg/storage/unified/sql/sqltemplate/into_test.go index b4b06767f7c..a35edc7fce0 100644 --- a/pkg/storage/unified/sql/sqltemplate/into_test.go +++ b/pkg/storage/unified/sql/sqltemplate/into_test.go @@ -9,7 +9,7 @@ import ( func TestScanDest_Into(t *testing.T) { t.Parallel() - var d ScanDest + var d scanDest colName, err := d.Into(reflect.Value{}, "some field") if colName != "" || err == nil || len(d.GetScanDest()) != 0 { diff --git a/pkg/storage/unified/sql/sqltemplate/mocks/SQLTemplateIface.go b/pkg/storage/unified/sql/sqltemplate/mocks/SQLTemplateIface.go index 3c633a45f0f..d714c54e46d 100644 --- a/pkg/storage/unified/sql/sqltemplate/mocks/SQLTemplateIface.go +++ b/pkg/storage/unified/sql/sqltemplate/mocks/SQLTemplateIface.go @@ -10,21 +10,21 @@ import ( sqltemplate "github.com/grafana/grafana/pkg/storage/unified/sql/sqltemplate" ) -// SQLTemplateIface is an autogenerated mock type for the SQLTemplateIface type -type SQLTemplateIface struct { +// SQLTemplate is an autogenerated mock type for the SQLTemplate type +type SQLTemplate struct { mock.Mock } -type SQLTemplateIface_Expecter struct { +type SQLTemplate_Expecter struct { mock *mock.Mock } -func (_m *SQLTemplateIface) EXPECT() *SQLTemplateIface_Expecter { - return &SQLTemplateIface_Expecter{mock: &_m.Mock} +func (_m *SQLTemplate) EXPECT() *SQLTemplate_Expecter { + return &SQLTemplate_Expecter{mock: &_m.Mock} } // Arg provides a mock function with given fields: x -func (_m *SQLTemplateIface) Arg(x interface{}) string { +func (_m *SQLTemplate) Arg(x interface{}) string { ret := _m.Called(x) if len(ret) == 0 { @@ -41,36 +41,36 @@ func (_m *SQLTemplateIface) Arg(x interface{}) string { return r0 } -// SQLTemplateIface_Arg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Arg' -type SQLTemplateIface_Arg_Call struct { +// SQLTemplate_Arg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Arg' +type SQLTemplate_Arg_Call struct { *mock.Call } // Arg is a helper method to define mock.On call // - x interface{} -func (_e *SQLTemplateIface_Expecter) Arg(x interface{}) *SQLTemplateIface_Arg_Call { - return &SQLTemplateIface_Arg_Call{Call: _e.mock.On("Arg", x)} +func (_e *SQLTemplate_Expecter) Arg(x interface{}) *SQLTemplate_Arg_Call { + return &SQLTemplate_Arg_Call{Call: _e.mock.On("Arg", x)} } -func (_c *SQLTemplateIface_Arg_Call) Run(run func(x interface{})) *SQLTemplateIface_Arg_Call { +func (_c *SQLTemplate_Arg_Call) Run(run func(x interface{})) *SQLTemplate_Arg_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(interface{})) }) return _c } -func (_c *SQLTemplateIface_Arg_Call) Return(_a0 string) *SQLTemplateIface_Arg_Call { +func (_c *SQLTemplate_Arg_Call) Return(_a0 string) *SQLTemplate_Arg_Call { _c.Call.Return(_a0) return _c } -func (_c *SQLTemplateIface_Arg_Call) RunAndReturn(run func(interface{}) string) *SQLTemplateIface_Arg_Call { +func (_c *SQLTemplate_Arg_Call) RunAndReturn(run func(interface{}) string) *SQLTemplate_Arg_Call { _c.Call.Return(run) return _c } // ArgList provides a mock function with given fields: slice -func (_m *SQLTemplateIface) ArgList(slice reflect.Value) (string, error) { +func (_m *SQLTemplate) ArgList(slice reflect.Value) (string, error) { ret := _m.Called(slice) if len(ret) == 0 { @@ -97,36 +97,36 @@ func (_m *SQLTemplateIface) ArgList(slice reflect.Value) (string, error) { return r0, r1 } -// SQLTemplateIface_ArgList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ArgList' -type SQLTemplateIface_ArgList_Call struct { +// SQLTemplate_ArgList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ArgList' +type SQLTemplate_ArgList_Call struct { *mock.Call } // ArgList is a helper method to define mock.On call // - slice reflect.Value -func (_e *SQLTemplateIface_Expecter) ArgList(slice interface{}) *SQLTemplateIface_ArgList_Call { - return &SQLTemplateIface_ArgList_Call{Call: _e.mock.On("ArgList", slice)} +func (_e *SQLTemplate_Expecter) ArgList(slice interface{}) *SQLTemplate_ArgList_Call { + return &SQLTemplate_ArgList_Call{Call: _e.mock.On("ArgList", slice)} } -func (_c *SQLTemplateIface_ArgList_Call) Run(run func(slice reflect.Value)) *SQLTemplateIface_ArgList_Call { +func (_c *SQLTemplate_ArgList_Call) Run(run func(slice reflect.Value)) *SQLTemplate_ArgList_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(reflect.Value)) }) return _c } -func (_c *SQLTemplateIface_ArgList_Call) Return(_a0 string, _a1 error) *SQLTemplateIface_ArgList_Call { +func (_c *SQLTemplate_ArgList_Call) Return(_a0 string, _a1 error) *SQLTemplate_ArgList_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *SQLTemplateIface_ArgList_Call) RunAndReturn(run func(reflect.Value) (string, error)) *SQLTemplateIface_ArgList_Call { +func (_c *SQLTemplate_ArgList_Call) RunAndReturn(run func(reflect.Value) (string, error)) *SQLTemplate_ArgList_Call { _c.Call.Return(run) return _c } // ArgPlaceholder provides a mock function with given fields: argNum -func (_m *SQLTemplateIface) ArgPlaceholder(argNum int) string { +func (_m *SQLTemplate) ArgPlaceholder(argNum int) string { ret := _m.Called(argNum) if len(ret) == 0 { @@ -143,36 +143,36 @@ func (_m *SQLTemplateIface) ArgPlaceholder(argNum int) string { return r0 } -// SQLTemplateIface_ArgPlaceholder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ArgPlaceholder' -type SQLTemplateIface_ArgPlaceholder_Call struct { +// SQLTemplate_ArgPlaceholder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ArgPlaceholder' +type SQLTemplate_ArgPlaceholder_Call struct { *mock.Call } // ArgPlaceholder is a helper method to define mock.On call // - argNum int -func (_e *SQLTemplateIface_Expecter) ArgPlaceholder(argNum interface{}) *SQLTemplateIface_ArgPlaceholder_Call { - return &SQLTemplateIface_ArgPlaceholder_Call{Call: _e.mock.On("ArgPlaceholder", argNum)} +func (_e *SQLTemplate_Expecter) ArgPlaceholder(argNum interface{}) *SQLTemplate_ArgPlaceholder_Call { + return &SQLTemplate_ArgPlaceholder_Call{Call: _e.mock.On("ArgPlaceholder", argNum)} } -func (_c *SQLTemplateIface_ArgPlaceholder_Call) Run(run func(argNum int)) *SQLTemplateIface_ArgPlaceholder_Call { +func (_c *SQLTemplate_ArgPlaceholder_Call) Run(run func(argNum int)) *SQLTemplate_ArgPlaceholder_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(int)) }) return _c } -func (_c *SQLTemplateIface_ArgPlaceholder_Call) Return(_a0 string) *SQLTemplateIface_ArgPlaceholder_Call { +func (_c *SQLTemplate_ArgPlaceholder_Call) Return(_a0 string) *SQLTemplate_ArgPlaceholder_Call { _c.Call.Return(_a0) return _c } -func (_c *SQLTemplateIface_ArgPlaceholder_Call) RunAndReturn(run func(int) string) *SQLTemplateIface_ArgPlaceholder_Call { +func (_c *SQLTemplate_ArgPlaceholder_Call) RunAndReturn(run func(int) string) *SQLTemplate_ArgPlaceholder_Call { _c.Call.Return(run) return _c } // DialectName provides a mock function with given fields: -func (_m *SQLTemplateIface) DialectName() string { +func (_m *SQLTemplate) DialectName() string { ret := _m.Called() if len(ret) == 0 { @@ -189,35 +189,35 @@ func (_m *SQLTemplateIface) DialectName() string { return r0 } -// SQLTemplateIface_DialectName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DialectName' -type SQLTemplateIface_DialectName_Call struct { +// SQLTemplate_DialectName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DialectName' +type SQLTemplate_DialectName_Call struct { *mock.Call } // DialectName is a helper method to define mock.On call -func (_e *SQLTemplateIface_Expecter) DialectName() *SQLTemplateIface_DialectName_Call { - return &SQLTemplateIface_DialectName_Call{Call: _e.mock.On("DialectName")} +func (_e *SQLTemplate_Expecter) DialectName() *SQLTemplate_DialectName_Call { + return &SQLTemplate_DialectName_Call{Call: _e.mock.On("DialectName")} } -func (_c *SQLTemplateIface_DialectName_Call) Run(run func()) *SQLTemplateIface_DialectName_Call { +func (_c *SQLTemplate_DialectName_Call) Run(run func()) *SQLTemplate_DialectName_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } -func (_c *SQLTemplateIface_DialectName_Call) Return(_a0 string) *SQLTemplateIface_DialectName_Call { +func (_c *SQLTemplate_DialectName_Call) Return(_a0 string) *SQLTemplate_DialectName_Call { _c.Call.Return(_a0) return _c } -func (_c *SQLTemplateIface_DialectName_Call) RunAndReturn(run func() string) *SQLTemplateIface_DialectName_Call { +func (_c *SQLTemplate_DialectName_Call) RunAndReturn(run func() string) *SQLTemplate_DialectName_Call { _c.Call.Return(run) return _c } // GetArgs provides a mock function with given fields: -func (_m *SQLTemplateIface) GetArgs() []interface{} { +func (_m *SQLTemplate) GetArgs() []interface{} { ret := _m.Called() if len(ret) == 0 { @@ -236,35 +236,35 @@ func (_m *SQLTemplateIface) GetArgs() []interface{} { return r0 } -// SQLTemplateIface_GetArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetArgs' -type SQLTemplateIface_GetArgs_Call struct { +// SQLTemplate_GetArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetArgs' +type SQLTemplate_GetArgs_Call struct { *mock.Call } // GetArgs is a helper method to define mock.On call -func (_e *SQLTemplateIface_Expecter) GetArgs() *SQLTemplateIface_GetArgs_Call { - return &SQLTemplateIface_GetArgs_Call{Call: _e.mock.On("GetArgs")} +func (_e *SQLTemplate_Expecter) GetArgs() *SQLTemplate_GetArgs_Call { + return &SQLTemplate_GetArgs_Call{Call: _e.mock.On("GetArgs")} } -func (_c *SQLTemplateIface_GetArgs_Call) Run(run func()) *SQLTemplateIface_GetArgs_Call { +func (_c *SQLTemplate_GetArgs_Call) Run(run func()) *SQLTemplate_GetArgs_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } -func (_c *SQLTemplateIface_GetArgs_Call) Return(_a0 []interface{}) *SQLTemplateIface_GetArgs_Call { +func (_c *SQLTemplate_GetArgs_Call) Return(_a0 []interface{}) *SQLTemplate_GetArgs_Call { _c.Call.Return(_a0) return _c } -func (_c *SQLTemplateIface_GetArgs_Call) RunAndReturn(run func() []interface{}) *SQLTemplateIface_GetArgs_Call { +func (_c *SQLTemplate_GetArgs_Call) RunAndReturn(run func() []interface{}) *SQLTemplate_GetArgs_Call { _c.Call.Return(run) return _c } // GetColNames provides a mock function with given fields: -func (_m *SQLTemplateIface) GetColNames() []string { +func (_m *SQLTemplate) GetColNames() []string { ret := _m.Called() if len(ret) == 0 { @@ -283,35 +283,35 @@ func (_m *SQLTemplateIface) GetColNames() []string { return r0 } -// SQLTemplateIface_GetColNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetColNames' -type SQLTemplateIface_GetColNames_Call struct { +// SQLTemplate_GetColNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetColNames' +type SQLTemplate_GetColNames_Call struct { *mock.Call } // GetColNames is a helper method to define mock.On call -func (_e *SQLTemplateIface_Expecter) GetColNames() *SQLTemplateIface_GetColNames_Call { - return &SQLTemplateIface_GetColNames_Call{Call: _e.mock.On("GetColNames")} +func (_e *SQLTemplate_Expecter) GetColNames() *SQLTemplate_GetColNames_Call { + return &SQLTemplate_GetColNames_Call{Call: _e.mock.On("GetColNames")} } -func (_c *SQLTemplateIface_GetColNames_Call) Run(run func()) *SQLTemplateIface_GetColNames_Call { +func (_c *SQLTemplate_GetColNames_Call) Run(run func()) *SQLTemplate_GetColNames_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } -func (_c *SQLTemplateIface_GetColNames_Call) Return(_a0 []string) *SQLTemplateIface_GetColNames_Call { +func (_c *SQLTemplate_GetColNames_Call) Return(_a0 []string) *SQLTemplate_GetColNames_Call { _c.Call.Return(_a0) return _c } -func (_c *SQLTemplateIface_GetColNames_Call) RunAndReturn(run func() []string) *SQLTemplateIface_GetColNames_Call { +func (_c *SQLTemplate_GetColNames_Call) RunAndReturn(run func() []string) *SQLTemplate_GetColNames_Call { _c.Call.Return(run) return _c } // GetScanDest provides a mock function with given fields: -func (_m *SQLTemplateIface) GetScanDest() []interface{} { +func (_m *SQLTemplate) GetScanDest() []interface{} { ret := _m.Called() if len(ret) == 0 { @@ -330,35 +330,35 @@ func (_m *SQLTemplateIface) GetScanDest() []interface{} { return r0 } -// SQLTemplateIface_GetScanDest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetScanDest' -type SQLTemplateIface_GetScanDest_Call struct { +// SQLTemplate_GetScanDest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetScanDest' +type SQLTemplate_GetScanDest_Call struct { *mock.Call } // GetScanDest is a helper method to define mock.On call -func (_e *SQLTemplateIface_Expecter) GetScanDest() *SQLTemplateIface_GetScanDest_Call { - return &SQLTemplateIface_GetScanDest_Call{Call: _e.mock.On("GetScanDest")} +func (_e *SQLTemplate_Expecter) GetScanDest() *SQLTemplate_GetScanDest_Call { + return &SQLTemplate_GetScanDest_Call{Call: _e.mock.On("GetScanDest")} } -func (_c *SQLTemplateIface_GetScanDest_Call) Run(run func()) *SQLTemplateIface_GetScanDest_Call { +func (_c *SQLTemplate_GetScanDest_Call) Run(run func()) *SQLTemplate_GetScanDest_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } -func (_c *SQLTemplateIface_GetScanDest_Call) Return(_a0 []interface{}) *SQLTemplateIface_GetScanDest_Call { +func (_c *SQLTemplate_GetScanDest_Call) Return(_a0 []interface{}) *SQLTemplate_GetScanDest_Call { _c.Call.Return(_a0) return _c } -func (_c *SQLTemplateIface_GetScanDest_Call) RunAndReturn(run func() []interface{}) *SQLTemplateIface_GetScanDest_Call { +func (_c *SQLTemplate_GetScanDest_Call) RunAndReturn(run func() []interface{}) *SQLTemplate_GetScanDest_Call { _c.Call.Return(run) return _c } // Ident provides a mock function with given fields: _a0 -func (_m *SQLTemplateIface) Ident(_a0 string) (string, error) { +func (_m *SQLTemplate) Ident(_a0 string) (string, error) { ret := _m.Called(_a0) if len(ret) == 0 { @@ -385,36 +385,36 @@ func (_m *SQLTemplateIface) Ident(_a0 string) (string, error) { return r0, r1 } -// SQLTemplateIface_Ident_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ident' -type SQLTemplateIface_Ident_Call struct { +// SQLTemplate_Ident_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ident' +type SQLTemplate_Ident_Call struct { *mock.Call } // Ident is a helper method to define mock.On call // - _a0 string -func (_e *SQLTemplateIface_Expecter) Ident(_a0 interface{}) *SQLTemplateIface_Ident_Call { - return &SQLTemplateIface_Ident_Call{Call: _e.mock.On("Ident", _a0)} +func (_e *SQLTemplate_Expecter) Ident(_a0 interface{}) *SQLTemplate_Ident_Call { + return &SQLTemplate_Ident_Call{Call: _e.mock.On("Ident", _a0)} } -func (_c *SQLTemplateIface_Ident_Call) Run(run func(_a0 string)) *SQLTemplateIface_Ident_Call { +func (_c *SQLTemplate_Ident_Call) Run(run func(_a0 string)) *SQLTemplate_Ident_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(string)) }) return _c } -func (_c *SQLTemplateIface_Ident_Call) Return(_a0 string, _a1 error) *SQLTemplateIface_Ident_Call { +func (_c *SQLTemplate_Ident_Call) Return(_a0 string, _a1 error) *SQLTemplate_Ident_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *SQLTemplateIface_Ident_Call) RunAndReturn(run func(string) (string, error)) *SQLTemplateIface_Ident_Call { +func (_c *SQLTemplate_Ident_Call) RunAndReturn(run func(string) (string, error)) *SQLTemplate_Ident_Call { _c.Call.Return(run) return _c } // Into provides a mock function with given fields: v, colName -func (_m *SQLTemplateIface) Into(v reflect.Value, colName string) (string, error) { +func (_m *SQLTemplate) Into(v reflect.Value, colName string) (string, error) { ret := _m.Called(v, colName) if len(ret) == 0 { @@ -441,69 +441,69 @@ func (_m *SQLTemplateIface) Into(v reflect.Value, colName string) (string, error return r0, r1 } -// SQLTemplateIface_Into_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Into' -type SQLTemplateIface_Into_Call struct { +// SQLTemplate_Into_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Into' +type SQLTemplate_Into_Call struct { *mock.Call } // Into is a helper method to define mock.On call // - v reflect.Value // - colName string -func (_e *SQLTemplateIface_Expecter) Into(v interface{}, colName interface{}) *SQLTemplateIface_Into_Call { - return &SQLTemplateIface_Into_Call{Call: _e.mock.On("Into", v, colName)} +func (_e *SQLTemplate_Expecter) Into(v interface{}, colName interface{}) *SQLTemplate_Into_Call { + return &SQLTemplate_Into_Call{Call: _e.mock.On("Into", v, colName)} } -func (_c *SQLTemplateIface_Into_Call) Run(run func(v reflect.Value, colName string)) *SQLTemplateIface_Into_Call { +func (_c *SQLTemplate_Into_Call) Run(run func(v reflect.Value, colName string)) *SQLTemplate_Into_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(reflect.Value), args[1].(string)) }) return _c } -func (_c *SQLTemplateIface_Into_Call) Return(_a0 string, _a1 error) *SQLTemplateIface_Into_Call { +func (_c *SQLTemplate_Into_Call) Return(_a0 string, _a1 error) *SQLTemplate_Into_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *SQLTemplateIface_Into_Call) RunAndReturn(run func(reflect.Value, string) (string, error)) *SQLTemplateIface_Into_Call { +func (_c *SQLTemplate_Into_Call) RunAndReturn(run func(reflect.Value, string) (string, error)) *SQLTemplate_Into_Call { _c.Call.Return(run) return _c } // Reset provides a mock function with given fields: -func (_m *SQLTemplateIface) Reset() { +func (_m *SQLTemplate) Reset() { _m.Called() } -// SQLTemplateIface_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset' -type SQLTemplateIface_Reset_Call struct { +// SQLTemplate_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset' +type SQLTemplate_Reset_Call struct { *mock.Call } // Reset is a helper method to define mock.On call -func (_e *SQLTemplateIface_Expecter) Reset() *SQLTemplateIface_Reset_Call { - return &SQLTemplateIface_Reset_Call{Call: _e.mock.On("Reset")} +func (_e *SQLTemplate_Expecter) Reset() *SQLTemplate_Reset_Call { + return &SQLTemplate_Reset_Call{Call: _e.mock.On("Reset")} } -func (_c *SQLTemplateIface_Reset_Call) Run(run func()) *SQLTemplateIface_Reset_Call { +func (_c *SQLTemplate_Reset_Call) Run(run func()) *SQLTemplate_Reset_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } -func (_c *SQLTemplateIface_Reset_Call) Return() *SQLTemplateIface_Reset_Call { +func (_c *SQLTemplate_Reset_Call) Return() *SQLTemplate_Reset_Call { _c.Call.Return() return _c } -func (_c *SQLTemplateIface_Reset_Call) RunAndReturn(run func()) *SQLTemplateIface_Reset_Call { +func (_c *SQLTemplate_Reset_Call) RunAndReturn(run func()) *SQLTemplate_Reset_Call { _c.Call.Return(run) return _c } // SelectFor provides a mock function with given fields: _a0 -func (_m *SQLTemplateIface) SelectFor(_a0 ...string) (string, error) { +func (_m *SQLTemplate) SelectFor(_a0 ...string) (string, error) { _va := make([]interface{}, len(_a0)) for _i := range _a0 { _va[_i] = _a0[_i] @@ -536,19 +536,19 @@ func (_m *SQLTemplateIface) SelectFor(_a0 ...string) (string, error) { return r0, r1 } -// SQLTemplateIface_SelectFor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectFor' -type SQLTemplateIface_SelectFor_Call struct { +// SQLTemplate_SelectFor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectFor' +type SQLTemplate_SelectFor_Call struct { *mock.Call } // SelectFor is a helper method to define mock.On call // - _a0 ...string -func (_e *SQLTemplateIface_Expecter) SelectFor(_a0 ...interface{}) *SQLTemplateIface_SelectFor_Call { - return &SQLTemplateIface_SelectFor_Call{Call: _e.mock.On("SelectFor", +func (_e *SQLTemplate_Expecter) SelectFor(_a0 ...interface{}) *SQLTemplate_SelectFor_Call { + return &SQLTemplate_SelectFor_Call{Call: _e.mock.On("SelectFor", append([]interface{}{}, _a0...)...)} } -func (_c *SQLTemplateIface_SelectFor_Call) Run(run func(_a0 ...string)) *SQLTemplateIface_SelectFor_Call { +func (_c *SQLTemplate_SelectFor_Call) Run(run func(_a0 ...string)) *SQLTemplate_SelectFor_Call { _c.Call.Run(func(args mock.Arguments) { variadicArgs := make([]string, len(args)-0) for i, a := range args[0:] { @@ -561,51 +561,51 @@ func (_c *SQLTemplateIface_SelectFor_Call) Run(run func(_a0 ...string)) *SQLTemp return _c } -func (_c *SQLTemplateIface_SelectFor_Call) Return(_a0 string, _a1 error) *SQLTemplateIface_SelectFor_Call { +func (_c *SQLTemplate_SelectFor_Call) Return(_a0 string, _a1 error) *SQLTemplate_SelectFor_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *SQLTemplateIface_SelectFor_Call) RunAndReturn(run func(...string) (string, error)) *SQLTemplateIface_SelectFor_Call { +func (_c *SQLTemplate_SelectFor_Call) RunAndReturn(run func(...string) (string, error)) *SQLTemplate_SelectFor_Call { _c.Call.Return(run) return _c } // SetDialect provides a mock function with given fields: _a0 -func (_m *SQLTemplateIface) SetDialect(_a0 sqltemplate.Dialect) { +func (_m *SQLTemplate) SetDialect(_a0 sqltemplate.Dialect) { _m.Called(_a0) } -// SQLTemplateIface_SetDialect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDialect' -type SQLTemplateIface_SetDialect_Call struct { +// SQLTemplate_SetDialect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDialect' +type SQLTemplate_SetDialect_Call struct { *mock.Call } // SetDialect is a helper method to define mock.On call // - _a0 sqltemplate.Dialect -func (_e *SQLTemplateIface_Expecter) SetDialect(_a0 interface{}) *SQLTemplateIface_SetDialect_Call { - return &SQLTemplateIface_SetDialect_Call{Call: _e.mock.On("SetDialect", _a0)} +func (_e *SQLTemplate_Expecter) SetDialect(_a0 interface{}) *SQLTemplate_SetDialect_Call { + return &SQLTemplate_SetDialect_Call{Call: _e.mock.On("SetDialect", _a0)} } -func (_c *SQLTemplateIface_SetDialect_Call) Run(run func(_a0 sqltemplate.Dialect)) *SQLTemplateIface_SetDialect_Call { +func (_c *SQLTemplate_SetDialect_Call) Run(run func(_a0 sqltemplate.Dialect)) *SQLTemplate_SetDialect_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(sqltemplate.Dialect)) }) return _c } -func (_c *SQLTemplateIface_SetDialect_Call) Return() *SQLTemplateIface_SetDialect_Call { +func (_c *SQLTemplate_SetDialect_Call) Return() *SQLTemplate_SetDialect_Call { _c.Call.Return() return _c } -func (_c *SQLTemplateIface_SetDialect_Call) RunAndReturn(run func(sqltemplate.Dialect)) *SQLTemplateIface_SetDialect_Call { +func (_c *SQLTemplate_SetDialect_Call) RunAndReturn(run func(sqltemplate.Dialect)) *SQLTemplate_SetDialect_Call { _c.Call.Return(run) return _c } // Validate provides a mock function with given fields: -func (_m *SQLTemplateIface) Validate() error { +func (_m *SQLTemplate) Validate() error { ret := _m.Called() if len(ret) == 0 { @@ -622,40 +622,40 @@ func (_m *SQLTemplateIface) Validate() error { return r0 } -// SQLTemplateIface_Validate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Validate' -type SQLTemplateIface_Validate_Call struct { +// SQLTemplate_Validate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Validate' +type SQLTemplate_Validate_Call struct { *mock.Call } // Validate is a helper method to define mock.On call -func (_e *SQLTemplateIface_Expecter) Validate() *SQLTemplateIface_Validate_Call { - return &SQLTemplateIface_Validate_Call{Call: _e.mock.On("Validate")} +func (_e *SQLTemplate_Expecter) Validate() *SQLTemplate_Validate_Call { + return &SQLTemplate_Validate_Call{Call: _e.mock.On("Validate")} } -func (_c *SQLTemplateIface_Validate_Call) Run(run func()) *SQLTemplateIface_Validate_Call { +func (_c *SQLTemplate_Validate_Call) Run(run func()) *SQLTemplate_Validate_Call { _c.Call.Run(func(args mock.Arguments) { run() }) return _c } -func (_c *SQLTemplateIface_Validate_Call) Return(_a0 error) *SQLTemplateIface_Validate_Call { +func (_c *SQLTemplate_Validate_Call) Return(_a0 error) *SQLTemplate_Validate_Call { _c.Call.Return(_a0) return _c } -func (_c *SQLTemplateIface_Validate_Call) RunAndReturn(run func() error) *SQLTemplateIface_Validate_Call { +func (_c *SQLTemplate_Validate_Call) RunAndReturn(run func() error) *SQLTemplate_Validate_Call { _c.Call.Return(run) return _c } -// NewSQLTemplateIface creates a new instance of SQLTemplateIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// NewSQLTemplate creates a new instance of SQLTemplate. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. -func NewSQLTemplateIface(t interface { +func NewSQLTemplate(t interface { mock.TestingT Cleanup(func()) -}) *SQLTemplateIface { - mock := &SQLTemplateIface{} +}) *SQLTemplate { + mock := &SQLTemplate{} mock.Mock.Test(t) t.Cleanup(func() { mock.AssertExpectations(t) }) diff --git a/pkg/storage/unified/sql/sqltemplate/mocks/test_snapshots.go b/pkg/storage/unified/sql/sqltemplate/mocks/test_snapshots.go index 9fda62e1302..6fbfe3e9eb3 100644 --- a/pkg/storage/unified/sql/sqltemplate/mocks/test_snapshots.go +++ b/pkg/storage/unified/sql/sqltemplate/mocks/test_snapshots.go @@ -14,13 +14,13 @@ import ( "github.com/stretchr/testify/require" ) -func NewTestingSQLTemplate() sqltemplate.SQLTemplateIface { +func NewTestingSQLTemplate() sqltemplate.SQLTemplate { standard := sqltemplate.New(sqltemplate.MySQL) // dialect gets replaced at each iteration return &testingSQLTemplate{standard} } type testingSQLTemplate struct { - *sqltemplate.SQLTemplate + sqltemplate.SQLTemplate } func (t *testingSQLTemplate) Arg(x any) string { @@ -69,7 +69,7 @@ type TemplateTestCase struct { Name string // Data should be the struct passed to the template. - Data sqltemplate.SQLTemplateIface + Data sqltemplate.SQLTemplate } type TemplateTestSetup struct { diff --git a/pkg/storage/unified/sql/sqltemplate/sqltemplate.go b/pkg/storage/unified/sql/sqltemplate/sqltemplate.go index f44df7414fb..895a0fcd654 100644 --- a/pkg/storage/unified/sql/sqltemplate/sqltemplate.go +++ b/pkg/storage/unified/sql/sqltemplate/sqltemplate.go @@ -13,58 +13,58 @@ var ( ErrSQLTemplateNoSerialize = errors.New("SQLTemplate should not be serialized") // Make sure SQLTemplate implements the interface - _ SQLTemplateIface = (*SQLTemplate)(nil) + _ SQLTemplate = (*sqlTemplate)(nil) ) // SQLTemplate provides comprehensive support for SQL templating, handling // dialect traits, execution arguments and scanning arguments. -type SQLTemplate struct { +type sqlTemplate struct { Dialect - *Args - *ScanDest + Args + ScanDest } // New returns a nee *SQLTemplate that will use the given dialect. -func New(d Dialect) *SQLTemplate { - ret := new(SQLTemplate) - ret.ScanDest = new(ScanDest) +func New(d Dialect) SQLTemplate { + ret := new(sqlTemplate) + ret.ScanDest = new(scanDest) ret.Args = NewArgs(d) ret.SetDialect(d) return ret } -func (t *SQLTemplate) Reset() { +func (t *sqlTemplate) Reset() { t.Args.Reset() t.ScanDest.Reset() } -func (t *SQLTemplate) SetDialect(d Dialect) { +func (t *sqlTemplate) SetDialect(d Dialect) { t.Reset() t.Dialect = d - t.Args.d = d + t.Args = NewArgs(d) } -func (t *SQLTemplate) Validate() error { +func (t *sqlTemplate) Validate() error { return ErrValidationNotImplemented } -func (t *SQLTemplate) MarshalJSON() ([]byte, error) { +func (t *sqlTemplate) MarshalJSON() ([]byte, error) { return nil, ErrSQLTemplateNoSerialize } -func (t *SQLTemplate) UnmarshalJSON([]byte) error { +func (t *sqlTemplate) UnmarshalJSON([]byte) error { return ErrSQLTemplateNoSerialize } -//go:generate mockery --with-expecter --name SQLTemplateIface +//go:generate mockery --with-expecter --name SQLTemplate -// SQLTemplateIface can be used as argument in general purpose utilities +// SQLTemplate can be used as argument in general purpose utilities // expecting a struct embedding *SQLTemplate. -type SQLTemplateIface interface { +type SQLTemplate interface { Dialect - ArgsIface - ScanDestIface - // Reset calls the Reset method of ArgsIface and ScanDestIface. + Args + ScanDest + // Reset calls the Reset method of Args and ScanDest. Reset() // SetDialect allows reusing the template components. It should first call // Reset. @@ -79,7 +79,7 @@ type SQLTemplateIface interface { // WithResults has an additional method suited for structs embedding // *SQLTemplate and returning a set of rows. type WithResults[T any] interface { - SQLTemplateIface + SQLTemplate // Results returns the results of the query. If the query is expected to // return a set of rows, then it should be a deep copy of the internal