Enginetests for Keyless tables

enginetest/enginetests.go

@@ -45,6 +45,12 @@ func TestQueries(t *testing.T, harness Harness) {
 	for _, tt := range QueryTests {
 		TestQuery(t, harness, engine, tt.Query, tt.Expected, tt.Bindings)
 	}
+
+	if _, ok := harness.(KeylessTableHarness); ok {
+		for _, tt := range KeylessQueries {
+			TestQuery(t, harness, engine, tt.Query, tt.Expected, tt.Bindings)
+		}
+	}
 }
 
 // Runs the query tests given after setting up the engine. Useful for testing out a smaller subset of queries during

enginetest/harness.go

@@ -80,3 +80,10 @@ type VersionedDBHarness interface {
 	// NewTableAsOf might do all the necessary work to create such snapshots, so this could be a no-op.
 	SnapshotTable(db sql.VersionedDatabase, name string, asOf interface{}) error
 }
+
+// KeylessTableHarness is an extension to Harness that lets an integrator test their implementation with keyless tables.
+type KeylessTableHarness interface {
+	Harness
+	// SupportsKeylessTables indicates integrator support for keyless tables.
+	SupportsKeylessTables() bool
+}

enginetest/memoryharness.go

@@ -59,6 +59,7 @@ var _ IndexDriverHarness = (*MemoryHarness)(nil)
 var _ IndexHarness = (*MemoryHarness)(nil)
 var _ VersionedDBHarness = (*MemoryHarness)(nil)
 var _ ForeignKeyHarness = (*MemoryHarness)(nil)
+var _ KeylessTableHarness = (*MemoryHarness)(nil)
 var _ SkippingHarness = (*SkippingMemoryHarness)(nil)
 
 type SkippingMemoryHarness struct {
@@ -77,6 +78,10 @@ func (m *MemoryHarness) SupportsForeignKeys() bool {
 	return true
 }
 
+func (m *MemoryHarness) SupportsKeylessTables() bool {
+	return true
+}
+
 func (m *MemoryHarness) Parallelism() int {
 	return m.parallelism
 }

enginetest/queries.go

@@ -332,7 +332,6 @@ var QueryTests = []QueryTest{
 		Query:    "SELECT 100 NOT IN (SELECT i2 FROM niltable)",
 		Expected: []sql.Row{{nil}},
 	},
-
 	{
 		Query:    "SELECT 1 IN (2,3,4,null)",
 		Expected: []sql.Row{{nil}},
@@ -760,7 +759,8 @@ var QueryTests = []QueryTest{
 	{
 		Query:    "SELECT id FROM typestable WHERE da < date_sub('2020-01-01', INTERVAL 1 DAY)",
 		Expected: nil,
-	}, {
+	},
+	{
 		Query: "SELECT i,v from stringandtable WHERE i",
 		Expected: []sql.Row{
 			{int64(1), "1"},
@@ -3393,6 +3393,43 @@ var QueryTests = []QueryTest{
 	},
 }
 
+var KeylessQueries = []QueryTest{
+	{
+		Query: "SELECT * FROM keyless",
+		Expected: []sql.Row{
+			{0, 0},
+			{1, 1},
+			{1, 1},
+			{2, 2},
+		},
+	},
+	{
+		Query: "SELECT * FROM keyless ORDER BY c1 DESC",
+		Expected: []sql.Row{
+			{2, 2},
+			{1, 1},
+			{1, 1},
+			{0, 0},
+		},
+	},
+	{
+		Query:    "SELECT * FROM keyless JOIN myTable where c0 = i",
+		Expected: []sql.Row{
+			{1, 1, 1, "first row"},
+			{1, 1, 1, "first row"},
+			{2, 2, 2, "second row"},
+		},
+	},
+	{
+		Query:    "SELECT * FROM myTable JOIN keyless where i = c0",
+		Expected: []sql.Row{
+			{1, "first row", 1, 1},
+			{1, "first row", 1, 1},
+			{2, "second row", 2, 2},
+		},
+	},
+}
+
 // Queries that are known to be broken in the engine.
 var BrokenQueries = []QueryTest{
 	{

enginetest/testdata.go

@@ -421,6 +421,24 @@ func CreateSubsetTestData(t *testing.T, harness Harness, includedTables []string
 		require.NoError(t, versionedHarness.SnapshotTable(versionedDb, "myhistorytable", "2019-01-02"))
 	}
 
+	if _, ok := harness.(KeylessTableHarness); ok &&
+		includeTable(includedTables, "keyless") {
+		table, err = harness.NewTable(myDb, "keyless", sql.Schema{
+			{Name: "c0", Type: sql.Int64, Source: "keyless", Nullable: true},
+			{Name: "c1", Type: sql.Int64, Source: "keyless", Nullable: true},
+		})
+
+		if err == nil {
+			InsertRows(t, NewContext(harness), mustInsertableTable(t, table),
+				sql.NewRow(int64(0), int64(0)),
+				sql.NewRow(int64(1), int64(1)),
+				sql.NewRow(int64(1), int64(1)),
+				sql.NewRow(int64(2), int64(2)))
+		} else {
+			t.Logf("Warning: could not create table %s: %s", "keyless", err)
+		}
+	}
+
 	return []sql.Database{myDb, foo}
 }