SQL: Add sql template test helper (#91953)

2024-08-16 14:36:56 +03:00
parent ac72098248
commit d9cabe5e14
131 changed files with 1377 additions and 911 deletions
@@ -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{
-			SQLTemplate: sqltemplate.New(b.dialect),
-			WriteEvent:  event,
-			GUID:        guid,
+			SQLTemplateIface: 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{
-			SQLTemplate: sqltemplate.New(b.dialect),
-			WriteEvent:  event,
-			GUID:        guid,
+			SQLTemplateIface: 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{
-			SQLTemplate:     sqltemplate.New(b.dialect),
-			GUID:            guid,
-			ResourceVersion: rv,
+			SQLTemplateIface: 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{
-			SQLTemplate:     sqltemplate.New(b.dialect),
-			GUID:            guid,
-			ResourceVersion: rv,
+			SQLTemplateIface: 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{
-			SQLTemplate: sqltemplate.New(b.dialect),
-			WriteEvent:  event,
-			GUID:        guid,
+			SQLTemplateIface: 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{
-			SQLTemplate: sqltemplate.New(b.dialect),
-			WriteEvent:  event,
-			GUID:        guid,
+			SQLTemplateIface: 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{
-			SQLTemplate:     sqltemplate.New(b.dialect),
-			GUID:            guid,
-			ResourceVersion: rv,
+			SQLTemplateIface: 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{
-			SQLTemplate:     sqltemplate.New(b.dialect),
-			GUID:            guid,
-			ResourceVersion: rv,
+			SQLTemplateIface: 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{
-			SQLTemplate: sqltemplate.New(b.dialect),
-			WriteEvent:  event,
-			GUID:        guid,
+			SQLTemplateIface: 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{
-			SQLTemplate: sqltemplate.New(b.dialect),
-			WriteEvent:  event,
-			GUID:        guid,
+			SQLTemplateIface: 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{
-			SQLTemplate:     sqltemplate.New(b.dialect),
-			GUID:            guid,
-			ResourceVersion: rv,
+			SQLTemplateIface: 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{
-		SQLTemplate:  sqltemplate.New(b.dialect),
-		Request:      req,
-		readResponse: new(readResponse),
+		SQLTemplateIface: 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{
-			SQLTemplate: sqltemplate.New(b.dialect),
-			Request:     new(resource.ListRequest),
+			SQLTemplateIface: 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{
-			SQLTemplate: sqltemplate.New(b.dialect),
+			SQLTemplateIface: 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{
-		SQLTemplate:          sqltemplate.New(b.dialect),
+		SQLTemplateIface:     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{
-		SQLTemplate:     sqltemplate.New(d),
-		Group:           group,
-		Resource:        resource,
-		ReadOnly:        true,
-		resourceVersion: new(resourceVersion),
+		SQLTemplateIface: 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{
-		SQLTemplate:          sqltemplate.New(b.dialect),
+		SQLTemplateIface:     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{
-		SQLTemplate:     sqltemplate.New(d),
-		Group:           key.Group,
-		Resource:        key.Resource,
-		resourceVersion: new(resourceVersion),
+		SQLTemplateIface: 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{
-			SQLTemplate: sqltemplate.New(d),
-			Group:       key.Group,
-			Resource:    key.Resource,
+			SQLTemplateIface: 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{
-		SQLTemplate: sqltemplate.New(d),
-		Group:       key.Group,
-		Resource:    key.Resource,
+		SQLTemplateIface: sqltemplate.New(d),
+		Group:            key.Group,
+		Resource:         key.Resource,
 		resourceVersion: &resourceVersion{
 			ResourceVersion: nextRV,
 		},
@@ -58,7 +58,7 @@ var (
 )

 type sqlResourceRequest struct {
-	*sqltemplate.SQLTemplate
+	sqltemplate.SQLTemplateIface
 	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.SQLTemplate
+	sqltemplate.SQLTemplateIface
 	Resource             string
 	Group                string
 	SinceResourceVersion int64
@@ -102,7 +102,7 @@ func (r *readResponse) Results() (*readResponse, error) {
 }

 type sqlResourceReadRequest struct {
-	*sqltemplate.SQLTemplate
+	sqltemplate.SQLTemplateIface
 	Request *resource.ReadRequest
 	*readResponse
 }
@@ -113,7 +113,7 @@ func (r sqlResourceReadRequest) Validate() error {

 // List
 type sqlResourceListRequest struct {
-	*sqltemplate.SQLTemplate
+	sqltemplate.SQLTemplateIface
 	Request *resource.ListRequest
 }

@@ -126,7 +126,7 @@ type historyListRequest struct {
 	Options                        *resource.ListOptions
 }
 type sqlResourceHistoryListRequest struct {
-	*sqltemplate.SQLTemplate
+	sqltemplate.SQLTemplateIface
 	Request  *historyListRequest
 	Response *resource.ResourceWrapper
 }
@@ -150,7 +150,7 @@ func (r sqlResourceHistoryListRequest) Results() (*resource.ResourceWrapper, err
 // update RV

 type sqlResourceUpdateRVRequest struct {
-	*sqltemplate.SQLTemplate
+	sqltemplate.SQLTemplateIface
 	GUID            string
 	ResourceVersion int64
 }
@@ -174,7 +174,7 @@ func (r *resourceVersion) Results() (*resourceVersion, error) {
 }

 type sqlResourceVersionRequest struct {
-	*sqltemplate.SQLTemplate
+	sqltemplate.SQLTemplateIface
 	Group, Resource string
 	ReadOnly        bool
 	*resourceVersion
@@ -185,7 +185,7 @@ func (r sqlResourceVersionRequest) Validate() error {
 }

 type sqlResourceVersionListRequest struct {
-	*sqltemplate.SQLTemplate
+	sqltemplate.SQLTemplateIface
 	*groupResourceVersion
 }

@@ -1,353 +1,184 @@
 package sql

 import (
-	"embed"
 	"testing"
 	"text/template"

-	"github.com/stretchr/testify/require"
-
 	"github.com/grafana/grafana/pkg/storage/unified/resource"
-	"github.com/grafana/grafana/pkg/storage/unified/sql/sqltemplate"
+	"github.com/grafana/grafana/pkg/storage/unified/sql/sqltemplate/mocks"
 )

-//go:embed testdata/*
-var testdataFS embed.FS
-
-func testdata(t *testing.T, filename string) []byte {
-	t.Helper()
-	b, err := testdataFS.ReadFile(`testdata/` + filename)
-	require.NoError(t, err)
-
-	return b
-}
-
 func TestQueries(t *testing.T) {
-	t.Parallel()
-
-	// Each template has one or more test cases, each identified with a
-	// descriptive name (e.g. "happy path", "error twiddling the frobb"). Each
-	// of them will test that for the same input data they must produce a result
-	// that will depend on the Dialect. Expected queries should be defined in
-	// separate files in the testdata directory. This improves the testing
-	// experience by separating test data from test code, since mixing both
-	// tends to make it more difficult to reason about what is being done,
-	// especially as we want testing code to scale and make it easy to add
-	// tests.
-	type (
-		// type aliases to make code more semantic and self-documenting
-		resultSQLFilename = string
-		dialects          = []sqltemplate.Dialect
-		expected          map[resultSQLFilename]dialects
-
-		testCase = struct {
-			Name string
-
-			// Data should be the struct passed to the template.
-			Data sqltemplate.SQLTemplateIface
-
-			// Expected maps the filename containing the expected result query
-			// to the list of dialects that would produce it. For simple
-			// queries, it is possible that more than one dialect produce the
-			// same output. The filename is expected to be in the `testdata`
-			// directory.
-			Expected expected
-		}
-	)
-
-	// Define tests cases. Most templates are trivial and testing that they
-	// generate correct code for a single Dialect is fine, since the one thing
-	// that always changes is how SQL placeholder arguments are passed (most
-	// Dialects use `?` while PostgreSQL uses `$1`, `$2`, etc.), and that is
-	// something that should be tested in the Dialect implementation instead of
-	// here. We will ask to have at least one test per SQL template, and we will
-	// lean to test MySQL. Templates containing branching (conditionals, loops,
-	// etc.) should be exercised at least once in each of their branches.
-	//
-	// NOTE: in the Data field, make sure to have pointers populated to simulate
-	// data is set as it would be in a real request. The data being correctly
-	// populated in each case should be tested in integration tests, where the
-	// data will actually flow to and from a real database. In this tests we
-	// only care about producing the correct SQL.
-	testCases := map[*template.Template][]*testCase{
-		sqlResourceDelete: {
-			{
-				Name: "single path",
-				Data: &sqlResourceRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-					WriteEvent: resource.WriteEvent{
-						Key: &resource.ResourceKey{},
-					},
-				},
-				Expected: expected{
-					"resource_delete_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
-					},
-					"resource_delete_postgres.sql": dialects{
-						sqltemplate.PostgreSQL,
-					},
-				},
-			},
-		},
-
-		sqlResourceInsert: {
-			{
-				Name: "insert into resource",
-				Data: &sqlResourceRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-					WriteEvent: resource.WriteEvent{
-						Key: &resource.ResourceKey{},
-					},
-				},
-				Expected: expected{
-					"resource_insert_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
-					},
-				},
-			},
-		},
-
-		sqlResourceUpdate: {
-			{
-				Name: "single path",
-				Data: &sqlResourceRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-					WriteEvent: resource.WriteEvent{
-						Key: &resource.ResourceKey{},
-					},
-				},
-				Expected: expected{
-					"resource_update_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
-					},
-				},
-			},
-		},
-
-		sqlResourceRead: {
-			{
-				Name: "without resource version",
-				Data: &sqlResourceReadRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-					Request: &resource.ReadRequest{
-						Key: &resource.ResourceKey{},
-					},
-					readResponse: new(readResponse),
-				},
-				Expected: expected{
-					"resource_read_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
-					},
-				},
-			},
-		},
-
-		sqlResourceList: {
-			{
-				Name: "filter on namespace",
-				Data: &sqlResourceListRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-					Request: &resource.ListRequest{
-						Limit: 10,
-						Options: &resource.ListOptions{
+	mocks.CheckQuerySnapshots(t, mocks.TemplateTestSetup{
+		RootDir: "testdata",
+		Templates: map[*template.Template][]mocks.TemplateTestCase{
+			sqlResourceDelete: {
+				{
+					Name: "simple",
+					Data: &sqlResourceRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
+						WriteEvent: resource.WriteEvent{
 							Key: &resource.ResourceKey{
-								Namespace: "ns",
+								Namespace: "nn",
+								Group:     "gg",
+								Resource:  "rr",
+								Name:      "name",
 							},
 						},
 					},
 				},
-				Expected: expected{
-					"resource_list_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
+			},
+			sqlResourceInsert: {
+				{
+					Name: "simple",
+					Data: &sqlResourceRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
+						WriteEvent: resource.WriteEvent{
+							Key: &resource.ResourceKey{
+								Namespace: "nn",
+								Group:     "gg",
+								Resource:  "rr",
+								Name:      "name",
+							},
+							Type:       resource.WatchEvent_ADDED,
+							PreviousRV: 123,
+						},
+					},
+				},
+			},
+			sqlResourceUpdate: {
+				{
+					Name: "single path",
+					Data: &sqlResourceRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
+						WriteEvent: resource.WriteEvent{
+							Key: &resource.ResourceKey{},
+						},
+					},
+				},
+			},
+			sqlResourceRead: {
+				{
+					Name: "without_resource_version",
+					Data: &sqlResourceReadRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
+						Request: &resource.ReadRequest{
+							Key: &resource.ResourceKey{},
+						},
+						readResponse: new(readResponse),
 					},
 				},
 			},
-		},

-		sqlResourceHistoryList: {
-			{
-				Name: "single path",
-				Data: &sqlResourceHistoryListRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-					Request: &historyListRequest{
-						Limit: 10,
-						Options: &resource.ListOptions{
-							Key: &resource.ResourceKey{
-								Namespace: "ns",
+			sqlResourceList: {
+				{
+					Name: "filter_on_namespace",
+					Data: &sqlResourceListRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
+						Request: &resource.ListRequest{
+							Limit: 10,
+							Options: &resource.ListOptions{
+								Key: &resource.ResourceKey{
+									Namespace: "ns",
+								},
 							},
 						},
 					},
-					Response: new(resource.ResourceWrapper),
 				},
-				Expected: expected{
-					"resource_history_list_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
+			},
+
+			sqlResourceHistoryList: {
+				{
+					Name: "single path",
+					Data: &sqlResourceHistoryListRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
+						Request: &historyListRequest{
+							Limit: 10,
+							Options: &resource.ListOptions{
+								Key: &resource.ResourceKey{
+									Namespace: "ns",
+								},
+							},
+						},
+						Response: new(resource.ResourceWrapper),
 					},
 				},
 			},
-		},

-		sqlResourceUpdateRV: {
-			{
-				Name: "single path",
-				Data: &sqlResourceUpdateRVRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-				},
-				Expected: expected{
-					"resource_update_rv_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
+			sqlResourceUpdateRV: {
+				{
+					Name: "single path",
+					Data: &sqlResourceUpdateRVRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
 					},
 				},
 			},
-		},

-		sqlResourceHistoryRead: {
-			{
-				Name: "single path",
-				Data: &sqlResourceReadRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-					Request: &resource.ReadRequest{
-						ResourceVersion: 123,
-						Key:             &resource.ResourceKey{},
-					},
-					readResponse: new(readResponse),
-				},
-				Expected: expected{
-					"resource_history_read_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
+			sqlResourceHistoryRead: {
+				{
+					Name: "single path",
+					Data: &sqlResourceReadRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
+						Request: &resource.ReadRequest{
+							ResourceVersion: 123,
+							Key:             &resource.ResourceKey{},
+						},
+						readResponse: new(readResponse),
 					},
 				},
 			},
-		},

-		sqlResourceHistoryUpdateRV: {
-			{
-				Name: "single path",
-				Data: &sqlResourceUpdateRVRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-				},
-				Expected: expected{
-					"resource_history_update_rv_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
+			sqlResourceHistoryUpdateRV: {
+				{
+					Name: "single path",
+					Data: &sqlResourceUpdateRVRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
 					},
 				},
 			},
-		},

-		sqlResourceHistoryInsert: {
-			{
-				Name: "insert into resource_history",
-				Data: &sqlResourceRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-					WriteEvent: resource.WriteEvent{
-						Key: &resource.ResourceKey{},
-					},
-				},
-				Expected: expected{
-					"resource_history_insert_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
+			sqlResourceHistoryInsert: {
+				{
+					Name: "insert into resource_history",
+					Data: &sqlResourceRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
+						WriteEvent: resource.WriteEvent{
+							Key: &resource.ResourceKey{},
+						},
 					},
 				},
 			},
-		},

-		sqlResourceVersionGet: {
-			{
-				Name: "single path",
-				Data: &sqlResourceVersionRequest{
-					SQLTemplate:     new(sqltemplate.SQLTemplate),
-					resourceVersion: new(resourceVersion),
-					ReadOnly:        false,
-				},
-				Expected: expected{
-					"resource_version_get_mysql.sql": dialects{
-						sqltemplate.MySQL,
-					},
-					"resource_version_get_sqlite.sql": dialects{
-						sqltemplate.SQLite,
+			sqlResourceVersionGet: {
+				{
+					Name: "single path",
+					Data: &sqlResourceVersionRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
+						resourceVersion:  new(resourceVersion),
+						ReadOnly:         false,
 					},
 				},
 			},
-		},

-		sqlResourceVersionInc: {
-			{
-				Name: "increment resource version",
-				Data: &sqlResourceVersionRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-					resourceVersion: &resourceVersion{
-						ResourceVersion: 123,
-					},
-				},
-				Expected: expected{
-					"resource_version_inc_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
+			sqlResourceVersionInc: {
+				{
+					Name: "increment resource version",
+					Data: &sqlResourceVersionRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
+						resourceVersion: &resourceVersion{
+							ResourceVersion: 123,
+						},
 					},
 				},
 			},
-		},

-		sqlResourceVersionInsert: {
-			{
-				Name: "single path",
-				Data: &sqlResourceVersionRequest{
-					SQLTemplate: new(sqltemplate.SQLTemplate),
-				},
-				Expected: expected{
-					"resource_version_insert_mysql_sqlite.sql": dialects{
-						sqltemplate.MySQL,
-						sqltemplate.SQLite,
+			sqlResourceVersionInsert: {
+				{
+					Name: "single path",
+					Data: &sqlResourceVersionRequest{
+						SQLTemplateIface: mocks.NewTestingSQLTemplate(),
 					},
 				},
 			},
-		},
-	}
-
-	// Execute test cases
-	for tmpl, tcs := range testCases {
-		t.Run(tmpl.Name(), func(t *testing.T) {
-			t.Parallel()
-
-			for _, tc := range tcs {
-				t.Run(tc.Name, func(t *testing.T) {
-					t.Parallel()
-
-					for filename, ds := range tc.Expected {
-						t.Run(filename, func(t *testing.T) {
-							// not parallel because we're sharing tc.Data, not
-							// worth it deep cloning
-
-							rawQuery := string(testdata(t, filename))
-							expectedQuery := sqltemplate.FormatSQL(rawQuery)
-
-							for _, d := range ds {
-								t.Run(d.DialectName(), func(t *testing.T) {
-									// not parallel for the same reason
-
-									tc.Data.SetDialect(d)
-									err := tc.Data.Validate()
-									require.NoError(t, err)
-									got, err := sqltemplate.Execute(tmpl, tc.Data)
-									require.NoError(t, err)
-									got = sqltemplate.FormatSQL(got)
-									require.Equal(t, expectedQuery, got)
-								})
-							}
-						})
-					}
-				})
-			}
-		})
-	}
+		}})
 }
@@ -0,0 +1,147 @@
+package mocks
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	reflect "reflect"
+	"strings"
+	"testing"
+	"text/template"
+
+	"github.com/google/go-cmp/cmp"
+	sqltemplate "github.com/grafana/grafana/pkg/storage/unified/sql/sqltemplate"
+	"github.com/stretchr/testify/require"
+)
+
+func NewTestingSQLTemplate() sqltemplate.SQLTemplateIface {
+	standard := sqltemplate.New(sqltemplate.MySQL) // dialect gets replaced at each iteration
+	return &testingSQLTemplate{standard}
+}
+
+type testingSQLTemplate struct {
+	*sqltemplate.SQLTemplate
+}
+
+func (t *testingSQLTemplate) Arg(x any) string {
+	_ = t.SQLTemplate.Arg(x) // discard the output
+
+	switch v := reflect.ValueOf(x); {
+	case v.Kind() == reflect.Bool:
+		if v.Bool() {
+			return "TRUE"
+		}
+		return "FALSE"
+
+	case v.CanInt(), v.CanUint(), v.CanFloat():
+		_, ok := x.(fmt.Stringer)
+		if !ok {
+			return fmt.Sprintf("%v", x)
+		}
+	}
+
+	return fmt.Sprintf("'%v'", x) // single quotes
+}
+
+func (t *testingSQLTemplate) ArgList(slice reflect.Value) (string, error) {
+	// Copied from upstream Arg
+	if !slice.IsValid() || slice.Kind() != reflect.Slice {
+		return "", sqltemplate.ErrInvalidArgList
+	}
+	sliceLen := slice.Len()
+	if sliceLen == 0 {
+		return "", nil
+	}
+
+	var b strings.Builder
+	b.Grow(3*sliceLen - 2) // the list will be ?, ?, ?
+	for i, l := 0, slice.Len(); i < l; i++ {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		b.WriteString(t.Arg(slice.Index(i).Interface()))
+	}
+
+	return b.String(), nil
+}
+
+type TemplateTestCase struct {
+	Name string
+
+	// Data should be the struct passed to the template.
+	Data sqltemplate.SQLTemplateIface
+}
+
+type TemplateTestSetup struct {
+	// Where the snapshots can be found
+	RootDir string
+
+	// The template will be run through each dialect
+	Dialects []sqltemplate.Dialect
+
+	// Check a set of templates against example inputs
+	Templates map[*template.Template][]TemplateTestCase
+}
+
+func CheckQuerySnapshots(t *testing.T, setup TemplateTestSetup) {
+	t.Helper()
+	t.Parallel()
+
+	if len(setup.Dialects) < 1 {
+		setup.Dialects = []sqltemplate.Dialect{
+			sqltemplate.MySQL,
+			sqltemplate.SQLite,
+			sqltemplate.PostgreSQL,
+		}
+	}
+
+	for tmpl, cases := range setup.Templates {
+		t.Run(tmpl.Name(), func(t *testing.T) {
+			t.Parallel()
+
+			tname := strings.TrimSuffix(tmpl.Name(), ".sql")
+			for _, input := range cases {
+				t.Run(input.Name, func(t *testing.T) {
+					t.Parallel()
+
+					require.NotPanics(t, func() {
+						for _, dialect := range setup.Dialects {
+							t.Run(dialect.DialectName(), func(t *testing.T) {
+								// not parallel because we're sharing tc.Data,
+								// but also not worth deep cloning
+								input.Data.SetDialect(dialect)
+								err := input.Data.Validate()
+
+								require.NoError(t, err)
+								got, err := sqltemplate.Execute(tmpl, input.Data)
+								require.NoError(t, err)
+
+								clean := sqltemplate.RemoveEmptyLines(got)
+
+								update := false
+								fname := fmt.Sprintf("%s--%s-%s.sql", dialect.DialectName(), tname, input.Name)
+								fpath := filepath.Join(setup.RootDir, fname)
+
+								// We can ignore the gosec G304 because this is only for tests
+								// nolint:gosec
+								expect, err := os.ReadFile(fpath)
+								if err != nil || len(expect) < 1 {
+									update = true
+									t.Errorf("missing " + fpath)
+								} else {
+									if diff := cmp.Diff(string(expect), clean); diff != "" {
+										t.Errorf("%s: %s", fname, diff)
+										update = true
+									}
+								}
+								if update {
+									_ = os.WriteFile(fpath, []byte(clean), 0777)
+								}
+							})
+						}
+					})
+				})
+			}
+		})
+	}
+}
@@ -11,21 +11,25 @@ import (
 var (
 	ErrValidationNotImplemented = errors.New("validation not implemented")
 	ErrSQLTemplateNoSerialize   = errors.New("SQLTemplate should not be serialized")
+
+	// Make sure SQLTemplate implements the interface
+	_ SQLTemplateIface = (*SQLTemplate)(nil)
 )

 // SQLTemplate provides comprehensive support for SQL templating, handling
 // dialect traits, execution arguments and scanning arguments.
 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)
+	ret.Args = NewArgs(d)
 	ret.SetDialect(d)
-
 	return ret
 }

@@ -0,0 +1,7 @@
+DELETE FROM "resource"
+    WHERE 1 = 1
+        AND "namespace" = 'nn'
+        AND "group"     = 'gg'
+        AND "resource"  = 'rr'
+        AND "name"      = 'name'
+;
@@ -0,0 +1,20 @@
+INSERT INTO "resource_history"
+    (
+        "guid",
+        "group",
+        "resource",
+        "namespace",
+        "name",
+        "value",
+        "action"
+    )
+    VALUES (
+        '',
+        '',
+        '',
+        '',
+        '',
+        '[]',
+        'UNKNOWN'
+    )
+;
@@ -0,0 +1,25 @@
+SELECT
+    kv."resource_version",
+    kv."namespace",
+    kv."name",
+    kv."value"
+    FROM "resource_history" as kv 
+    INNER JOIN  (
+        SELECT "namespace", "group", "resource", "name",  max("resource_version") AS "resource_version"
+        FROM "resource_history" AS mkv
+        WHERE 1 = 1
+            AND "resource_version" <=  0
+                AND "namespace" = 'ns'
+        GROUP BY mkv."namespace", mkv."group", mkv."resource", mkv."name" 
+    ) AS maxkv
+    ON
+        maxkv."resource_version"  = kv."resource_version"
+        AND maxkv."namespace"     = kv."namespace"
+        AND maxkv."group"         = kv."group"
+        AND maxkv."resource"      = kv."resource"
+        AND maxkv."name"          = kv."name"
+    WHERE kv."action"  != 3 
+        AND kv."namespace" = 'ns'
+    ORDER BY kv."namespace" ASC, kv."name" ASC
+    LIMIT 10 OFFSET 0
+;
@@ -0,0 +1,13 @@
+SELECT
+    "resource_version",
+    "value"
+    FROM "resource_history"
+    WHERE 1 = 1
+        AND "namespace" = ''
+        AND "group"     = ''
+        AND "resource"  = ''
+        AND "name"      = ''
+        AND "resource_version" <= 123
+    ORDER BY "resource_version" DESC
+    LIMIT 1
+;
@@ -0,0 +1,4 @@
+UPDATE "resource_history"
+    SET "resource_version" = 0
+    WHERE  "guid" = ''
+;
@@ -0,0 +1,20 @@
+INSERT INTO "resource"
+    (
+        "guid",
+        "group",
+        "resource",
+        "namespace",
+        "name",
+        "value",
+        "action"
+    )
+    VALUES (
+        '',
+        'gg',
+        'rr',
+        'nn',
+        'name',
+        '[]',
+        'ADDED'
+    )
+;
@@ -0,0 +1,10 @@
+SELECT
+    "resource_version",
+    "namespace",
+    "name",
+    "value"
+    FROM "resource"
+    WHERE 1 = 1
+            AND "namespace" = 'ns'
+    ORDER BY "namespace" ASC, "name" ASC
+;
@@ -0,0 +1,10 @@
+SELECT
+    "resource_version",
+    "value"
+    FROM "resource"
+    WHERE 1 = 1
+        AND "namespace" = ''
+        AND "group"     = ''
+        AND "resource"  = ''
+        AND "name"      = ''
+;
@@ -0,0 +1,11 @@
+UPDATE "resource"
+    SET
+        "guid"   = '',
+        "value"  = '[]',
+        "action" = 'UNKNOWN'  
+    WHERE 1 = 1
+        AND "group"     = ''
+        AND "resource"  = ''
+        AND "namespace" = ''
+        AND "name"      = ''
+;
@@ -0,0 +1,4 @@
+UPDATE "resource"
+    SET "resource_version" = 0
+    WHERE  "guid" = ''
+;
@@ -0,0 +1,8 @@
+SELECT
+        "resource_version"
+    FROM "resource_version"
+    WHERE 1 = 1
+        AND "group"    = ''
+        AND "resource" = ''
+    FOR UPDATE
+;
@@ -0,0 +1,7 @@
+UPDATE "resource_version"
+SET
+    "resource_version" = 123
+WHERE 1 = 1
+    AND "group"    = ''
+    AND "resource" = ''
+;
@@ -0,0 +1,12 @@
+INSERT INTO "resource_version"
+    (
+        "group",
+        "resource",
+        "resource_version"
+    )
+    VALUES (
+        '',
+        '',
+        1
+    )
+;
@@ -0,0 +1,7 @@
+DELETE FROM "resource"
+    WHERE 1 = 1
+        AND "namespace" = 'nn'
+        AND "group"     = 'gg'
+        AND "resource"  = 'rr'
+        AND "name"      = 'name'
+;
@@ -0,0 +1,20 @@
+INSERT INTO "resource_history"
+    (
+        "guid",
+        "group",
+        "resource",
+        "namespace",
+        "name",
+        "value",
+        "action"
+    )
+    VALUES (
+        '',
+        '',
+        '',
+        '',
+        '',
+        '[]',
+        'UNKNOWN'
+    )
+;
@@ -0,0 +1,25 @@
+SELECT
+    kv."resource_version",
+    kv."namespace",
+    kv."name",
+    kv."value"
+    FROM "resource_history" as kv 
+    INNER JOIN  (
+        SELECT "namespace", "group", "resource", "name",  max("resource_version") AS "resource_version"
+        FROM "resource_history" AS mkv
+        WHERE 1 = 1
+            AND "resource_version" <=  0
+                AND "namespace" = 'ns'
+        GROUP BY mkv."namespace", mkv."group", mkv."resource", mkv."name" 
+    ) AS maxkv
+    ON
+        maxkv."resource_version"  = kv."resource_version"
+        AND maxkv."namespace"     = kv."namespace"
+        AND maxkv."group"         = kv."group"
+        AND maxkv."resource"      = kv."resource"
+        AND maxkv."name"          = kv."name"
+    WHERE kv."action"  != 3 
+        AND kv."namespace" = 'ns'
+    ORDER BY kv."namespace" ASC, kv."name" ASC
+    LIMIT 10 OFFSET 0
+;
@@ -0,0 +1,13 @@
+SELECT
+    "resource_version",
+    "value"
+    FROM "resource_history"
+    WHERE 1 = 1
+        AND "namespace" = ''
+        AND "group"     = ''
+        AND "resource"  = ''
+        AND "name"      = ''
+        AND "resource_version" <= 123
+    ORDER BY "resource_version" DESC
+    LIMIT 1
+;
@@ -0,0 +1,4 @@
+UPDATE "resource_history"
+    SET "resource_version" = 0
+    WHERE  "guid" = ''
+;
@@ -0,0 +1,20 @@
+INSERT INTO "resource"
+    (
+        "guid",
+        "group",
+        "resource",
+        "namespace",
+        "name",
+        "value",
+        "action"
+    )
+    VALUES (
+        '',
+        'gg',
+        'rr',
+        'nn',
+        'name',
+        '[]',
+        'ADDED'
+    )
+;
@@ -0,0 +1,10 @@
+SELECT
+    "resource_version",
+    "namespace",
+    "name",
+    "value"
+    FROM "resource"
+    WHERE 1 = 1
+            AND "namespace" = 'ns'
+    ORDER BY "namespace" ASC, "name" ASC
+;
@@ -0,0 +1,10 @@
+SELECT
+    "resource_version",
+    "value"
+    FROM "resource"
+    WHERE 1 = 1
+        AND "namespace" = ''
+        AND "group"     = ''
+        AND "resource"  = ''
+        AND "name"      = ''
+;
@@ -0,0 +1,11 @@
+UPDATE "resource"
+    SET
+        "guid"   = '',
+        "value"  = '[]',
+        "action" = 'UNKNOWN'  
+    WHERE 1 = 1
+        AND "group"     = ''
+        AND "resource"  = ''
+        AND "namespace" = ''
+        AND "name"      = ''
+;
@@ -0,0 +1,4 @@
+UPDATE "resource"
+    SET "resource_version" = 0
+    WHERE  "guid" = ''
+;
@@ -0,0 +1,8 @@
+SELECT
+        "resource_version"
+    FROM "resource_version"
+    WHERE 1 = 1
+        AND "group"    = ''
+        AND "resource" = ''
+    FOR UPDATE
+;
@@ -0,0 +1,7 @@
+UPDATE "resource_version"
+SET
+    "resource_version" = 123
+WHERE 1 = 1
+    AND "group"    = ''
+    AND "resource" = ''
+;
@@ -0,0 +1,12 @@
+INSERT INTO "resource_version"
+    (
+        "group",
+        "resource",
+        "resource_version"
+    )
+    VALUES (
+        '',
+        '',
+        1
+    )
+;
@@ -1 +0,0 @@
-DELETE FROM "resource" WHERE 1 = 1 AND "namespace" = ? AND "group" = ? AND "resource" = ? AND "name" = ?;
@@ -1 +0,0 @@
-DELETE FROM "resource" WHERE 1 = 1 AND "namespace" = $1 AND "group" = $2 AND "resource" = $3 AND "name" = $4;
@@ -1,3 +0,0 @@
-INSERT INTO "resource_history"
-    ("guid", "group", "resource", "namespace", "name", "value", "action")
-    VALUES (?, ?, ?, ?, ?, ?, ?);
@@ -1,13 +0,0 @@
-SELECT kv."resource_version", kv."namespace", kv."name", kv."value"
-FROM "resource_history" as kv
-INNER JOIN (
-	SELECT "namespace", "group", "resource", "name", max("resource_version") AS "resource_version"
-	FROM "resource_history" AS mkv
-	WHERE 1 = 1 AND "resource_version" <= ? AND "namespace" = ?
-	GROUP BY mkv."namespace", mkv."group", mkv."resource", mkv."name"
-) AS maxkv
-ON maxkv."resource_version" = kv."resource_version" AND maxkv."namespace" = kv."namespace" AND maxkv."group" = kv."group" AND maxkv."resource" = kv."resource" AND maxkv."name" = kv."name"
-WHERE kv."action" != 3 AND kv."namespace" = ?
-ORDER BY kv."namespace" ASC, kv."name" ASC
-LIMIT ? OFFSET ?
-;
@@ -1,6 +0,0 @@
-SELECT "resource_version", "value"
-    FROM "resource_history"
-    WHERE 1 = 1 AND "namespace" = ? AND "group" = ? AND "resource" = ? AND "name" = ? AND "resource_version" <= ?
-    ORDER BY "resource_version" DESC
-    LIMIT 1  
-;
@@ -1,3 +0,0 @@
-UPDATE "resource_history" SET "resource_version" = ?
-WHERE "guid" = ?
-;
@@ -1,4 +0,0 @@
-INSERT INTO "resource"
-    ("guid", "group", "resource", "namespace", "name", "value", "action")
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-;
@@ -1,5 +0,0 @@
-SELECT "resource_version", "namespace", "name", "value"
-    FROM "resource"
-    WHERE 1 = 1 AND "namespace" = ?
-    ORDER BY "namespace" ASC, "name" ASC
-;
@@ -1,4 +0,0 @@
-SELECT "resource_version", "value"
-    FROM "resource"
-    WHERE 1 = 1 AND "namespace" = ? AND "group" = ? AND "resource" = ? AND "name" = ?
-;
@@ -1,4 +0,0 @@
-UPDATE "resource" SET "guid" = ?, "value" = ?, "action" = ?
-WHERE 1 =1 AND "group" = ? AND "resource" = ? AND "namespace" = ? AND "name" = ?
-;
- 
@@ -1,4 +0,0 @@
-UPDATE "resource" SET "resource_version" = ?
-WHERE "guid" = ?
-;
- 
@@ -1,4 +0,0 @@
-SELECT "resource_version"
-    FROM "resource_version"
-    WHERE 1 = 1 AND "group" = ? AND "resource" = ?
-FOR UPDATE;
@@ -1,4 +0,0 @@
-SELECT "resource_version"
-    FROM "resource_version"
-    WHERE 1 = 1 AND "group" = ? AND "resource" = ?
-;
@@ -1,4 +0,0 @@
-UPDATE "resource_version"
-    SET "resource_version" = ?
-    WHERE 1 = 1 AND "group" = ? AND "resource" = ?
-;
@@ -1,3 +0,0 @@
-INSERT INTO "resource_version"
-    ("group", "resource", "resource_version")
-    VALUES (?, ?, 1);
@@ -0,0 +1,7 @@
+DELETE FROM "resource"
+    WHERE 1 = 1
+        AND "namespace" = 'nn'
+        AND "group"     = 'gg'
+        AND "resource"  = 'rr'
+        AND "name"      = 'name'
+;
@@ -0,0 +1,20 @@
+INSERT INTO "resource_history"
+    (
+        "guid",
+        "group",
+        "resource",
+        "namespace",
+        "name",
+        "value",
+        "action"
+    )
+    VALUES (
+        '',
+        '',
+        '',
+        '',
+        '',
+        '[]',
+        'UNKNOWN'
+    )
+;
@@ -0,0 +1,25 @@
+SELECT
+    kv."resource_version",
+    kv."namespace",
+    kv."name",
+    kv."value"
+    FROM "resource_history" as kv 
+    INNER JOIN  (
+        SELECT "namespace", "group", "resource", "name",  max("resource_version") AS "resource_version"
+        FROM "resource_history" AS mkv
+        WHERE 1 = 1
+            AND "resource_version" <=  0
+                AND "namespace" = 'ns'
+        GROUP BY mkv."namespace", mkv."group", mkv."resource", mkv."name" 
+    ) AS maxkv
+    ON
+        maxkv."resource_version"  = kv."resource_version"
+        AND maxkv."namespace"     = kv."namespace"
+        AND maxkv."group"         = kv."group"
+        AND maxkv."resource"      = kv."resource"
+        AND maxkv."name"          = kv."name"
+    WHERE kv."action"  != 3 
+        AND kv."namespace" = 'ns'
+    ORDER BY kv."namespace" ASC, kv."name" ASC
+    LIMIT 10 OFFSET 0
+;
@@ -0,0 +1,13 @@
+SELECT
+    "resource_version",
+    "value"
+    FROM "resource_history"
+    WHERE 1 = 1
+        AND "namespace" = ''
+        AND "group"     = ''
+        AND "resource"  = ''
+        AND "name"      = ''
+        AND "resource_version" <= 123
+    ORDER BY "resource_version" DESC
+    LIMIT 1
+;
@@ -0,0 +1,4 @@
+UPDATE "resource_history"
+    SET "resource_version" = 0
+    WHERE  "guid" = ''
+;
@@ -0,0 +1,20 @@
+INSERT INTO "resource"
+    (
+        "guid",
+        "group",
+        "resource",
+        "namespace",
+        "name",
+        "value",
+        "action"
+    )
+    VALUES (
+        '',
+        'gg',
+        'rr',
+        'nn',
+        'name',
+        '[]',
+        'ADDED'
+    )
+;
@@ -0,0 +1,10 @@
+SELECT
+    "resource_version",
+    "namespace",
+    "name",
+    "value"
+    FROM "resource"
+    WHERE 1 = 1
+            AND "namespace" = 'ns'
+    ORDER BY "namespace" ASC, "name" ASC
+;
@@ -0,0 +1,10 @@
+SELECT
+    "resource_version",
+    "value"
+    FROM "resource"
+    WHERE 1 = 1
+        AND "namespace" = ''
+        AND "group"     = ''
+        AND "resource"  = ''
+        AND "name"      = ''
+;
@@ -0,0 +1,11 @@
+UPDATE "resource"
+    SET
+        "guid"   = '',
+        "value"  = '[]',
+        "action" = 'UNKNOWN'  
+    WHERE 1 = 1
+        AND "group"     = ''
+        AND "resource"  = ''
+        AND "namespace" = ''
+        AND "name"      = ''
+;
@@ -0,0 +1,4 @@
+UPDATE "resource"
+    SET "resource_version" = 0
+    WHERE  "guid" = ''
+;
@@ -0,0 +1,7 @@
+SELECT
+        "resource_version"
+    FROM "resource_version"
+    WHERE 1 = 1
+        AND "group"    = ''
+        AND "resource" = ''
+;
@@ -0,0 +1,7 @@
+UPDATE "resource_version"
+SET
+    "resource_version" = 123
+WHERE 1 = 1
+    AND "group"    = ''
+    AND "resource" = ''
+;
@@ -0,0 +1,12 @@
+INSERT INTO "resource_version"
+    (
+        "group",
+        "resource",
+        "resource_version"
+    )
+    VALUES (
+        '',
+        '',
+        1
+    )
+;
				`@@ -1 +0,0 @@`
				`DELETE FROM "resource" WHERE 1 = 1 AND "namespace" = ? AND "group" = ? AND "resource" = ? AND "name" = ?;`