IntenseWebs/grafana
3
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2026-08-26 13:27:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

SQLTemplate: Swap the IFace with the concrete struct (#92008)

Browse Source
This commit is contained in:
Ryan McKinley
2024-08-16 15:12:37 +03:00
committed by GitHub
parent 32a5651e96
commit f432a1713b
19 changed files with 271 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/registry/apis/dashboard/legacy/queries.go
+1 -1
View File
@@ -29,7 +29,7 @@ var (
) )
type sqlQuery struct { type sqlQuery struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
Query *DashboardQuery Query *DashboardQuery
} }
pkg/registry/apis/dashboard/legacy/queries_test.go
+5 -5
View File
@@ -15,7 +15,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "history_uid", Name: "history_uid",
Data: &sqlQuery{ Data: &sqlQuery{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &DashboardQuery{ Query: &DashboardQuery{
OrgID: 2, OrgID: 2,
UID: "UUU", UID: "UUU",
@@ -25,7 +25,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "history_uid_at_version", Name: "history_uid_at_version",
Data: &sqlQuery{ Data: &sqlQuery{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &DashboardQuery{ Query: &DashboardQuery{
OrgID: 2, OrgID: 2,
UID: "UUU", UID: "UUU",
@@ -36,7 +36,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "history_uid_second_page", Name: "history_uid_second_page",
Data: &sqlQuery{ Data: &sqlQuery{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &DashboardQuery{ Query: &DashboardQuery{
OrgID: 2, OrgID: 2,
UID: "UUU", UID: "UUU",
@@ -47,7 +47,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "dashboard", Name: "dashboard",
Data: &sqlQuery{ Data: &sqlQuery{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &DashboardQuery{ Query: &DashboardQuery{
OrgID: 2, OrgID: 2,
}, },
@@ -56,7 +56,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "dashboard_next_page", Name: "dashboard_next_page",
Data: &sqlQuery{ Data: &sqlQuery{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &DashboardQuery{ Query: &DashboardQuery{
OrgID: 2, OrgID: 2,
LastID: 22, LastID: 22,
pkg/registry/apis/dashboard/legacy/sql_dashboards.go
+2 -2
View File
@@ -92,8 +92,8 @@ func (a *dashboardSqlAccess) getRows(ctx context.Context, query *DashboardQuery)
} }
req := sqlQuery{ req := sqlQuery{
SQLTemplateIface: sqltemplate.New(a.dialect), SQLTemplate: sqltemplate.New(a.dialect),
Query: query, Query: query,
} }
tmpl := sqlQueryDashboards tmpl := sqlQueryDashboards
pkg/registry/apis/identity/legacy/legacy_sql.go
+7 -7
View File
@@ -55,8 +55,8 @@ func (s *legacySQLStore) ListTeams(ctx context.Context, ns claims.NamespaceInfo,
} }
req := sqlQueryListTeams{ req := sqlQueryListTeams{
SQLTemplateIface: sqltemplate.New(s.dialect), SQLTemplate: sqltemplate.New(s.dialect),
Query: &query, Query: &query,
} }
rawQuery, err := sqltemplate.Execute(sqlQueryTeams, req) 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{ return s.queryUsers(ctx, sqlQueryUsers, sqlQueryListUsers{
SQLTemplateIface: sqltemplate.New(s.dialect), SQLTemplate: sqltemplate.New(s.dialect),
Query: &query, Query: &query,
}, limit, query.UID != "") }, 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) rawQuery, err := sqltemplate.Execute(t, req)
if err != nil { if err != nil {
return nil, fmt.Errorf("execute template %q: %w", sqlQueryUsers.Name(), err) 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{ return s.queryUsers(ctx, sqlQueryDisplay, sqlQueryGetDisplay{
SQLTemplateIface: sqltemplate.New(s.dialect), SQLTemplate: sqltemplate.New(s.dialect),
Query: &query, Query: &query,
}, 10000, false) }, 10000, false)
} }
pkg/registry/apis/identity/legacy/queries.go
+3 -3
View File
@@ -31,7 +31,7 @@ var (
) )
type sqlQueryListUsers struct { type sqlQueryListUsers struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
Query *ListUserQuery Query *ListUserQuery
} }
@@ -40,7 +40,7 @@ func (r sqlQueryListUsers) Validate() error {
} }
type sqlQueryListTeams struct { type sqlQueryListTeams struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
Query *ListTeamQuery Query *ListTeamQuery
} }
@@ -49,7 +49,7 @@ func (r sqlQueryListTeams) Validate() error {
} }
type sqlQueryGetDisplay struct { type sqlQueryGetDisplay struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
Query *GetUserDisplayQuery Query *GetUserDisplayQuery
} }
pkg/registry/apis/identity/legacy/queries_test.go
+9 -9
View File
@@ -15,7 +15,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "teams_uid", Name: "teams_uid",
Data: &sqlQueryListTeams{ Data: &sqlQueryListTeams{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &ListTeamQuery{ Query: &ListTeamQuery{
UID: "abc", UID: "abc",
}, },
@@ -24,7 +24,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "teams_page_1", Name: "teams_page_1",
Data: &sqlQueryListTeams{ Data: &sqlQueryListTeams{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &ListTeamQuery{ Query: &ListTeamQuery{
Limit: 5, Limit: 5,
}, },
@@ -33,7 +33,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "teams_page_2", Name: "teams_page_2",
Data: &sqlQueryListTeams{ Data: &sqlQueryListTeams{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &ListTeamQuery{ Query: &ListTeamQuery{
ContinueID: 1, ContinueID: 1,
Limit: 2, Limit: 2,
@@ -45,7 +45,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "users_uid", Name: "users_uid",
Data: &sqlQueryListUsers{ Data: &sqlQueryListUsers{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &ListUserQuery{ Query: &ListUserQuery{
UID: "abc", UID: "abc",
}, },
@@ -54,7 +54,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "users_page_1", Name: "users_page_1",
Data: &sqlQueryListUsers{ Data: &sqlQueryListUsers{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &ListUserQuery{ Query: &ListUserQuery{
Limit: 5, Limit: 5,
}, },
@@ -63,7 +63,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "users_page_2", Name: "users_page_2",
Data: &sqlQueryListUsers{ Data: &sqlQueryListUsers{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &ListUserQuery{ Query: &ListUserQuery{
ContinueID: 1, ContinueID: 1,
Limit: 2, Limit: 2,
@@ -75,7 +75,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "display_uids", Name: "display_uids",
Data: &sqlQueryGetDisplay{ Data: &sqlQueryGetDisplay{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &GetUserDisplayQuery{ Query: &GetUserDisplayQuery{
OrgID: 2, OrgID: 2,
UIDs: []string{"a", "b"}, UIDs: []string{"a", "b"},
@@ -85,7 +85,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "display_ids", Name: "display_ids",
Data: &sqlQueryGetDisplay{ Data: &sqlQueryGetDisplay{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &GetUserDisplayQuery{ Query: &GetUserDisplayQuery{
OrgID: 2, OrgID: 2,
IDs: []int64{1, 2}, IDs: []int64{1, 2},
@@ -95,7 +95,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "display_ids_uids", Name: "display_ids_uids",
Data: &sqlQueryGetDisplay{ Data: &sqlQueryGetDisplay{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Query: &GetUserDisplayQuery{ Query: &GetUserDisplayQuery{
OrgID: 2, OrgID: 2,
UIDs: []string{"a", "b"}, UIDs: []string{"a", "b"},
pkg/storage/unified/sql/backend.go
+56 -56
View File
@@ -136,18 +136,18 @@ func (b *backend) create(ctx context.Context, event resource.WriteEvent) (int64,
// 1. Insert into resource // 1. Insert into resource
if _, err := dbutil.Exec(ctx, tx, sqlResourceInsert, sqlResourceRequest{ if _, err := dbutil.Exec(ctx, tx, sqlResourceInsert, sqlResourceRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
WriteEvent: event, WriteEvent: event,
GUID: guid, GUID: guid,
}); err != nil { }); err != nil {
return fmt.Errorf("insert into resource: %w", err) return fmt.Errorf("insert into resource: %w", err)
} }
// 2. Insert into resource history // 2. Insert into resource history
if _, err := dbutil.Exec(ctx, tx, sqlResourceHistoryInsert, sqlResourceRequest{ if _, err := dbutil.Exec(ctx, tx, sqlResourceHistoryInsert, sqlResourceRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
WriteEvent: event, WriteEvent: event,
GUID: guid, GUID: guid,
}); err != nil { }); err != nil {
return fmt.Errorf("insert into resource history: %w", err) 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 // 5. Update the RV in both resource and resource_history
if _, err = dbutil.Exec(ctx, tx, sqlResourceHistoryUpdateRV, sqlResourceUpdateRVRequest{ if _, err = dbutil.Exec(ctx, tx, sqlResourceHistoryUpdateRV, sqlResourceUpdateRVRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
GUID: guid, GUID: guid,
ResourceVersion: rv, ResourceVersion: rv,
}); err != nil { }); err != nil {
return fmt.Errorf("update resource_history rv: %w", err) return fmt.Errorf("update resource_history rv: %w", err)
} }
if _, err = dbutil.Exec(ctx, tx, sqlResourceUpdateRV, sqlResourceUpdateRVRequest{ if _, err = dbutil.Exec(ctx, tx, sqlResourceUpdateRV, sqlResourceUpdateRVRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
GUID: guid, GUID: guid,
ResourceVersion: rv, ResourceVersion: rv,
}); err != nil { }); err != nil {
return fmt.Errorf("update resource rv: %w", err) 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 // 1. Update resource
_, err := dbutil.Exec(ctx, tx, sqlResourceUpdate, sqlResourceRequest{ _, err := dbutil.Exec(ctx, tx, sqlResourceUpdate, sqlResourceRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
WriteEvent: event, WriteEvent: event,
GUID: guid, GUID: guid,
}) })
if err != nil { if err != nil {
return fmt.Errorf("initial resource update: %w", err) 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 // 2. Insert into resource history
if _, err := dbutil.Exec(ctx, tx, sqlResourceHistoryInsert, sqlResourceRequest{ if _, err := dbutil.Exec(ctx, tx, sqlResourceHistoryInsert, sqlResourceRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
WriteEvent: event, WriteEvent: event,
GUID: guid, GUID: guid,
}); err != nil { }); err != nil {
return fmt.Errorf("insert into resource history: %w", err) 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 // 5. Update the RV in both resource and resource_history
if _, err = dbutil.Exec(ctx, tx, sqlResourceHistoryUpdateRV, sqlResourceUpdateRVRequest{ if _, err = dbutil.Exec(ctx, tx, sqlResourceHistoryUpdateRV, sqlResourceUpdateRVRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
GUID: guid, GUID: guid,
ResourceVersion: rv, ResourceVersion: rv,
}); err != nil { }); err != nil {
return fmt.Errorf("update history rv: %w", err) return fmt.Errorf("update history rv: %w", err)
} }
if _, err = dbutil.Exec(ctx, tx, sqlResourceUpdateRV, sqlResourceUpdateRVRequest{ if _, err = dbutil.Exec(ctx, tx, sqlResourceUpdateRV, sqlResourceUpdateRVRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
GUID: guid, GUID: guid,
ResourceVersion: rv, ResourceVersion: rv,
}); err != nil { }); err != nil {
return fmt.Errorf("update resource rv: %w", err) 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 // 1. delete from resource
_, err := dbutil.Exec(ctx, tx, sqlResourceDelete, sqlResourceRequest{ _, err := dbutil.Exec(ctx, tx, sqlResourceDelete, sqlResourceRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
WriteEvent: event, WriteEvent: event,
GUID: guid, GUID: guid,
}) })
if err != nil { if err != nil {
return fmt.Errorf("delete resource: %w", err) 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 // 2. Add event to resource history
if _, err := dbutil.Exec(ctx, tx, sqlResourceHistoryInsert, sqlResourceRequest{ if _, err := dbutil.Exec(ctx, tx, sqlResourceHistoryInsert, sqlResourceRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
WriteEvent: event, WriteEvent: event,
GUID: guid, GUID: guid,
}); err != nil { }); err != nil {
return fmt.Errorf("insert into resource history: %w", err) 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 // 5. Update the RV in resource_history
if _, err = dbutil.Exec(ctx, tx, sqlResourceHistoryUpdateRV, sqlResourceUpdateRVRequest{ if _, err = dbutil.Exec(ctx, tx, sqlResourceHistoryUpdateRV, sqlResourceUpdateRVRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
GUID: guid, GUID: guid,
ResourceVersion: rv, ResourceVersion: rv,
}); err != nil { }); err != nil {
return fmt.Errorf("update history rv: %w", err) 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 ? // TODO: validate key ?
readReq := sqlResourceReadRequest{ readReq := sqlResourceReadRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
Request: req, Request: req,
readResponse: new(readResponse), readResponse: new(readResponse),
} }
sr := sqlResourceRead sr := sqlResourceRead
@@ -418,8 +418,8 @@ func (b *backend) listLatest(ctx context.Context, req *resource.ListRequest, cb
} }
listReq := sqlResourceListRequest{ listReq := sqlResourceListRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
Request: new(resource.ListRequest), Request: new(resource.ListRequest),
} }
listReq.Request = proto.Clone(req).(*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 limit = math.MaxInt64 // a limit is required for offset
} }
listReq := sqlResourceHistoryListRequest{ listReq := sqlResourceHistoryListRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
Request: &historyListRequest{ Request: &historyListRequest{
ResourceVersion: iter.listRV, ResourceVersion: iter.listRV,
Limit: limit, 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) { func (b *backend) listLatestRVs(ctx context.Context) (groupResourceRV, error) {
since := groupResourceRV{} since := groupResourceRV{}
reqRVs := sqlResourceVersionListRequest{ reqRVs := sqlResourceVersionListRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
groupResourceVersion: new(groupResourceVersion), groupResourceVersion: new(groupResourceVersion),
} }
query, err := sqltemplate.Execute(sqlResourceVersionList, reqRVs) 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 // 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) { func fetchLatestRV(ctx context.Context, x db.ContextExecer, d sqltemplate.Dialect, group, resource string) (int64, error) {
res, err := dbutil.QueryRow(ctx, x, sqlResourceVersionGet, sqlResourceVersionRequest{ res, err := dbutil.QueryRow(ctx, x, sqlResourceVersionGet, sqlResourceVersionRequest{
SQLTemplateIface: sqltemplate.New(d), SQLTemplate: sqltemplate.New(d),
Group: group, Group: group,
Resource: resource, Resource: resource,
ReadOnly: true, ReadOnly: true,
resourceVersion: new(resourceVersion), resourceVersion: new(resourceVersion),
}) })
if errors.Is(err, sql.ErrNoRows) { if errors.Is(err, sql.ErrNoRows) {
return 1, nil return 1, nil
@@ -604,7 +604,7 @@ func (b *backend) poll(ctx context.Context, grp string, res string, since int64,
defer span.End() defer span.End()
pollReq := sqlResourceHistoryPollRequest{ pollReq := sqlResourceHistoryPollRequest{
SQLTemplateIface: sqltemplate.New(b.dialect), SQLTemplate: sqltemplate.New(b.dialect),
Resource: res, Resource: res,
Group: grp, Group: grp,
SinceResourceVersion: since, 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. // 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 // 1 Lock the row for update
rv, err := dbutil.QueryRow(ctx, x, sqlResourceVersionGet, sqlResourceVersionRequest{ rv, err := dbutil.QueryRow(ctx, x, sqlResourceVersionGet, sqlResourceVersionRequest{
SQLTemplateIface: sqltemplate.New(d), SQLTemplate: sqltemplate.New(d),
Group: key.Group, Group: key.Group,
Resource: key.Resource, Resource: key.Resource,
resourceVersion: new(resourceVersion), resourceVersion: new(resourceVersion),
}) })
if errors.Is(err, sql.ErrNoRows) { if errors.Is(err, sql.ErrNoRows) {
// if there wasn't a row associated with the given resource, we create one with // if there wasn't a row associated with the given resource, we create one with
// version 1 // version 1
if _, err = dbutil.Exec(ctx, x, sqlResourceVersionInsert, sqlResourceVersionRequest{ if _, err = dbutil.Exec(ctx, x, sqlResourceVersionInsert, sqlResourceVersionRequest{
SQLTemplateIface: sqltemplate.New(d), SQLTemplate: sqltemplate.New(d),
Group: key.Group, Group: key.Group,
Resource: key.Resource, Resource: key.Resource,
}); err != nil { }); err != nil {
return 0, fmt.Errorf("insert into resource_version: %w", err) 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 // 2. Increment the resource version
_, err = dbutil.Exec(ctx, x, sqlResourceVersionInc, sqlResourceVersionRequest{ _, err = dbutil.Exec(ctx, x, sqlResourceVersionInc, sqlResourceVersionRequest{
SQLTemplateIface: sqltemplate.New(d), SQLTemplate: sqltemplate.New(d),
Group: key.Group, Group: key.Group,
Resource: key.Resource, Resource: key.Resource,
resourceVersion: &resourceVersion{ resourceVersion: &resourceVersion{
ResourceVersion: nextRV, ResourceVersion: nextRV,
}, },
pkg/storage/unified/sql/dbutil/dbutil.go
+2 -2
View File
@@ -79,7 +79,7 @@ func Debug(err error) error {
// Exec uses `req` as input for a non-data returning query generated with // Exec uses `req` as input for a non-data returning query generated with
// `tmpl`, and executed in `x`. // `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 { if err := req.Validate(); err != nil {
return nil, fmt.Errorf("Exec: invalid request for template %q: %w", return nil, fmt.Errorf("Exec: invalid request for template %q: %w",
tmpl.Name(), err) 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 // Query uses `req` as input for a single-statement, set-returning query
// generated with `tmpl`, and executed in `x`. // 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 { if err := req.Validate(); err != nil {
return nil, fmt.Errorf("Query: invalid request for template %q: %w", return nil, fmt.Errorf("Query: invalid request for template %q: %w",
tmpl.Name(), err) tmpl.Name(), err)
pkg/storage/unified/sql/dbutil/dbutil_test.go
+4 -4
View File
@@ -441,7 +441,7 @@ func TestExec(t *testing.T) {
// test declarations // test declarations
ctx := testutil.NewDefaultTestContext(t) ctx := testutil.NewDefaultTestContext(t)
req := sqltemplateMocks.NewSQLTemplateIface(t) req := sqltemplateMocks.NewSQLTemplate(t)
rdb := test.NewDBProviderNopSQL(t) rdb := test.NewDBProviderNopSQL(t)
// setup expectations // setup expectations
@@ -460,7 +460,7 @@ func TestExec(t *testing.T) {
// test declarations // test declarations
ctx := testutil.NewDefaultTestContext(t) ctx := testutil.NewDefaultTestContext(t)
req := sqltemplateMocks.NewSQLTemplateIface(t) req := sqltemplateMocks.NewSQLTemplate(t)
rdb := test.NewDBProviderNopSQL(t) rdb := test.NewDBProviderNopSQL(t)
// setup expectations // setup expectations
@@ -478,7 +478,7 @@ func TestExec(t *testing.T) {
// test declarations // test declarations
ctx := testutil.NewDefaultTestContext(t) ctx := testutil.NewDefaultTestContext(t)
req := sqltemplateMocks.NewSQLTemplateIface(t) req := sqltemplateMocks.NewSQLTemplate(t)
rdb := test.NewDBProviderNopSQL(t) rdb := test.NewDBProviderNopSQL(t)
// setup expectations // setup expectations
@@ -496,7 +496,7 @@ func TestExec(t *testing.T) {
// test declarations // test declarations
ctx := testutil.NewDefaultTestContext(t) ctx := testutil.NewDefaultTestContext(t)
req := sqltemplateMocks.NewSQLTemplateIface(t) req := sqltemplateMocks.NewSQLTemplate(t)
rdb := test.NewDBProviderNopSQL(t) rdb := test.NewDBProviderNopSQL(t)
// setup expectations // setup expectations
pkg/storage/unified/sql/queries.go
+8 -8
View File
@@ -58,7 +58,7 @@ var (
) )
type sqlResourceRequest struct { type sqlResourceRequest struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
GUID string GUID string
WriteEvent resource.WriteEvent WriteEvent resource.WriteEvent
} }
@@ -80,7 +80,7 @@ func (r *historyPollResponse) Results() (*historyPollResponse, error) {
type groupResourceRV map[string]map[string]int64 type groupResourceRV map[string]map[string]int64
type sqlResourceHistoryPollRequest struct { type sqlResourceHistoryPollRequest struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
Resource string Resource string
Group string Group string
SinceResourceVersion int64 SinceResourceVersion int64
@@ -102,7 +102,7 @@ func (r *readResponse) Results() (*readResponse, error) {
} }
type sqlResourceReadRequest struct { type sqlResourceReadRequest struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
Request *resource.ReadRequest Request *resource.ReadRequest
*readResponse *readResponse
} }
@@ -113,7 +113,7 @@ func (r sqlResourceReadRequest) Validate() error {
// List // List
type sqlResourceListRequest struct { type sqlResourceListRequest struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
Request *resource.ListRequest Request *resource.ListRequest
} }
@@ -126,7 +126,7 @@ type historyListRequest struct {
Options *resource.ListOptions Options *resource.ListOptions
} }
type sqlResourceHistoryListRequest struct { type sqlResourceHistoryListRequest struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
Request *historyListRequest Request *historyListRequest
Response *resource.ResourceWrapper Response *resource.ResourceWrapper
} }
@@ -150,7 +150,7 @@ func (r sqlResourceHistoryListRequest) Results() (*resource.ResourceWrapper, err
// update RV // update RV
type sqlResourceUpdateRVRequest struct { type sqlResourceUpdateRVRequest struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
GUID string GUID string
ResourceVersion int64 ResourceVersion int64
} }
@@ -174,7 +174,7 @@ func (r *resourceVersion) Results() (*resourceVersion, error) {
} }
type sqlResourceVersionRequest struct { type sqlResourceVersionRequest struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
Group, Resource string Group, Resource string
ReadOnly bool ReadOnly bool
*resourceVersion *resourceVersion
@@ -185,7 +185,7 @@ func (r sqlResourceVersionRequest) Validate() error {
} }
type sqlResourceVersionListRequest struct { type sqlResourceVersionListRequest struct {
sqltemplate.SQLTemplateIface sqltemplate.SQLTemplate
*groupResourceVersion *groupResourceVersion
} }
pkg/storage/unified/sql/queries_test.go
+15 -15
View File
@@ -16,7 +16,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "simple", Name: "simple",
Data: &sqlResourceRequest{ Data: &sqlResourceRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
WriteEvent: resource.WriteEvent{ WriteEvent: resource.WriteEvent{
Key: &resource.ResourceKey{ Key: &resource.ResourceKey{
Namespace: "nn", Namespace: "nn",
@@ -32,7 +32,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "simple", Name: "simple",
Data: &sqlResourceRequest{ Data: &sqlResourceRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
WriteEvent: resource.WriteEvent{ WriteEvent: resource.WriteEvent{
Key: &resource.ResourceKey{ Key: &resource.ResourceKey{
Namespace: "nn", Namespace: "nn",
@@ -50,7 +50,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "single path", Name: "single path",
Data: &sqlResourceRequest{ Data: &sqlResourceRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
WriteEvent: resource.WriteEvent{ WriteEvent: resource.WriteEvent{
Key: &resource.ResourceKey{}, Key: &resource.ResourceKey{},
}, },
@@ -61,7 +61,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "without_resource_version", Name: "without_resource_version",
Data: &sqlResourceReadRequest{ Data: &sqlResourceReadRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Request: &resource.ReadRequest{ Request: &resource.ReadRequest{
Key: &resource.ResourceKey{}, Key: &resource.ResourceKey{},
}, },
@@ -74,7 +74,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "filter_on_namespace", Name: "filter_on_namespace",
Data: &sqlResourceListRequest{ Data: &sqlResourceListRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Request: &resource.ListRequest{ Request: &resource.ListRequest{
Limit: 10, Limit: 10,
Options: &resource.ListOptions{ Options: &resource.ListOptions{
@@ -91,7 +91,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "single path", Name: "single path",
Data: &sqlResourceHistoryListRequest{ Data: &sqlResourceHistoryListRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Request: &historyListRequest{ Request: &historyListRequest{
Limit: 10, Limit: 10,
Options: &resource.ListOptions{ Options: &resource.ListOptions{
@@ -109,7 +109,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "single path", Name: "single path",
Data: &sqlResourceUpdateRVRequest{ Data: &sqlResourceUpdateRVRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
}, },
}, },
}, },
@@ -118,7 +118,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "single path", Name: "single path",
Data: &sqlResourceReadRequest{ Data: &sqlResourceReadRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
Request: &resource.ReadRequest{ Request: &resource.ReadRequest{
ResourceVersion: 123, ResourceVersion: 123,
Key: &resource.ResourceKey{}, Key: &resource.ResourceKey{},
@@ -132,7 +132,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "single path", Name: "single path",
Data: &sqlResourceUpdateRVRequest{ Data: &sqlResourceUpdateRVRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
}, },
}, },
}, },
@@ -141,7 +141,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "insert into resource_history", Name: "insert into resource_history",
Data: &sqlResourceRequest{ Data: &sqlResourceRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
WriteEvent: resource.WriteEvent{ WriteEvent: resource.WriteEvent{
Key: &resource.ResourceKey{}, Key: &resource.ResourceKey{},
}, },
@@ -153,9 +153,9 @@ func TestQueries(t *testing.T) {
{ {
Name: "single path", Name: "single path",
Data: &sqlResourceVersionRequest{ Data: &sqlResourceVersionRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
resourceVersion: new(resourceVersion), resourceVersion: new(resourceVersion),
ReadOnly: false, ReadOnly: false,
}, },
}, },
}, },
@@ -164,7 +164,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "increment resource version", Name: "increment resource version",
Data: &sqlResourceVersionRequest{ Data: &sqlResourceVersionRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
resourceVersion: &resourceVersion{ resourceVersion: &resourceVersion{
ResourceVersion: 123, ResourceVersion: 123,
}, },
@@ -176,7 +176,7 @@ func TestQueries(t *testing.T) {
{ {
Name: "single path", Name: "single path",
Data: &sqlResourceVersionRequest{ Data: &sqlResourceVersionRequest{
SQLTemplateIface: mocks.NewTestingSQLTemplate(), SQLTemplate: mocks.NewTestingSQLTemplate(),
}, },
}, },
}, },
pkg/storage/unified/sql/sqltemplate/args.go
+8 -8
View File
@@ -15,20 +15,20 @@ var (
// the right order. Add it to your data types passed to SQLTemplate, either by // 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 // embedding or with a named struct field if its Arg method would clash with
// another struct field. // another struct field.
type Args struct { type args struct {
d interface{ ArgPlaceholder(argNum int) string } d interface{ ArgPlaceholder(argNum int) string }
values []any values []any
} }
func NewArgs(d Dialect) *Args { func NewArgs(d Dialect) Args {
return &Args{ return &args{
d: d, d: d,
} }
} }
// Arg can be called from within templates to pass arguments to the SQL driver // Arg can be called from within templates to pass arguments to the SQL driver
// to use in the execution of the query. // 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) a.values = append(a.values, x)
return a.d.ArgPlaceholder(len(a.values)) return a.d.ArgPlaceholder(len(a.values))
@@ -48,7 +48,7 @@ func (a *Args) Arg(x any) string {
// DELETE FROM {{ .Ident "mytab" }} // DELETE FROM {{ .Ident "mytab" }}
// WHERE id IN ( {{ argList . .IDs }} ) // 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 { if !slice.IsValid() || slice.Kind() != reflect.Slice {
return "", ErrInvalidArgList return "", ErrInvalidArgList
} }
@@ -69,15 +69,15 @@ func (a *Args) ArgList(slice reflect.Value) (string, error) {
return b.String(), nil return b.String(), nil
} }
func (a *Args) Reset() { func (a *args) Reset() {
a.values = nil a.values = nil
} }
func (a *Args) GetArgs() []any { func (a *args) GetArgs() []any {
return a.values return a.values
} }
type ArgsIface interface { type Args interface {
Arg(x any) string Arg(x any) string
ArgList(slice reflect.Value) (string, error) ArgList(slice reflect.Value) (string, error)
GetArgs() []any GetArgs() []any
pkg/storage/unified/sql/sqltemplate/args_test.go
+1 -1
View File
@@ -70,7 +70,7 @@ func TestArg_ArgList(t *testing.T) {
}, },
} }
var a Args var a args
a.d = argFmtSQL92 a.d = argFmtSQL92
for i, tc := range testCases { for i, tc := range testCases {
a.Reset() a.Reset()
pkg/storage/unified/sql/sqltemplate/example_test.go
+7 -7
View File
@@ -47,7 +47,7 @@ type GetUserResponse struct {
// the methods to achieve our purpose:: // the methods to achieve our purpose::
type GetUserQuery struct { type GetUserQuery struct {
*SQLTemplate SQLTemplate
Request *GetUserRequest Request *GetUserRequest
Response *GetUserResponse Response *GetUserResponse
} }
@@ -109,11 +109,11 @@ func Example() {
// As we're not actually running a database in this example, let's verify // As we're not actually running a database in this example, let's verify
// that we find our arguments populated as expected instead: // that we find our arguments populated as expected instead:
if len(queryData.GetArgs()) != 1 { 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) id, ok := queryData.GetArgs()[0].(int)
if !ok || id != queryData.Request.ID { 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, // 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 // the expected data, which should be pointers to each of the fields of
// Response so that the Scan method can write to them: // Response so that the Scan method can write to them:
if len(queryData.GetScanDest()) != 3 { 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) idPtr, ok := queryData.GetScanDest()[0].(*int)
if !ok || idPtr != &queryData.Response.ID { 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) typePtr, ok := queryData.GetScanDest()[1].(*string)
if !ok || typePtr != &queryData.Response.Type { 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) namePtr, ok := queryData.GetScanDest()[2].(*string)
if !ok || namePtr != &queryData.Response.Name { 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 // Remember the variable "query"? Well, we didn't check it. We will now make
pkg/storage/unified/sql/sqltemplate/into.go
+6 -6
View File
@@ -5,12 +5,12 @@ import (
"reflect" "reflect"
) )
type ScanDest struct { type scanDest struct {
values []any values []any
colNames []string 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() { if !v.IsValid() || !v.CanAddr() || !v.Addr().CanInterface() {
return "", fmt.Errorf("invalid or unaddressable value: %v", colName) 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 return colName, nil
} }
func (i *ScanDest) Reset() { func (i *scanDest) Reset() {
i.values = nil i.values = nil
} }
func (i *ScanDest) GetScanDest() []any { func (i *scanDest) GetScanDest() []any {
return i.values return i.values
} }
func (i *ScanDest) GetColNames() []string { func (i *scanDest) GetColNames() []string {
return i.colNames return i.colNames
} }
type ScanDestIface interface { type ScanDest interface {
Into(v reflect.Value, colName string) (string, error) Into(v reflect.Value, colName string) (string, error)
GetScanDest() []any GetScanDest() []any
GetColNames() []string GetColNames() []string
pkg/storage/unified/sql/sqltemplate/into_test.go
+1 -1
View File
@@ -9,7 +9,7 @@ import (
func TestScanDest_Into(t *testing.T) { func TestScanDest_Into(t *testing.T) {
t.Parallel() t.Parallel()
var d ScanDest var d scanDest
colName, err := d.Into(reflect.Value{}, "some field") colName, err := d.Into(reflect.Value{}, "some field")
if colName != "" || err == nil || len(d.GetScanDest()) != 0 { if colName != "" || err == nil || len(d.GetScanDest()) != 0 {
pkg/storage/unified/sql/sqltemplate/mocks/SQLTemplateIface.go
+113 -113
View File
@@ -10,21 +10,21 @@ import (
sqltemplate "github.com/grafana/grafana/pkg/storage/unified/sql/sqltemplate" sqltemplate "github.com/grafana/grafana/pkg/storage/unified/sql/sqltemplate"
) )
// SQLTemplateIface is an autogenerated mock type for the SQLTemplateIface type // SQLTemplate is an autogenerated mock type for the SQLTemplate type
type SQLTemplateIface struct { type SQLTemplate struct {
mock.Mock mock.Mock
} }
type SQLTemplateIface_Expecter struct { type SQLTemplate_Expecter struct {
mock *mock.Mock mock *mock.Mock
} }
func (_m *SQLTemplateIface) EXPECT() *SQLTemplateIface_Expecter { func (_m *SQLTemplate) EXPECT() *SQLTemplate_Expecter {
return &SQLTemplateIface_Expecter{mock: &_m.Mock} return &SQLTemplate_Expecter{mock: &_m.Mock}
} }
// Arg provides a mock function with given fields: x // 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) ret := _m.Called(x)
if len(ret) == 0 { if len(ret) == 0 {
@@ -41,36 +41,36 @@ func (_m *SQLTemplateIface) Arg(x interface{}) string {
return r0 return r0
} }
// SQLTemplateIface_Arg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Arg' // SQLTemplate_Arg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Arg'
type SQLTemplateIface_Arg_Call struct { type SQLTemplate_Arg_Call struct {
*mock.Call *mock.Call
} }
// Arg is a helper method to define mock.On call // Arg is a helper method to define mock.On call
// - x interface{} // - x interface{}
func (_e *SQLTemplateIface_Expecter) Arg(x interface{}) *SQLTemplateIface_Arg_Call { func (_e *SQLTemplate_Expecter) Arg(x interface{}) *SQLTemplate_Arg_Call {
return &SQLTemplateIface_Arg_Call{Call: _e.mock.On("Arg", x)} 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) { _c.Call.Run(func(args mock.Arguments) {
run(args[0].(interface{})) run(args[0].(interface{}))
}) })
return _c 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) _c.Call.Return(_a0)
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// ArgList provides a mock function with given fields: slice // 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) ret := _m.Called(slice)
if len(ret) == 0 { if len(ret) == 0 {
@@ -97,36 +97,36 @@ func (_m *SQLTemplateIface) ArgList(slice reflect.Value) (string, error) {
return r0, r1 return r0, r1
} }
// SQLTemplateIface_ArgList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ArgList' // SQLTemplate_ArgList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ArgList'
type SQLTemplateIface_ArgList_Call struct { type SQLTemplate_ArgList_Call struct {
*mock.Call *mock.Call
} }
// ArgList is a helper method to define mock.On call // ArgList is a helper method to define mock.On call
// - slice reflect.Value // - slice reflect.Value
func (_e *SQLTemplateIface_Expecter) ArgList(slice interface{}) *SQLTemplateIface_ArgList_Call { func (_e *SQLTemplate_Expecter) ArgList(slice interface{}) *SQLTemplate_ArgList_Call {
return &SQLTemplateIface_ArgList_Call{Call: _e.mock.On("ArgList", slice)} 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) { _c.Call.Run(func(args mock.Arguments) {
run(args[0].(reflect.Value)) run(args[0].(reflect.Value))
}) })
return _c 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) _c.Call.Return(_a0, _a1)
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// ArgPlaceholder provides a mock function with given fields: argNum // 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) ret := _m.Called(argNum)
if len(ret) == 0 { if len(ret) == 0 {
@@ -143,36 +143,36 @@ func (_m *SQLTemplateIface) ArgPlaceholder(argNum int) string {
return r0 return r0
} }
// SQLTemplateIface_ArgPlaceholder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ArgPlaceholder' // SQLTemplate_ArgPlaceholder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ArgPlaceholder'
type SQLTemplateIface_ArgPlaceholder_Call struct { type SQLTemplate_ArgPlaceholder_Call struct {
*mock.Call *mock.Call
} }
// ArgPlaceholder is a helper method to define mock.On call // ArgPlaceholder is a helper method to define mock.On call
// - argNum int // - argNum int
func (_e *SQLTemplateIface_Expecter) ArgPlaceholder(argNum interface{}) *SQLTemplateIface_ArgPlaceholder_Call { func (_e *SQLTemplate_Expecter) ArgPlaceholder(argNum interface{}) *SQLTemplate_ArgPlaceholder_Call {
return &SQLTemplateIface_ArgPlaceholder_Call{Call: _e.mock.On("ArgPlaceholder", argNum)} 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) { _c.Call.Run(func(args mock.Arguments) {
run(args[0].(int)) run(args[0].(int))
}) })
return _c 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) _c.Call.Return(_a0)
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// DialectName provides a mock function with given fields: // DialectName provides a mock function with given fields:
func (_m *SQLTemplateIface) DialectName() string { func (_m *SQLTemplate) DialectName() string {
ret := _m.Called() ret := _m.Called()
if len(ret) == 0 { if len(ret) == 0 {
@@ -189,35 +189,35 @@ func (_m *SQLTemplateIface) DialectName() string {
return r0 return r0
} }
// SQLTemplateIface_DialectName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DialectName' // SQLTemplate_DialectName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DialectName'
type SQLTemplateIface_DialectName_Call struct { type SQLTemplate_DialectName_Call struct {
*mock.Call *mock.Call
} }
// DialectName is a helper method to define mock.On call // DialectName is a helper method to define mock.On call
func (_e *SQLTemplateIface_Expecter) DialectName() *SQLTemplateIface_DialectName_Call { func (_e *SQLTemplate_Expecter) DialectName() *SQLTemplate_DialectName_Call {
return &SQLTemplateIface_DialectName_Call{Call: _e.mock.On("DialectName")} 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) { _c.Call.Run(func(args mock.Arguments) {
run() run()
}) })
return _c 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) _c.Call.Return(_a0)
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// GetArgs provides a mock function with given fields: // GetArgs provides a mock function with given fields:
func (_m *SQLTemplateIface) GetArgs() []interface{} { func (_m *SQLTemplate) GetArgs() []interface{} {
ret := _m.Called() ret := _m.Called()
if len(ret) == 0 { if len(ret) == 0 {
@@ -236,35 +236,35 @@ func (_m *SQLTemplateIface) GetArgs() []interface{} {
return r0 return r0
} }
// SQLTemplateIface_GetArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetArgs' // SQLTemplate_GetArgs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetArgs'
type SQLTemplateIface_GetArgs_Call struct { type SQLTemplate_GetArgs_Call struct {
*mock.Call *mock.Call
} }
// GetArgs is a helper method to define mock.On call // GetArgs is a helper method to define mock.On call
func (_e *SQLTemplateIface_Expecter) GetArgs() *SQLTemplateIface_GetArgs_Call { func (_e *SQLTemplate_Expecter) GetArgs() *SQLTemplate_GetArgs_Call {
return &SQLTemplateIface_GetArgs_Call{Call: _e.mock.On("GetArgs")} 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) { _c.Call.Run(func(args mock.Arguments) {
run() run()
}) })
return _c 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) _c.Call.Return(_a0)
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// GetColNames provides a mock function with given fields: // GetColNames provides a mock function with given fields:
func (_m *SQLTemplateIface) GetColNames() []string { func (_m *SQLTemplate) GetColNames() []string {
ret := _m.Called() ret := _m.Called()
if len(ret) == 0 { if len(ret) == 0 {
@@ -283,35 +283,35 @@ func (_m *SQLTemplateIface) GetColNames() []string {
return r0 return r0
} }
// SQLTemplateIface_GetColNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetColNames' // SQLTemplate_GetColNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetColNames'
type SQLTemplateIface_GetColNames_Call struct { type SQLTemplate_GetColNames_Call struct {
*mock.Call *mock.Call
} }
// GetColNames is a helper method to define mock.On call // GetColNames is a helper method to define mock.On call
func (_e *SQLTemplateIface_Expecter) GetColNames() *SQLTemplateIface_GetColNames_Call { func (_e *SQLTemplate_Expecter) GetColNames() *SQLTemplate_GetColNames_Call {
return &SQLTemplateIface_GetColNames_Call{Call: _e.mock.On("GetColNames")} 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) { _c.Call.Run(func(args mock.Arguments) {
run() run()
}) })
return _c 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) _c.Call.Return(_a0)
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// GetScanDest provides a mock function with given fields: // GetScanDest provides a mock function with given fields:
func (_m *SQLTemplateIface) GetScanDest() []interface{} { func (_m *SQLTemplate) GetScanDest() []interface{} {
ret := _m.Called() ret := _m.Called()
if len(ret) == 0 { if len(ret) == 0 {
@@ -330,35 +330,35 @@ func (_m *SQLTemplateIface) GetScanDest() []interface{} {
return r0 return r0
} }
// SQLTemplateIface_GetScanDest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetScanDest' // SQLTemplate_GetScanDest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetScanDest'
type SQLTemplateIface_GetScanDest_Call struct { type SQLTemplate_GetScanDest_Call struct {
*mock.Call *mock.Call
} }
// GetScanDest is a helper method to define mock.On call // GetScanDest is a helper method to define mock.On call
func (_e *SQLTemplateIface_Expecter) GetScanDest() *SQLTemplateIface_GetScanDest_Call { func (_e *SQLTemplate_Expecter) GetScanDest() *SQLTemplate_GetScanDest_Call {
return &SQLTemplateIface_GetScanDest_Call{Call: _e.mock.On("GetScanDest")} 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) { _c.Call.Run(func(args mock.Arguments) {
run() run()
}) })
return _c 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) _c.Call.Return(_a0)
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// Ident provides a mock function with given fields: _a0 // 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) ret := _m.Called(_a0)
if len(ret) == 0 { if len(ret) == 0 {
@@ -385,36 +385,36 @@ func (_m *SQLTemplateIface) Ident(_a0 string) (string, error) {
return r0, r1 return r0, r1
} }
// SQLTemplateIface_Ident_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ident' // SQLTemplate_Ident_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ident'
type SQLTemplateIface_Ident_Call struct { type SQLTemplate_Ident_Call struct {
*mock.Call *mock.Call
} }
// Ident is a helper method to define mock.On call // Ident is a helper method to define mock.On call
// - _a0 string // - _a0 string
func (_e *SQLTemplateIface_Expecter) Ident(_a0 interface{}) *SQLTemplateIface_Ident_Call { func (_e *SQLTemplate_Expecter) Ident(_a0 interface{}) *SQLTemplate_Ident_Call {
return &SQLTemplateIface_Ident_Call{Call: _e.mock.On("Ident", _a0)} 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) { _c.Call.Run(func(args mock.Arguments) {
run(args[0].(string)) run(args[0].(string))
}) })
return _c 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) _c.Call.Return(_a0, _a1)
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// Into provides a mock function with given fields: v, colName // 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) ret := _m.Called(v, colName)
if len(ret) == 0 { if len(ret) == 0 {
@@ -441,69 +441,69 @@ func (_m *SQLTemplateIface) Into(v reflect.Value, colName string) (string, error
return r0, r1 return r0, r1
} }
// SQLTemplateIface_Into_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Into' // SQLTemplate_Into_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Into'
type SQLTemplateIface_Into_Call struct { type SQLTemplate_Into_Call struct {
*mock.Call *mock.Call
} }
// Into is a helper method to define mock.On call // Into is a helper method to define mock.On call
// - v reflect.Value // - v reflect.Value
// - colName string // - colName string
func (_e *SQLTemplateIface_Expecter) Into(v interface{}, colName interface{}) *SQLTemplateIface_Into_Call { func (_e *SQLTemplate_Expecter) Into(v interface{}, colName interface{}) *SQLTemplate_Into_Call {
return &SQLTemplateIface_Into_Call{Call: _e.mock.On("Into", v, colName)} 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) { _c.Call.Run(func(args mock.Arguments) {
run(args[0].(reflect.Value), args[1].(string)) run(args[0].(reflect.Value), args[1].(string))
}) })
return _c 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) _c.Call.Return(_a0, _a1)
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// Reset provides a mock function with given fields: // Reset provides a mock function with given fields:
func (_m *SQLTemplateIface) Reset() { func (_m *SQLTemplate) Reset() {
_m.Called() _m.Called()
} }
// SQLTemplateIface_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset' // SQLTemplate_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset'
type SQLTemplateIface_Reset_Call struct { type SQLTemplate_Reset_Call struct {
*mock.Call *mock.Call
} }
// Reset is a helper method to define mock.On call // Reset is a helper method to define mock.On call
func (_e *SQLTemplateIface_Expecter) Reset() *SQLTemplateIface_Reset_Call { func (_e *SQLTemplate_Expecter) Reset() *SQLTemplate_Reset_Call {
return &SQLTemplateIface_Reset_Call{Call: _e.mock.On("Reset")} 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) { _c.Call.Run(func(args mock.Arguments) {
run() run()
}) })
return _c return _c
} }
func (_c *SQLTemplateIface_Reset_Call) Return() *SQLTemplateIface_Reset_Call { func (_c *SQLTemplate_Reset_Call) Return() *SQLTemplate_Reset_Call {
_c.Call.Return() _c.Call.Return()
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// SelectFor provides a mock function with given fields: _a0 // 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)) _va := make([]interface{}, len(_a0))
for _i := range _a0 { for _i := range _a0 {
_va[_i] = _a0[_i] _va[_i] = _a0[_i]
@@ -536,19 +536,19 @@ func (_m *SQLTemplateIface) SelectFor(_a0 ...string) (string, error) {
return r0, r1 return r0, r1
} }
// SQLTemplateIface_SelectFor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectFor' // SQLTemplate_SelectFor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectFor'
type SQLTemplateIface_SelectFor_Call struct { type SQLTemplate_SelectFor_Call struct {
*mock.Call *mock.Call
} }
// SelectFor is a helper method to define mock.On call // SelectFor is a helper method to define mock.On call
// - _a0 ...string // - _a0 ...string
func (_e *SQLTemplateIface_Expecter) SelectFor(_a0 ...interface{}) *SQLTemplateIface_SelectFor_Call { func (_e *SQLTemplate_Expecter) SelectFor(_a0 ...interface{}) *SQLTemplate_SelectFor_Call {
return &SQLTemplateIface_SelectFor_Call{Call: _e.mock.On("SelectFor", return &SQLTemplate_SelectFor_Call{Call: _e.mock.On("SelectFor",
append([]interface{}{}, _a0...)...)} 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) { _c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]string, len(args)-0) variadicArgs := make([]string, len(args)-0)
for i, a := range 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 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) _c.Call.Return(_a0, _a1)
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// SetDialect provides a mock function with given fields: _a0 // 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) _m.Called(_a0)
} }
// SQLTemplateIface_SetDialect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDialect' // SQLTemplate_SetDialect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDialect'
type SQLTemplateIface_SetDialect_Call struct { type SQLTemplate_SetDialect_Call struct {
*mock.Call *mock.Call
} }
// SetDialect is a helper method to define mock.On call // SetDialect is a helper method to define mock.On call
// - _a0 sqltemplate.Dialect // - _a0 sqltemplate.Dialect
func (_e *SQLTemplateIface_Expecter) SetDialect(_a0 interface{}) *SQLTemplateIface_SetDialect_Call { func (_e *SQLTemplate_Expecter) SetDialect(_a0 interface{}) *SQLTemplate_SetDialect_Call {
return &SQLTemplateIface_SetDialect_Call{Call: _e.mock.On("SetDialect", _a0)} 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) { _c.Call.Run(func(args mock.Arguments) {
run(args[0].(sqltemplate.Dialect)) run(args[0].(sqltemplate.Dialect))
}) })
return _c return _c
} }
func (_c *SQLTemplateIface_SetDialect_Call) Return() *SQLTemplateIface_SetDialect_Call { func (_c *SQLTemplate_SetDialect_Call) Return() *SQLTemplate_SetDialect_Call {
_c.Call.Return() _c.Call.Return()
return _c 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) _c.Call.Return(run)
return _c return _c
} }
// Validate provides a mock function with given fields: // Validate provides a mock function with given fields:
func (_m *SQLTemplateIface) Validate() error { func (_m *SQLTemplate) Validate() error {
ret := _m.Called() ret := _m.Called()
if len(ret) == 0 { if len(ret) == 0 {
@@ -622,40 +622,40 @@ func (_m *SQLTemplateIface) Validate() error {
return r0 return r0
} }
// SQLTemplateIface_Validate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Validate' // SQLTemplate_Validate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Validate'
type SQLTemplateIface_Validate_Call struct { type SQLTemplate_Validate_Call struct {
*mock.Call *mock.Call
} }
// Validate is a helper method to define mock.On call // Validate is a helper method to define mock.On call
func (_e *SQLTemplateIface_Expecter) Validate() *SQLTemplateIface_Validate_Call { func (_e *SQLTemplate_Expecter) Validate() *SQLTemplate_Validate_Call {
return &SQLTemplateIface_Validate_Call{Call: _e.mock.On("Validate")} 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) { _c.Call.Run(func(args mock.Arguments) {
run() run()
}) })
return _c 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) _c.Call.Return(_a0)
return _c 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) _c.Call.Return(run)
return _c 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. // The first argument is typically a *testing.T value.
func NewSQLTemplateIface(t interface { func NewSQLTemplate(t interface {
mock.TestingT mock.TestingT
Cleanup(func()) Cleanup(func())
}) *SQLTemplateIface { }) *SQLTemplate {
mock := &SQLTemplateIface{} mock := &SQLTemplate{}
mock.Mock.Test(t) mock.Mock.Test(t)
t.Cleanup(func() { mock.AssertExpectations(t) }) t.Cleanup(func() { mock.AssertExpectations(t) })
pkg/storage/unified/sql/sqltemplate/mocks/test_snapshots.go
+3 -3
View File
@@ -14,13 +14,13 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
func NewTestingSQLTemplate() sqltemplate.SQLTemplateIface { func NewTestingSQLTemplate() sqltemplate.SQLTemplate {
standard := sqltemplate.New(sqltemplate.MySQL) // dialect gets replaced at each iteration standard := sqltemplate.New(sqltemplate.MySQL) // dialect gets replaced at each iteration
return &testingSQLTemplate{standard} return &testingSQLTemplate{standard}
} }
type testingSQLTemplate struct { type testingSQLTemplate struct {
*sqltemplate.SQLTemplate sqltemplate.SQLTemplate
} }
func (t *testingSQLTemplate) Arg(x any) string { func (t *testingSQLTemplate) Arg(x any) string {
@@ -69,7 +69,7 @@ type TemplateTestCase struct {
Name string Name string
// Data should be the struct passed to the template. // Data should be the struct passed to the template.
Data sqltemplate.SQLTemplateIface Data sqltemplate.SQLTemplate
} }
type TemplateTestSetup struct { type TemplateTestSetup struct {
pkg/storage/unified/sql/sqltemplate/sqltemplate.go
+20 -20
View File
@@ -13,58 +13,58 @@ var (
ErrSQLTemplateNoSerialize = errors.New("SQLTemplate should not be serialized") ErrSQLTemplateNoSerialize = errors.New("SQLTemplate should not be serialized")
// Make sure SQLTemplate implements the interface // Make sure SQLTemplate implements the interface
_ SQLTemplateIface = (*SQLTemplate)(nil) _ SQLTemplate = (*sqlTemplate)(nil)
) )
// SQLTemplate provides comprehensive support for SQL templating, handling // SQLTemplate provides comprehensive support for SQL templating, handling
// dialect traits, execution arguments and scanning arguments. // dialect traits, execution arguments and scanning arguments.
type SQLTemplate struct { type sqlTemplate struct {
Dialect Dialect
*Args Args
*ScanDest ScanDest
} }
// New returns a nee *SQLTemplate that will use the given dialect. // New returns a nee *SQLTemplate that will use the given dialect.
func New(d Dialect) *SQLTemplate { func New(d Dialect) SQLTemplate {
ret := new(SQLTemplate) ret := new(sqlTemplate)
ret.ScanDest = new(ScanDest) ret.ScanDest = new(scanDest)
ret.Args = NewArgs(d) ret.Args = NewArgs(d)
ret.SetDialect(d) ret.SetDialect(d)
return ret return ret
} }
func (t *SQLTemplate) Reset() { func (t *sqlTemplate) Reset() {
t.Args.Reset() t.Args.Reset()
t.ScanDest.Reset() t.ScanDest.Reset()
} }
func (t *SQLTemplate) SetDialect(d Dialect) { func (t *sqlTemplate) SetDialect(d Dialect) {
t.Reset() t.Reset()
t.Dialect = d t.Dialect = d
t.Args.d = d t.Args = NewArgs(d)
} }
func (t *SQLTemplate) Validate() error { func (t *sqlTemplate) Validate() error {
return ErrValidationNotImplemented return ErrValidationNotImplemented
} }
func (t *SQLTemplate) MarshalJSON() ([]byte, error) { func (t *sqlTemplate) MarshalJSON() ([]byte, error) {
return nil, ErrSQLTemplateNoSerialize return nil, ErrSQLTemplateNoSerialize
} }
func (t *SQLTemplate) UnmarshalJSON([]byte) error { func (t *sqlTemplate) UnmarshalJSON([]byte) error {
return ErrSQLTemplateNoSerialize 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. // expecting a struct embedding *SQLTemplate.
type SQLTemplateIface interface { type SQLTemplate interface {
Dialect Dialect
ArgsIface Args
ScanDestIface ScanDest
// Reset calls the Reset method of ArgsIface and ScanDestIface. // Reset calls the Reset method of Args and ScanDest.
Reset() Reset()
// SetDialect allows reusing the template components. It should first call // SetDialect allows reusing the template components. It should first call
// Reset. // Reset.
@@ -79,7 +79,7 @@ type SQLTemplateIface interface {
// WithResults has an additional method suited for structs embedding // WithResults has an additional method suited for structs embedding
// *SQLTemplate and returning a set of rows. // *SQLTemplate and returning a set of rows.
type WithResults[T any] interface { type WithResults[T any] interface {
SQLTemplateIface SQLTemplate
// Results returns the results of the query. If the query is expected to // 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 // return a set of rows, then it should be a deep copy of the internal