diff --git a/README.md b/README.md
index 9a2cec89a9..9e3eaec596 100644
--- a/README.md
+++ b/README.md
@@ -147,7 +147,6 @@ func main() {
 
 func createTestDatabase() *memory.DbProvider {
 	db := memory.NewDatabase(dbName)
-	db.BaseDatabase.EnablePrimaryKeyIndexes()
 
 	pro := memory.NewDBProvider(db)
 	session := memory.NewSession(sql.NewBaseSession(), pro)
diff --git a/_example/main.go b/_example/main.go
index 1244c93239..1b0e10ff89 100644
--- a/_example/main.go
+++ b/_example/main.go
@@ -84,7 +84,6 @@ func main() {
 
 func createTestDatabase() *memory.DbProvider {
 	db := memory.NewDatabase(dbName)
-	db.BaseDatabase.EnablePrimaryKeyIndexes()
 
 	pro := memory.NewDBProvider(db)
 	session := memory.NewSession(sql.NewBaseSession(), pro)
diff --git a/enginetest/engine_only_test.go b/enginetest/engine_only_test.go
index 86aa287be1..29381ae062 100644
--- a/enginetest/engine_only_test.go
+++ b/enginetest/engine_only_test.go
@@ -77,7 +77,7 @@ func TestWarnings(t *testing.T) {
 		enginetest.TestWarnings(t, harness)
 	})
 
-	harness = enginetest.NewMemoryHarness("parallel", 2, testNumPartitions, false, nil)
+	harness = enginetest.NewMemoryHarness("parallel", testNumPartitions, nil)
 	t.Run("parallel", func(t *testing.T) {
 		enginetest.TestWarnings(t, harness)
 	})
@@ -563,7 +563,7 @@ func TestShowCharset(t *testing.T) {
 		},
 	}
 
-	harness := enginetest.NewMemoryHarness("", 1, 1, false, nil)
+	harness := enginetest.NewMemoryHarness("", 1, nil)
 	for _, test := range tests {
 		enginetest.TestQuery(t, harness, test.Query, test.RowGen(t), nil, nil)
 	}
diff --git a/enginetest/histogram_test.go b/enginetest/histogram_test.go
index 49c42797a9..ff234f610a 100644
--- a/enginetest/histogram_test.go
+++ b/enginetest/histogram_test.go
@@ -402,7 +402,6 @@ func childSchema(source string) sql.PrimaryKeySchema {
 
 func makeTable(db *memory.Database, name string, tabId sql.TableId, colId sql.ColumnId) *plan.ResolvedTable {
 	t := memory.NewTable(db, name, childSchema(name), nil)
-	t.EnablePrimaryKeyIndexes()
 	colset := sql.NewColSet(sql.ColumnId(colId), sql.ColumnId(colId+1), sql.ColumnId(colId+2))
 	return plan.NewResolvedTable(t, db, nil).WithId(sql.TableId(tabId)).WithColumns(colset).(*plan.ResolvedTable)
 }
diff --git a/enginetest/memory_engine_test.go b/enginetest/memory_engine_test.go
index f1ec7b45d0..b76315f215 100644
--- a/enginetest/memory_engine_test.go
+++ b/enginetest/memory_engine_test.go
@@ -42,7 +42,6 @@ import (
 type indexBehaviorTestParams struct {
 	name              string
 	driverInitializer enginetest.IndexDriverInitializer
-	nativeIndexes     bool
 }
 
 const testNumPartitions = 5
@@ -51,15 +50,11 @@ var numPartitionsVals = []int{
 	1,
 	testNumPartitions,
 }
+
+// indexBehaviors are the set of index configurations to test against.
 var indexBehaviors = []*indexBehaviorTestParams{
-	{"none", nil, false},
-	{"mergableIndexes", mergableIndexDriver, false},
-	{"nativeIndexes", nil, true},
-	{"nativeAndMergable", mergableIndexDriver, true},
-}
-var parallelVals = []int{
-	1,
-	2,
+	{"nativeIndexes", nil},
+	{"nativeAndMergable", mergableIndexDriver},
 }
 
 // TestQueries tests the given queries on an engine under a variety of circumstances:
@@ -69,18 +64,16 @@ var parallelVals = []int{
 func TestQueries(t *testing.T) {
 	for _, numPartitions := range numPartitionsVals {
 		for _, indexBehavior := range indexBehaviors {
-			for _, parallelism := range parallelVals {
-				if parallelism == 1 && numPartitions == testNumPartitions && indexBehavior.name == "nativeIndexes" {
-					// This case is covered by TestQueriesSimple
-					continue
-				}
-				testName := fmt.Sprintf("partitions=%d,indexes=%v,parallelism=%v", numPartitions, indexBehavior.name, parallelism)
-				harness := enginetest.NewMemoryHarness(testName, parallelism, numPartitions, indexBehavior.nativeIndexes, indexBehavior.driverInitializer)
-
-				t.Run(testName, func(t *testing.T) {
-					enginetest.TestQueries(t, harness)
-				})
+			if numPartitions == testNumPartitions && indexBehavior.name == "nativeIndexes" {
+				// This case is covered by TestQueriesSimple
+				continue
 			}
+			testName := fmt.Sprintf("partitions=%d,indexes=%v", numPartitions, indexBehavior.name)
+			harness := enginetest.NewMemoryHarness(testName, numPartitions, indexBehavior.driverInitializer)
+
+			t.Run(testName, func(t *testing.T) {
+				enginetest.TestQueries(t, harness)
+			})
 		}
 	}
 }
@@ -156,7 +149,7 @@ func TestSingleQuery(t *testing.T) {
 		Expected: []sql.Row{{-1}},
 	}
 
-	harness := enginetest.NewMemoryHarness("", 1, testNumPartitions, true, nil)
+	harness := enginetest.NewMemoryHarness("", testNumPartitions, nil)
 	// harness.UseServer()
 	harness.Setup(setup.MydbData, setup.NiltableData)
 	engine, err := harness.NewEngine(t)
@@ -185,7 +178,7 @@ func TestSingleQueryPrepared(t *testing.T) {
 		},
 	}
 
-	harness := enginetest.NewMemoryHarness("", 1, testNumPartitions, false, nil)
+	harness := enginetest.NewMemoryHarness("", testNumPartitions, nil)
 	harness.Setup(setup.KeylessSetup...)
 	engine, err := harness.NewEngine(t)
 	if err != nil {
@@ -223,15 +216,15 @@ func TestSingleScript(t *testing.T) {
 	}
 
 	for _, test := range scripts {
-		harness := enginetest.NewMemoryHarness("", 1, testNumPartitions, true, nil)
-		//harness.UseServer()
+		harness := enginetest.NewMemoryHarness("", testNumPartitions, nil)
+		// harness.UseServer()
 		engine, err := harness.NewEngine(t)
 		if err != nil {
 			panic(err)
 		}
 
-		//engine.EngineAnalyzer().Debug = true
-		//engine.EngineAnalyzer().Verbose = true
+		// engine.EngineAnalyzer().Debug = true
+		// engine.EngineAnalyzer().Verbose = true
 
 		enginetest.TestScriptWithEngine(t, engine, harness, test)
 	}
@@ -287,14 +280,12 @@ func TestQueryPlanTODOs(t *testing.T) {
 func TestVersionedQueries(t *testing.T) {
 	for _, numPartitions := range numPartitionsVals {
 		for _, indexInit := range indexBehaviors {
-			for _, parallelism := range parallelVals {
-				testName := fmt.Sprintf("partitions=%d,indexes=%v,parallelism=%v", numPartitions, indexInit.name, parallelism)
-				harness := enginetest.NewMemoryHarness(testName, parallelism, numPartitions, indexInit.nativeIndexes, indexInit.driverInitializer)
+			testName := fmt.Sprintf("partitions=%d,indexes=%v", numPartitions, indexInit.name)
+			harness := enginetest.NewMemoryHarness(testName, numPartitions, indexInit.driverInitializer)
 
-				t.Run(testName, func(t *testing.T) {
-					enginetest.TestVersionedQueries(t, harness)
-				})
-			}
+			t.Run(testName, func(t *testing.T) {
+				enginetest.TestVersionedQueries(t, harness)
+			})
 		}
 	}
 }
@@ -314,21 +305,16 @@ func TestAnsiQuotesSqlModePrepared(t *testing.T) {
 // Tests of choosing the correct execution plan independent of result correctness. Mostly useful for confirming that
 // the right indexes are being used for joining tables.
 func TestQueryPlans(t *testing.T) {
-	indexBehaviors := []*indexBehaviorTestParams{
-		{"nativeIndexes", nil, true},
-		{"nativeAndMergable", mergableIndexDriver, true},
-	}
-
 	for _, indexInit := range indexBehaviors {
 		t.Run(indexInit.name, func(t *testing.T) {
-			harness := enginetest.NewMemoryHarness(indexInit.name, 1, 2, indexInit.nativeIndexes, indexInit.driverInitializer)
+			harness := enginetest.NewMemoryHarness(indexInit.name, 2, indexInit.driverInitializer)
 			enginetest.TestQueryPlans(t, harness, queries.PlanTests)
 		})
 	}
 }
 
 func TestQueryPlanScripts(t *testing.T) {
-	enginetest.TestQueryPlanScripts(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestQueryPlanScripts(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestSingleQueryPlan(t *testing.T) {
@@ -412,7 +398,7 @@ func TestSingleQueryPlan(t *testing.T) {
 		},
 	}
 
-	harness := enginetest.NewMemoryHarness("nativeIndexes", 1, 2, true, nil)
+	harness := enginetest.NewMemoryHarness("nativeIndexes", 2, nil)
 	harness.Setup(setup.PlanSetup...)
 
 	for _, test := range tt {
@@ -428,81 +414,36 @@ func TestSingleQueryPlan(t *testing.T) {
 }
 
 func TestIntegrationQueryPlans(t *testing.T) {
-	indexBehaviors := []*indexBehaviorTestParams{
-		{"nativeIndexes", nil, true},
-	}
-
-	for _, indexInit := range indexBehaviors {
-		t.Run(indexInit.name, func(t *testing.T) {
-			harness := enginetest.NewMemoryHarness(indexInit.name, 1, 1, indexInit.nativeIndexes, indexInit.driverInitializer)
-			enginetest.TestIntegrationPlans(t, harness)
-		})
-	}
+	harness := enginetest.NewMemoryHarness("nativeIndexes", 1, nil)
+	enginetest.TestIntegrationPlans(t, harness)
 }
 
 func TestImdbQueryPlans(t *testing.T) {
 	t.Skip("tests are too slow")
-	indexBehaviors := []*indexBehaviorTestParams{
-		{"nativeIndexes", nil, true},
-	}
-
-	for _, indexInit := range indexBehaviors {
-		t.Run(indexInit.name, func(t *testing.T) {
-			harness := enginetest.NewMemoryHarness(indexInit.name, 1, 1, indexInit.nativeIndexes, indexInit.driverInitializer)
-			enginetest.TestImdbPlans(t, harness)
-		})
-	}
+	harness := enginetest.NewMemoryHarness("nativeIndexes", 1, nil)
+	enginetest.TestImdbPlans(t, harness)
 }
 
 func TestTpccQueryPlans(t *testing.T) {
-	indexBehaviors := []*indexBehaviorTestParams{
-		{"nativeIndexes", nil, true},
-	}
-
-	for _, indexInit := range indexBehaviors {
-		t.Run(indexInit.name, func(t *testing.T) {
-			harness := enginetest.NewMemoryHarness(indexInit.name, 1, 1, indexInit.nativeIndexes, indexInit.driverInitializer)
-			enginetest.TestTpccPlans(t, harness)
-		})
-	}
+	harness := enginetest.NewMemoryHarness("nativeIndexes", 1, nil)
+	enginetest.TestTpccPlans(t, harness)
 }
 
 func TestTpchQueryPlans(t *testing.T) {
-	indexBehaviors := []*indexBehaviorTestParams{
-		{"nativeIndexes", nil, true},
-	}
-
-	for _, indexInit := range indexBehaviors {
-		t.Run(indexInit.name, func(t *testing.T) {
-			harness := enginetest.NewMemoryHarness(indexInit.name, 1, 1, indexInit.nativeIndexes, indexInit.driverInitializer).RetainSessionAfterSetup()
-			enginetest.TestTpchPlans(t, harness)
-		})
-	}
+	harness := enginetest.NewMemoryHarness("nativeIndexes", 1, nil)
+	enginetest.TestTpchPlans(t, harness)
 }
 
 func TestTpcdsQueryPlans(t *testing.T) {
 	t.Skip("missing features")
-	indexBehaviors := []*indexBehaviorTestParams{
-		{"nativeIndexes", nil, true},
-	}
-
-	for _, indexInit := range indexBehaviors {
-		t.Run(indexInit.name, func(t *testing.T) {
-			harness := enginetest.NewMemoryHarness(indexInit.name, 1, 1, indexInit.nativeIndexes, indexInit.driverInitializer)
-			enginetest.TestTpcdsPlans(t, harness)
-		})
-	}
+	harness := enginetest.NewMemoryHarness("nativeIndexes", 1, nil)
+	enginetest.TestTpcdsPlans(t, harness)
 }
 
 func TestIndexQueryPlans(t *testing.T) {
-	indexBehaviors := []*indexBehaviorTestParams{
-		{"nativeIndexes", nil, true},
-		{"nativeAndMergable", mergableIndexDriver, true},
-	}
-
 	for _, indexInit := range indexBehaviors {
 		t.Run(indexInit.name, func(t *testing.T) {
-			harness := enginetest.NewMemoryHarness(indexInit.name, 1, 2, indexInit.nativeIndexes, indexInit.driverInitializer)
+			harness := enginetest.NewMemoryHarness(indexInit.name, 2, indexInit.driverInitializer)
 			enginetest.TestIndexQueryPlans(t, harness)
 		})
 	}
@@ -513,7 +454,7 @@ func TestQueryErrors(t *testing.T) {
 }
 
 func TestInfoSchema(t *testing.T) {
-	enginetest.TestInfoSchema(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestInfoSchema(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestMySqlDb(t *testing.T) {
@@ -620,68 +561,68 @@ func TestReplaceIntoErrors(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	enginetest.TestUpdate(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestUpdate(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestUpdateIgnore(t *testing.T) {
-	enginetest.TestUpdateIgnore(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestUpdateIgnore(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestUpdateErrors(t *testing.T) {
 	// TODO different errors
-	enginetest.TestUpdateErrors(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestUpdateErrors(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestOnUpdateExprScripts(t *testing.T) {
-	enginetest.TestOnUpdateExprScripts(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestOnUpdateExprScripts(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestSpatialUpdate(t *testing.T) {
-	enginetest.TestSpatialUpdate(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestSpatialUpdate(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestDeleteFromErrors(t *testing.T) {
-	enginetest.TestDeleteErrors(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestDeleteErrors(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestSpatialDeleteFrom(t *testing.T) {
-	enginetest.TestSpatialDelete(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestSpatialDelete(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestTruncate(t *testing.T) {
-	enginetest.TestTruncate(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestTruncate(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestDeleteFrom(t *testing.T) {
-	enginetest.TestDelete(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestDelete(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestConvert(t *testing.T) {
-	enginetest.TestConvert(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestConvert(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestScripts(t *testing.T) {
-	enginetest.TestScripts(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestScripts(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestSpatialScripts(t *testing.T) {
-	enginetest.TestSpatialScripts(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestSpatialScripts(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestSpatialIndexScripts(t *testing.T) {
-	enginetest.TestSpatialIndexScripts(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestSpatialIndexScripts(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestSpatialIndexPlans(t *testing.T) {
-	enginetest.TestSpatialIndexPlans(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestSpatialIndexPlans(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestNumericErrorScripts(t *testing.T) {
-	enginetest.TestNumericErrorScripts(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestNumericErrorScripts(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestUserPrivileges(t *testing.T) {
-	harness := enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver)
+	harness := enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver)
 	if harness.IsUsingServer() {
 		t.Skip("TestUserPrivileges test depend on Context to switch the user to run test queries")
 	}
@@ -689,7 +630,7 @@ func TestUserPrivileges(t *testing.T) {
 }
 
 func TestUserAuthentication(t *testing.T) {
-	harness := enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver)
+	harness := enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver)
 	if harness.IsUsingServer() {
 		t.Skip("TestUserPrivileges test depend on Context to switch the user to run test queries")
 	}
@@ -697,11 +638,11 @@ func TestUserAuthentication(t *testing.T) {
 }
 
 func TestPrivilegePersistence(t *testing.T) {
-	enginetest.TestPrivilegePersistence(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestPrivilegePersistence(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestComplexIndexQueries(t *testing.T) {
-	harness := enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver)
+	harness := enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver)
 	enginetest.TestComplexIndexQueries(t, harness)
 }
 
@@ -722,7 +663,7 @@ func TestBrokenTriggers(t *testing.T) {
 
 func TestStoredProcedures(t *testing.T) {
 	for i, test := range queries.ProcedureLogicTests {
-		//TODO: the RowIter returned from a SELECT should not take future changes into account
+		// TODO: the RowIter returned from a SELECT should not take future changes into account
 		if test.Name == "FETCH captures state at OPEN" {
 			queries.ProcedureLogicTests[0], queries.ProcedureLogicTests[i] = queries.ProcedureLogicTests[i], queries.ProcedureLogicTests[0]
 			queries.ProcedureLogicTests = queries.ProcedureLogicTests[1:]
@@ -967,7 +908,7 @@ func TestPrepared(t *testing.T) {
 }
 
 func TestPreparedInsert(t *testing.T) {
-	enginetest.TestPreparedInsert(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestPreparedInsert(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestPreparedStatements(t *testing.T) {
@@ -1090,7 +1031,7 @@ func findTable(dbs []sql.Database, tableName string) (sql.Database, sql.Table) {
 }
 
 func TestSQLLogicTests(t *testing.T) {
-	enginetest.TestSQLLogicTests(t, enginetest.NewMemoryHarness("default", 1, testNumPartitions, true, mergableIndexDriver))
+	enginetest.TestSQLLogicTests(t, enginetest.NewMemoryHarness("default", testNumPartitions, mergableIndexDriver))
 }
 
 func TestSQLLogicTestFiles(t *testing.T) {
diff --git a/enginetest/memory_harness.go b/enginetest/memory_harness.go
index 62c8a64e25..f42085eb3e 100644
--- a/enginetest/memory_harness.go
+++ b/enginetest/memory_harness.go
@@ -37,13 +37,11 @@ type IndexDriverInitializer func([]sql.Database) sql.IndexDriver
 
 type MemoryHarness struct {
 	name                      string
-	parallelism               int
 	numTablePartitions        int
 	readonly                  bool
 	provider                  sql.DatabaseProvider
 	indexDriverInitializer    IndexDriverInitializer
 	driver                    sql.IndexDriver
-	nativeIndexSupport        bool
 	skippedQueries            map[string]struct{}
 	session                   sql.Session
 	retainSession             bool
@@ -65,7 +63,7 @@ var _ ClientHarness = (*MemoryHarness)(nil)
 var _ ServerHarness = (*MemoryHarness)(nil)
 var _ sql.ExternalStoredProcedureProvider = (*MemoryHarness)(nil)
 
-func NewMemoryHarness(name string, parallelism int, numTablePartitions int, useNativeIndexes bool, driverInitializer IndexDriverInitializer) *MemoryHarness {
+func NewMemoryHarness(name string, numTablePartitions int, driverInitializer IndexDriverInitializer) *MemoryHarness {
 	externalProcedureRegistry := sql.NewExternalStoredProcedureRegistry()
 	for _, esp := range memory.ExternalStoredProcedures {
 		externalProcedureRegistry.Register(esp)
@@ -80,8 +78,6 @@ func NewMemoryHarness(name string, parallelism int, numTablePartitions int, useN
 		name:                      name,
 		numTablePartitions:        numTablePartitions,
 		indexDriverInitializer:    driverInitializer,
-		parallelism:               parallelism,
-		nativeIndexSupport:        useNativeIndexes,
 		skippedQueries:            make(map[string]struct{}),
 		externalProcedureRegistry: externalProcedureRegistry,
 		mu:                        &sync.Mutex{},
@@ -90,7 +86,7 @@ func NewMemoryHarness(name string, parallelism int, numTablePartitions int, useN
 }
 
 func NewDefaultMemoryHarness() *MemoryHarness {
-	return NewMemoryHarness("default", 1, testNumPartitions, true, nil)
+	return NewMemoryHarness("default", testNumPartitions, nil)
 }
 
 func NewReadOnlyMemoryHarness() *MemoryHarness {
@@ -218,9 +214,6 @@ func (m *MemoryHarness) NewTableAsOf(db sql.VersionedDatabase, name string, sche
 		panic(fmt.Sprintf("unexpected database type %T", db))
 	}
 	table := memory.NewPartitionedTableRevision(baseDb, name, schema, fkColl, m.numTablePartitions)
-	if m.nativeIndexSupport {
-		table.EnablePrimaryKeyIndexes()
-	}
 	if ro, ok := db.(memory.ReadOnlyDatabase); ok {
 		ro.HistoryDatabase.AddTableAsOf(name, table, asOf)
 	} else {
@@ -238,7 +231,7 @@ func (m *MemoryHarness) SnapshotTable(db sql.VersionedDatabase, name string, asO
 }
 
 func (m *MemoryHarness) SupportsNativeIndexCreation() bool {
-	return m.nativeIndexSupport
+	return true
 }
 
 func (m *MemoryHarness) SupportsForeignKeys() bool {
@@ -249,10 +242,6 @@ func (m *MemoryHarness) SupportsKeylessTables() bool {
 	return true
 }
 
-func (m *MemoryHarness) Parallelism() int {
-	return m.parallelism
-}
-
 func (m *MemoryHarness) NewContext() *sql.Context {
 	if m.session == nil {
 		m.session = m.newSession()
@@ -320,7 +309,6 @@ func (m *MemoryHarness) getProvider() sql.DatabaseProvider {
 
 func (m *MemoryHarness) NewDatabaseProvider() sql.MutableDatabaseProvider {
 	return memory.NewDBProviderWithOpts(
-		memory.NativeIndexProvider(m.nativeIndexSupport),
 		memory.HistoryProvider(true))
 }
 
diff --git a/enginetest/plangen/cmd/plangen/main.go b/enginetest/plangen/cmd/plangen/main.go
index 9dadbc78df..a311b6d3c0 100644
--- a/enginetest/plangen/cmd/plangen/main.go
+++ b/enginetest/plangen/cmd/plangen/main.go
@@ -167,7 +167,7 @@ func analyzeQuery(ctx *sql.Context, engine enginetest.QueryEngine, query string)
 }
 
 func generatePlansForSuite(spec PlanSpec, w *bytes.Buffer) error {
-	harness := enginetest.NewMemoryHarness("default", 1, 1, true, nil)
+	harness := enginetest.NewMemoryHarness("default", 1, nil)
 	s := specSetup(spec.Name)
 	harness.Setup(s...)
 	engine, err := harness.NewEngine(nil)
@@ -246,7 +246,7 @@ func generatePlansForSuite(spec PlanSpec, w *bytes.Buffer) error {
 }
 
 func generatePlansForScriptSuite(spec PlanSpec, w *bytes.Buffer) error {
-	harness := enginetest.NewMemoryHarness("default", 1, 1, true, nil)
+	harness := enginetest.NewMemoryHarness("default", 1, nil)
 	harness.Setup(setup.MydbData)
 	_, _ = fmt.Fprintf(w, "var %s = []ScriptTest{\n", spec.Name)
 	for _, tt := range queries.QueryPlanScriptTests {
@@ -369,7 +369,7 @@ func usage() {
 
 	fmt.Fprintf(os.Stderr, "\tplangen [flags] spec\n\n")
 
-	//fmt.Fprintf(os.Stderr, "Flags:\n")
+	// fmt.Fprintf(os.Stderr, "Flags:\n")
 
 	flag.PrintDefaults()
 
diff --git a/memory/database.go b/memory/database.go
index e38a88ee98..150172706f 100644
--- a/memory/database.go
+++ b/memory/database.go
@@ -55,15 +55,14 @@ var _ sql.SchemaValidator = (*BaseDatabase)(nil)
 
 // BaseDatabase is an in-memory database that can't store views, only for testing the engine
 type BaseDatabase struct {
-	tables            map[string]MemTable
-	fkColl            *ForeignKeyCollection
-	tablesMu          *sync.RWMutex
-	name              string
-	triggers          []sql.TriggerDefinition
-	storedProcedures  []sql.StoredProcedureDetails
-	events            []sql.EventDefinition
-	collation         sql.CollationID
-	primaryKeyIndexes bool
+	tables           map[string]MemTable
+	fkColl           *ForeignKeyCollection
+	tablesMu         *sync.RWMutex
+	name             string
+	triggers         []sql.TriggerDefinition
+	storedProcedures []sql.StoredProcedureDetails
+	events           []sql.EventDefinition
+	collation        sql.CollationID
 }
 
 var _ MemoryDatabase = (*Database)(nil)
@@ -92,11 +91,6 @@ func (d *BaseDatabase) ValidateSchema(schema sql.Schema) error {
 	return validateMaxRowLength(schema)
 }
 
-// EnablePrimaryKeyIndexes causes every table created in this database to use an index on its primary partitionKeys
-func (d *BaseDatabase) EnablePrimaryKeyIndexes() {
-	d.primaryKeyIndexes = true
-}
-
 func (d *BaseDatabase) Database() *BaseDatabase {
 	return d
 }
@@ -270,9 +264,6 @@ func (d *BaseDatabase) CreateTable(ctx *sql.Context, name string, schema sql.Pri
 	table := NewTableWithCollation(d, name, schema, d.fkColl, collation)
 	table.db = d
 	table.data.comment = comment
-	if d.primaryKeyIndexes {
-		table.EnablePrimaryKeyIndexes()
-	}
 
 	d.AddTable(name, table)
 	sess := SessionFromContext(ctx)
@@ -292,9 +283,6 @@ func (d *BaseDatabase) CreateIndexedTable(ctx *sql.Context, name string, sch sql
 
 	table := NewTableWithCollation(d, name, sch, d.fkColl, collation)
 	table.db = d
-	if d.primaryKeyIndexes {
-		table.EnablePrimaryKeyIndexes()
-	}
 
 	for _, idxCol := range idxDef.Columns {
 		idx := sch.Schema.IndexOfColName(idxCol.Name)
diff --git a/memory/provider.go b/memory/provider.go
index 24f81ae413..c85f617814 100644
--- a/memory/provider.go
+++ b/memory/provider.go
@@ -22,7 +22,6 @@ type DbProvider struct {
 	mu                        *sync.RWMutex
 	history                   bool
 	readOnly                  bool
-	nativeIndexes             bool
 }
 
 type ProviderOption func(*DbProvider)
@@ -79,12 +78,6 @@ func ReadOnlyProvider(enableReadOnly bool) ProviderOption {
 	}
 }
 
-func NativeIndexProvider(useNativeIndexes bool) ProviderOption {
-	return func(pro *DbProvider) {
-		pro.nativeIndexes = useNativeIndexes
-	}
-}
-
 // HistoryProvider returns a ProviderOption to construct a memoryDBProvider that uses history databases
 func HistoryProvider(enableHistory bool) ProviderOption {
 	return func(pro *DbProvider) {
@@ -155,19 +148,10 @@ func (pro *DbProvider) CreateDatabase(_ *sql.Context, name string) (err error) {
 	var db sql.Database
 	if pro.readOnly {
 		db = NewReadOnlyDatabase(name)
-		if pro.nativeIndexes {
-			db.(ReadOnlyDatabase).EnablePrimaryKeyIndexes()
-		}
 	} else if pro.history {
 		db = NewHistoryDatabase(name)
-		if pro.nativeIndexes {
-			db.(*HistoryDatabase).EnablePrimaryKeyIndexes()
-		}
 	} else {
 		db = NewDatabase(name)
-		if pro.nativeIndexes {
-			db.(*Database).EnablePrimaryKeyIndexes()
-		}
 	}
 
 	pro.dbs[strings.ToLower(db.Name())] = db
diff --git a/memory/table.go b/memory/table.go
index f70d006929..e1b07f42f0 100644
--- a/memory/table.go
+++ b/memory/table.go
@@ -1790,12 +1790,6 @@ func (t *Table) Projections() []string {
 	return t.projection
 }
 
-// EnablePrimaryKeyIndexes enables the use of primary key indexes on this table.
-func (t *Table) EnablePrimaryKeyIndexes() {
-	t.pkIndexesEnabled = true
-	t.data.primaryKeyIndexes = true
-}
-
 func (t *Table) dbName() string {
 	if t.db != nil {
 		return t.db.Name()
@@ -1809,24 +1803,22 @@ func (t *Table) GetIndexes(ctx *sql.Context) ([]sql.Index, error) {
 
 	indexes := make([]sql.Index, 0)
 
-	if data.primaryKeyIndexes {
-		if len(data.schema.PkOrdinals) > 0 {
-			exprs := make([]sql.Expression, len(data.schema.PkOrdinals))
-			for i, ord := range data.schema.PkOrdinals {
-				column := data.schema.Schema[ord]
-				idx, field := data.getColumnOrdinal(column.Name)
-				exprs[i] = expression.NewGetFieldWithTable(idx, 0, field.Type, t.dbName(), t.name, field.Name, field.Nullable)
-			}
-			indexes = append(indexes, &Index{
-				DB:         t.dbName(),
-				DriverName: "",
-				Tbl:        t,
-				TableName:  t.name,
-				Exprs:      exprs,
-				Name:       "PRIMARY",
-				Unique:     true,
-			})
-		}
+	if len(data.schema.PkOrdinals) > 0 {
+		exprs := make([]sql.Expression, len(data.schema.PkOrdinals))
+		for i, ord := range data.schema.PkOrdinals {
+			column := data.schema.Schema[ord]
+			idx, field := data.getColumnOrdinal(column.Name)
+			exprs[i] = expression.NewGetFieldWithTable(idx, 0, field.Type, t.dbName(), t.name, field.Name, field.Nullable)
+		}
+		indexes = append(indexes, &Index{
+			DB:         t.dbName(),
+			DriverName: "",
+			Tbl:        t,
+			TableName:  t.name,
+			Exprs:      exprs,
+			Name:       "PRIMARY",
+			Unique:     true,
+		})
 	}
 
 	nonPrimaryIndexes := make([]sql.Index, len(data.indexes))
diff --git a/memory/table_data.go b/memory/table_data.go
index 90ff00142f..5adc0e9f2b 100644
--- a/memory/table_data.go
+++ b/memory/table_data.go
@@ -47,7 +47,6 @@ type TableData struct {
 	autoColIdx              int
 	autoIncVal              uint64
 	collation               sql.CollationID
-	primaryKeyIndexes       bool
 }
 
 type indexName string
@@ -62,10 +61,9 @@ type primaryRowLocation struct {
 // Table returns a table with this data
 func (td TableData) Table(database *BaseDatabase) *Table {
 	return &Table{
-		db:               database,
-		name:             td.tableName,
-		data:             &td,
-		pkIndexesEnabled: td.primaryKeyIndexes,
+		db:   database,
+		name: td.tableName,
+		data: &td,
 	}
 }
 
diff --git a/server/handler_test.go b/server/handler_test.go
index eb0e715169..c828d62751 100644
--- a/server/handler_test.go
+++ b/server/handler_test.go
@@ -1282,7 +1282,6 @@ func setupMemDB(require *require.Assertions) (*sqle.Engine, *memory.DbProvider)
 	ctx := sql.NewContext(context.Background(), sql.WithSession(memory.NewSession(sql.NewBaseSession(), pro)))
 
 	tableTest := memory.NewTable(db, "test", sql.NewPrimaryKeySchema(sql.Schema{{Name: "c1", Type: types.Int32, Source: "test"}}), nil)
-	tableTest.EnablePrimaryKeyIndexes()
 
 	for i := 0; i < 1010; i++ {
 		require.NoError(tableTest.Insert(
diff --git a/sql/analyzer/biased_coster_test.go b/sql/analyzer/biased_coster_test.go
index 15901a524f..9a2e48c569 100644
--- a/sql/analyzer/biased_coster_test.go
+++ b/sql/analyzer/biased_coster_test.go
@@ -31,7 +31,6 @@ import (
 
 func TestBiasedCoster(t *testing.T) {
 	db := memory.NewDatabase("mydb")
-	db.EnablePrimaryKeyIndexes()
 	pro := memory.NewDBProvider(db)
 	ctx := newContext(pro)
 
@@ -45,9 +44,6 @@ func TestBiasedCoster(t *testing.T) {
 		{Name: "b", Type: types.Int64, Source: "ab"},
 	}, 0), nil)
 
-	xy.EnablePrimaryKeyIndexes()
-	ab.EnablePrimaryKeyIndexes()
-
 	ab.Insert(ctx, sql.Row{int64(0), int64(0)})
 	ab.Insert(ctx, sql.Row{int64(1), int64(1)})
 	ab.Insert(ctx, sql.Row{int64(2), int64(2)})
diff --git a/sql/analyzer/indexed_joins_test.go b/sql/analyzer/indexed_joins_test.go
index 08602f816a..0d1fb9cdf2 100644
--- a/sql/analyzer/indexed_joins_test.go
+++ b/sql/analyzer/indexed_joins_test.go
@@ -68,39 +68,34 @@ func TestHashJoins(t *testing.T) {
 	}
 }
 
-var childSchema = sql.NewPrimaryKeySchema(sql.Schema{
-	{Name: "i", Type: types.Int64, Nullable: true},
-	{Name: "s", Type: types.Text, Nullable: true},
-})
-
 func uv(db *memory.Database) sql.Node {
 	t := memory.NewTable(db, "uv", sql.NewPrimaryKeySchema(sql.Schema{
-		{Name: "u", Type: types.Int64, Nullable: true},
-		{Name: "v", Type: types.Text, Nullable: true},
+		{Name: "u", Type: types.Int64, Nullable: true, Source: "uv"},
+		{Name: "v", Type: types.Text, Nullable: true, Source: "uv"},
 	}, 0), nil)
 	return plan.NewResolvedTable(t, db, nil).WithId(4).WithColumns(sql.NewColSet(7, 8))
 }
 
 func xy(db *memory.Database) sql.Node {
 	t := memory.NewTable(db, "xy", sql.NewPrimaryKeySchema(sql.Schema{
-		{Name: "x", Type: types.Int64, Nullable: true},
-		{Name: "y", Type: types.Text, Nullable: true},
+		{Name: "x", Type: types.Int64, Nullable: true, Source: "xy"},
+		{Name: "y", Type: types.Text, Nullable: true, Source: "xy"},
 	}, 0), nil)
 	return plan.NewResolvedTable(t, db, nil).WithId(1).WithColumns(sql.NewColSet(1, 2))
 }
 
 func ab(db *memory.Database) sql.Node {
 	t := memory.NewTable(db, "ab", sql.NewPrimaryKeySchema(sql.Schema{
-		{Name: "a", Type: types.Int64, Nullable: true},
-		{Name: "b", Type: types.Text, Nullable: true},
+		{Name: "a", Type: types.Int64, Nullable: true, Source: "ab"},
+		{Name: "b", Type: types.Text, Nullable: true, Source: "ab"},
 	}, 0), nil)
 	return plan.NewResolvedTable(t, db, nil).WithId(2).WithColumns(sql.NewColSet(3, 4))
 }
 
 func pq(db *memory.Database) sql.Node {
 	t := memory.NewTable(db, "pq", sql.NewPrimaryKeySchema(sql.Schema{
-		{Name: "p", Type: types.Int64, Nullable: true},
-		{Name: "q", Type: types.Text, Nullable: true},
+		{Name: "p", Type: types.Int64, Nullable: true, Source: "pq"},
+		{Name: "q", Type: types.Text, Nullable: true, Source: "pq"},
 	}, 0), nil)
 	return plan.NewResolvedTable(t, db, nil).WithId(3).WithColumns(sql.NewColSet(5, 6))
 }
diff --git a/sql/analyzer/optimization_rules_test.go b/sql/analyzer/optimization_rules_test.go
index dc256f330e..69024fc3f9 100644
--- a/sql/analyzer/optimization_rules_test.go
+++ b/sql/analyzer/optimization_rules_test.go
@@ -191,10 +191,10 @@ func TestPushNotFilters(t *testing.T) {
 			exp: "(xy.x < 0)",
 		},
 		// TODO this isn't correct for join filters
-		//{
+		// {
 		//	in:  "NOT(y IS NULL)",
 		//	exp: "((xy.x < NULL) OR (xy.x > NULL))",
-		//},
+		// },
 		{
 			in:  "NOT (x > 2 AND y > 2)",
 			exp: "((xy.x <= 2) OR (xy.y <= 2))",
@@ -244,14 +244,14 @@ func newTestCatalog(db *memory.Database) *sql.MapCatalog {
 	}
 
 	cat.Tables["xy"] = memory.NewTable(db, "xy", sql.NewPrimaryKeySchema(sql.Schema{
-		{Name: "x", Type: types.Int64},
-		{Name: "y", Type: types.Int64},
-		{Name: "z", Type: types.Int64},
+		{Name: "x", Type: types.Int64, Source: "xy"},
+		{Name: "y", Type: types.Int64, Source: "xy"},
+		{Name: "z", Type: types.Int64, Source: "xy"},
 	}, 0), nil)
 	cat.Tables["uv"] = memory.NewTable(db, "uv", sql.NewPrimaryKeySchema(sql.Schema{
-		{Name: "u", Type: types.Int64},
-		{Name: "v", Type: types.Int64},
-		{Name: "w", Type: types.Int64},
+		{Name: "u", Type: types.Int64, Source: "uv"},
+		{Name: "v", Type: types.Int64, Source: "uv"},
+		{Name: "w", Type: types.Int64, Source: "uv"},
 	}, 0), nil)
 
 	db.AddTable("xy", cat.Tables["xy"].(memory.MemTable))
diff --git a/sql/memo/join_order_builder_test.go b/sql/memo/join_order_builder_test.go
index a0dd6b63ab..0e63b9cd83 100644
--- a/sql/memo/join_order_builder_test.go
+++ b/sql/memo/join_order_builder_test.go
@@ -691,7 +691,6 @@ func childSchema(source string) sql.PrimaryKeySchema {
 
 func tableNode(db *memory.Database, name string) sql.Node {
 	t := memory.NewTable(db, name, childSchema(name), nil)
-	t.EnablePrimaryKeyIndexes()
 	tabId, colId := getIds([]string{name, "x"})
 	colset := sql.NewColSet(sql.ColumnId(colId), sql.ColumnId(colId+1), sql.ColumnId(colId+2))
 	return plan.NewResolvedTable(t, db, nil).WithId(sql.TableId(tabId)).WithColumns(colset)