IntenseWebs/grafana
3
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-02-16 18:34:52 -06: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
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
19 changed files with 271 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pkg/registry/apis/dashboard/legacy/queries.go
View File

@ -29,7 +29,7 @@ var (
)
type sqlQuery struct {
sqltemplate.SQLTemplateIface
sqltemplate.SQLTemplate
Query *DashboardQuery
}

10
pkg/registry/apis/dashboard/legacy/queries_test.go
View File

@ -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,

4
pkg/registry/apis/dashboard/legacy/sql_dashboards.go
View File

@ -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

14
pkg/registry/apis/identity/legacy/legacy_sql.go
View File

@ -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)
}

6
pkg/registry/apis/identity/legacy/queries.go
View File

@ -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
}

18
pkg/registry/apis/identity/legacy/queries_test.go
View File

@ -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"},

112
pkg/storage/unified/sql/backend.go
View File

@ -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,
},

4
pkg/storage/unified/sql/dbutil/dbutil.go
View File

@ -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)

8
pkg/storage/unified/sql/dbutil/dbutil_test.go
View File

@ -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

16
pkg/storage/unified/sql/queries.go
View File

@ -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
}

30
pkg/storage/unified/sql/queries_test.go
View File

@ -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(),
},
},
},

16
pkg/storage/unified/sql/sqltemplate/args.go
View File

@ -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

2
pkg/storage/unified/sql/sqltemplate/args_test.go
View File

@ -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()

14
pkg/storage/unified/sql/sqltemplate/example_test.go
View File

@ -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

12
pkg/storage/unified/sql/sqltemplate/into.go
View File

@ -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

2
pkg/storage/unified/sql/sqltemplate/into_test.go
View File

@ -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 {

226
pkg/storage/unified/sql/sqltemplate/mocks/SQLTemplateIface.go
View File

@ -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) })

6
pkg/storage/unified/sql/sqltemplate/mocks/test_snapshots.go
View File

@ -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 {

40
pkg/storage/unified/sql/sqltemplate/sqltemplate.go
View File

@ -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