replaced index types.Map with durable.IndexSet

go/cmd/dolt/commands/schcmds/import.go

@@ -30,6 +30,7 @@ import (
 	"github.com/dolthub/dolt/go/cmd/dolt/errhand"
 	eventsapi "github.com/dolthub/dolt/go/gen/proto/dolt/services/eventsapi/v1alpha1"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb/durable"
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
 	"github.com/dolthub/dolt/go/libraries/doltcore/env/actions"
 	"github.com/dolthub/dolt/go/libraries/doltcore/rowconv"
@@ -302,15 +303,15 @@ func importSchema(ctx context.Context, dEnv *env.DoltEnv, apr *argparser.ArgPars
 			return errhand.BuildDError("error: failed to create table.").AddCause(err).Build()
 		}
 
-		indexData := empty
+		var indexSet durable.IndexSet
 		if tblExists {
-			indexData, err = tbl.GetIndexData(ctx)
+			indexSet, err = tbl.GetIndexData(ctx)
 			if err != nil {
 				return errhand.BuildDError("error: failed to create table.").AddCause(err).Build()
 			}
 		}
 
-		tbl, err = doltdb.NewTable(ctx, root.VRW(), sch, empty, indexData, nil)
+		tbl, err = doltdb.NewTable(ctx, root.VRW(), sch, empty, indexSet, nil)
 		if err != nil {
 			return errhand.BuildDError("error: failed to create table.").AddCause(err).Build()
 		}

go/libraries/doltcore/diff/docs_diff_test.go

@@ -118,8 +118,7 @@ func TestDocDiff(t *testing.T) {
 }
 
 func CreateTestTable(vrw types.ValueReadWriter, tSchema schema.Schema, rowData types.Map) (*doltdb.Table, error) {
-	empty, _ := types.NewMap(context.Background(), vrw)
-	tbl, err := doltdb.NewTable(context.Background(), vrw, tSchema, rowData, empty, nil)
+	tbl, err := doltdb.NewTable(context.Background(), vrw, tSchema, rowData, nil, nil)
 
 	if err != nil {
 		return nil, err

go/libraries/doltcore/doltdb/doltdb_test.go

@@ -69,8 +69,7 @@ func createTestSchema(t *testing.T) schema.Schema {
 }
 
 func CreateTestTable(vrw types.ValueReadWriter, tSchema schema.Schema, rowData types.Map) (*Table, error) {
-	empty, _ := types.NewMap(context.Background(), vrw)
-	tbl, err := NewTable(context.Background(), vrw, tSchema, rowData, empty, nil)
+	tbl, err := NewTable(context.Background(), vrw, tSchema, rowData, nil, nil)
 
 	if err != nil {
 		return nil, err

go/libraries/doltcore/doltdb/durable/index.go

@@ -0,0 +1,85 @@
+// Copyright 2021 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package durable
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/dolthub/dolt/go/store/types"
+)
+
+type IndexSet interface {
+	// GetIndex gets an index from the set.
+	GetIndex(ctx context.Context, name string) (types.Map, error)
+
+	// PutIndex puts an index into the set.
+	// todo(andy): should this be immutable
+	PutIndex(ctx context.Context, name string, idx types.Map) error
+
+	// DropIndex removes an index from the set.
+	DropIndex(ctx context.Context, name string) error
+}
+
+func NewIndexSet(ctx context.Context, vrw types.ValueReadWriter) IndexSet {
+	empty, _ := types.NewMap(ctx, vrw)
+	return &nomsIndexSet{
+		indexes: empty,
+		vrw:     vrw,
+	}
+}
+
+func MapFromIndexSet(ic IndexSet) types.Map {
+	return ic.(*nomsIndexSet).indexes
+}
+
+type nomsIndexSet struct {
+	indexes types.Map
+	vrw     types.ValueReadWriter
+}
+
+var _ IndexSet = &nomsIndexSet{}
+
+func (c *nomsIndexSet) GetIndex(ctx context.Context, name string) (types.Map, error) {
+	v, ok, err := c.indexes.MaybeGet(ctx, types.String(name))
+	if !ok {
+		err = fmt.Errorf("index %s not found in IndexSet", name)
+	}
+	if err != nil {
+		return types.Map{}, err
+	}
+
+	v, err = v.(types.Ref).TargetValue(ctx, c.vrw)
+	if err != nil {
+		return types.Map{}, err
+	}
+
+	return v.(types.Map), nil
+}
+
+func (c *nomsIndexSet) PutIndex(ctx context.Context, name string, idx types.Map) (err error) {
+	ref, err := refFromNomsValue(ctx, c.vrw, idx)
+	if err != nil {
+		return err
+	}
+
+	c.indexes, err = c.indexes.Edit().Set(types.String(name), ref).Map(ctx)
+	return err
+}
+
+func (c *nomsIndexSet) DropIndex(ctx context.Context, name string) (err error) {
+	c.indexes, err = c.indexes.Edit().Remove(types.String(name)).Map(ctx)
+	return err
+}

go/libraries/doltcore/doltdb/durable/table.go

@@ -60,9 +60,9 @@ type Table interface {
 	SetTableRows(ctx context.Context, rows types.Map) (Table, error)
 
 	// GetIndexes returns the secondary indexes for this table.
-	GetIndexes(ctx context.Context) (types.Map, error)
+	GetIndexes(ctx context.Context) (IndexSet, error)
 	// SetIndexes sets the secondary indexes for this table.
-	SetIndexes(ctx context.Context, indexes types.Map) (Table, error)
+	SetIndexes(ctx context.Context, indexes IndexSet) (Table, error)
 
 	// GetConflicts returns the merge conflicts for this table.
 	GetConflicts(ctx context.Context) (conflict.ConflictSchema, types.Map, error)
@@ -92,7 +92,7 @@ type nomsTable struct {
 var _ Table = nomsTable{}
 
 // NewNomsTable makes a new Table.
-func NewNomsTable(ctx context.Context, vrw types.ValueReadWriter, sch schema.Schema, rowData types.Map, indexData types.Map, autoIncVal types.Value) (Table, error) {
+func NewNomsTable(ctx context.Context, vrw types.ValueReadWriter, sch schema.Schema, rowData types.Map, indexes IndexSet, autoIncVal types.Value) (Table, error) {
 	schVal, err := encoding.MarshalSchemaAsNomsValue(ctx, vrw, sch)
 	if err != nil {
 		return nil, err
@@ -108,7 +108,11 @@ func NewNomsTable(ctx context.Context, vrw types.ValueReadWriter, sch schema.Sch
 		return nil, err
 	}
 
-	indexesRef, err := refFromNomsValue(ctx, vrw, indexData)
+	if indexes == nil {
+		indexes = NewIndexSet(ctx, vrw)
+	}
+
+	indexesRef, err := refFromNomsValue(ctx, vrw, MapFromIndexSet(indexes))
 	if err != nil {
 		return nil, err
 	}
@@ -251,30 +255,33 @@ func (t nomsTable) GetTableRows(ctx context.Context) (types.Map, error) {
 }
 
 // GetIndexes implements Table.
-func (t nomsTable) GetIndexes(ctx context.Context) (types.Map, error) {
-	indexesVal, ok, err := t.tableStruct.MaybeGet(indexesKey)
+func (t nomsTable) GetIndexes(ctx context.Context) (IndexSet, error) {
+	iv, ok, err := t.tableStruct.MaybeGet(indexesKey)
 	if err != nil {
-		return types.EmptyMap, err
+		return nil, err
 	}
 	if !ok {
-		newEmptyMap, err := types.NewMap(ctx, t.vrw)
-		if err != nil {
-			return types.EmptyMap, err
-		}
-		return newEmptyMap, nil
+		return NewIndexSet(ctx, t.vrw), nil
 	}
 
-	indexesMap, err := indexesVal.(types.Ref).TargetValue(ctx, t.vrw)
+	im, err := iv.(types.Ref).TargetValue(ctx, t.vrw)
 	if err != nil {
-		return types.EmptyMap, err
+		return nil, err
 	}
 
-	return indexesMap.(types.Map), nil
+	return &nomsIndexSet{
+		indexes: im.(types.Map),
+		vrw:     t.vrw,
+	}, nil
 }
 
 // SetIndexes implements Table.
-func (t nomsTable) SetIndexes(ctx context.Context, indexesMap types.Map) (Table, error) {
-	indexesRef, err := refFromNomsValue(ctx, t.vrw, indexesMap)
+func (t nomsTable) SetIndexes(ctx context.Context, indexes IndexSet) (Table, error) {
+	if indexes == nil {
+		indexes = NewIndexSet(ctx, t.vrw)
+	}
+
+	indexesRef, err := refFromNomsValue(ctx, t.vrw, MapFromIndexSet(indexes))
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/doltdb/root_val.go

@@ -735,26 +735,16 @@ func (root *RootValue) CreateEmptyTable(ctx context.Context, tName string, sch s
 		return nil, err
 	}
 
-	emptyRef, err := WriteValAndGetRef(ctx, root.VRW(), empty)
-	if err != nil {
-		return nil, err
-	}
-
-	ed := empty.Edit()
+	indexes := durable.NewIndexSet(ctx, root.VRW())
 	err = sch.Indexes().Iter(func(index schema.Index) (stop bool, err error) {
-		// create an empty indexRowData map for every index
-		ed.Set(types.String(index.Name()), emptyRef)
+		// create an empty map for every index
+		err = indexes.PutIndex(ctx, index.Name(), empty)
 		return
 	})
 	if err != nil {
 		return nil, err
 	}
 
-	indexes, err := ed.Map(ctx)
-	if err != nil {
-		return nil, err
-	}
-
 	tbl, err := NewTable(ctx, root.VRW(), sch, empty, indexes, nil)
 	if err != nil {
 		return nil, err

go/libraries/doltcore/doltdb/table.go

@@ -74,8 +74,8 @@ type Table struct {
 }
 
 // NewTable creates a noms Struct which stores row data, index data, and schema.
-func NewTable(ctx context.Context, vrw types.ValueReadWriter, sch schema.Schema, rowData types.Map, indexData types.Map, autoIncVal types.Value) (*Table, error) {
-	dt, err := durable.NewNomsTable(ctx, vrw, sch, rowData, indexData, autoIncVal)
+func NewTable(ctx context.Context, vrw types.ValueReadWriter, sch schema.Schema, rowData types.Map, indexes durable.IndexSet, autoIncVal types.Value) (*Table, error) {
+	dt, err := durable.NewNomsTable(ctx, vrw, sch, rowData, indexes, autoIncVal)
 	if err != nil {
 		return nil, err
 	}
@@ -277,13 +277,13 @@ func (t *Table) ResolveConflicts(ctx context.Context, pkTuples []types.Value) (i
 }
 
 // GetIndexData returns the internal index map which goes from index name to a ref of the row data map.
-func (t *Table) GetIndexData(ctx context.Context) (types.Map, error) {
+func (t *Table) GetIndexData(ctx context.Context) (durable.IndexSet, error) {
 	return t.table.GetIndexes(ctx)
 }
 
 // SetIndexData replaces the current internal index map, and returns an updated Table.
-func (t *Table) SetIndexData(ctx context.Context, indexesMap types.Map) (*Table, error) {
-	table, err := t.table.SetIndexes(ctx, indexesMap)
+func (t *Table) SetIndexData(ctx context.Context, indexes durable.IndexSet) (*Table, error) {
+	table, err := t.table.SetIndexes(ctx, indexes)
 	if err != nil {
 		return nil, err
 	}
@@ -292,92 +292,66 @@ func (t *Table) SetIndexData(ctx context.Context, indexesMap types.Map) (*Table,
 
 // GetIndexRowData retrieves the underlying map of an index, in which the primary key consists of all indexed columns.
 func (t *Table) GetIndexRowData(ctx context.Context, indexName string) (types.Map, error) {
-	indexesMap, err := t.GetIndexData(ctx)
+	indexes, err := t.GetIndexData(ctx)
 	if err != nil {
 		return types.EmptyMap, err
 	}
 
-	indexMapRef, ok, err := indexesMap.MaybeGet(ctx, types.String(indexName))
-	if err != nil {
-		return types.EmptyMap, err
-	}
-	if !ok {
-		return types.EmptyMap, fmt.Errorf("index `%s` is missing its data", indexName)
-	}
-
-	indexMap, err := indexMapRef.(types.Ref).TargetValue(ctx, t.ValueReadWriter())
-	if err != nil {
-		return types.EmptyMap, err
-	}
-
-	return indexMap.(types.Map), nil
+	return indexes.GetIndex(ctx, indexName)
 }
 
 // SetIndexRowData replaces the current row data for the given index and returns an updated Table.
 func (t *Table) SetIndexRowData(ctx context.Context, indexName string, indexRowData types.Map) (*Table, error) {
-	indexesMap, err := t.GetIndexData(ctx)
+	indexes, err := t.GetIndexData(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	indexRowDataRef, err := WriteValAndGetRef(ctx, t.ValueReadWriter(), indexRowData)
-	if err != nil {
-		return nil, err
-	}
-	indexesMap, err = indexesMap.Edit().Set(types.String(indexName), indexRowDataRef).Map(ctx)
-	if err != nil {
+	if err = indexes.PutIndex(ctx, indexName, indexRowData); err != nil {
 		return nil, err
 	}
 
-	return t.SetIndexData(ctx, indexesMap)
+	return t.SetIndexData(ctx, indexes)
 }
 
 // DeleteIndexRowData removes the underlying map of an index, along with its key entry. This should only be used
 // when removing an index altogether. If the intent is to clear an index's data, then use SetIndexRowData with
 // an empty map.
 func (t *Table) DeleteIndexRowData(ctx context.Context, indexName string) (*Table, error) {
-	indexesMap, err := t.GetIndexData(ctx)
+	indexes, err := t.GetIndexData(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	key := types.String(indexName)
-	if has, err := indexesMap.Has(ctx, key); err != nil {
+	if err = indexes.DropIndex(ctx, indexName); err != nil {
 		return nil, err
-	} else if has {
-		indexesMap, err = indexesMap.Edit().Remove(key).Map(ctx)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		return t, nil
 	}
 
-	return t.SetIndexData(ctx, indexesMap)
+	return t.SetIndexData(ctx, indexes)
 }
 
 // RenameIndexRowData changes the name for the index data. Does not verify that the new name is unoccupied. If the old
 // name does not exist, then this returns the called table without error.
 func (t *Table) RenameIndexRowData(ctx context.Context, oldIndexName, newIndexName string) (*Table, error) {
-	indexesMap, err := t.GetIndexData(ctx)
+	indexes, err := t.GetIndexData(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	oldKey := types.String(oldIndexName)
-	newKey := types.String(newIndexName)
-	if indexRowData, ok, err := indexesMap.MaybeGet(ctx, oldKey); err != nil {
+	im, err := indexes.GetIndex(ctx, oldIndexName)
+	if err != nil {
 		return nil, err
-	} else if ok {
-		indexesMap, err = indexesMap.Edit().Set(newKey, indexRowData).Remove(oldKey).Map(ctx)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		return t, nil
 	}
 
-	return t.SetIndexData(ctx, indexesMap)
+	if err = indexes.DropIndex(ctx, oldIndexName); err != nil {
+		return nil, err
+	}
+
+	if err = indexes.PutIndex(ctx, newIndexName, im); err != nil {
+		return nil, err
+	}
+
+	return t.SetIndexData(ctx, indexes)
 }
 
 // VerifyIndexRowData verifies that the index with the given name's data matches what the index expects.
@@ -392,30 +366,22 @@ func (t *Table) VerifyIndexRowData(ctx context.Context, indexName string) error
 		return fmt.Errorf("index `%s` does not exist", indexName)
 	}
 
-	indexesMap, err := t.GetIndexData(ctx)
+	indexes, err := t.GetIndexData(ctx)
 	if err != nil {
 		return err
 	}
 
-	indexMapRef, ok, err := indexesMap.MaybeGet(ctx, types.String(indexName))
-	if err != nil {
-		return err
-	}
-	if !ok {
-		return fmt.Errorf("index `%s` is missing its data", indexName)
-	}
-
-	indexMapValue, err := indexMapRef.(types.Ref).TargetValue(ctx, t.ValueReadWriter())
+	im, err := indexes.GetIndex(ctx, indexName)
 	if err != nil {
 		return err
 	}
 
-	iter, err := indexMapValue.(types.Map).Iterator(ctx)
+	iter, err := im.Iterator(ctx)
 	if err != nil {
 		return err
 	}
 
-	return index.VerifyMap(ctx, iter, indexMapValue.(types.Map).Format())
+	return index.VerifyMap(ctx, iter, im.Format())
 }
 
 // GetAutoIncrementValue returns the current AUTO_INCREMENT value for this table.

go/libraries/doltcore/doltdocs/docs_table.go

@@ -119,7 +119,7 @@ func createDocsTable(ctx context.Context, vrw types.ValueReadWriter, docs Docs)
 		return nil, err
 	}
 
-	newDocsTbl, err := doltdb.NewTable(ctx, vrw, DocsSchema, rowMap, empty, nil)
+	newDocsTbl, err := doltdb.NewTable(ctx, vrw, DocsSchema, rowMap, nil, nil)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/doltdocs/docs_test.go

@@ -134,8 +134,7 @@ func TestAddNewerTextAndDocPkFromRow(t *testing.T) {
 }
 
 func CreateTestTable(vrw types.ValueReadWriter, tSchema schema.Schema, rowData types.Map) (*doltdb.Table, error) {
-	empty, _ := types.NewMap(context.Background(), vrw)
-	tbl, err := doltdb.NewTable(context.Background(), vrw, tSchema, rowData, empty, nil)
+	tbl, err := doltdb.NewTable(context.Background(), vrw, tSchema, rowData, nil, nil)
 
 	if err != nil {
 		return nil, err

go/libraries/doltcore/dtestutils/environment.go

@@ -78,10 +78,7 @@ func CreateEnvWithSeedData(t *testing.T) *env.DoltEnv {
 	ai := sch.Indexes().AllIndexes()
 	sch.Indexes().Merge(ai...)
 
-	empty, err := types.NewMap(ctx, vrw)
-	require.NoError(t, err)
-
-	tbl, err := doltdb.NewTable(ctx, vrw, sch, rowMap, empty, nil)
+	tbl, err := doltdb.NewTable(ctx, vrw, sch, rowMap, nil, nil)
 	require.NoError(t, err)
 	tbl, err = editor.RebuildAllIndexes(ctx, tbl, editor.TestEditorOptions(vrw))
 	require.NoError(t, err)

go/libraries/doltcore/dtestutils/schema.go

@@ -23,6 +23,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb/durable"
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
 	"github.com/dolthub/dolt/go/libraries/doltcore/row"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
@@ -111,9 +112,7 @@ func CreateTestTable(t *testing.T, dEnv *env.DoltEnv, tableName string, sch sche
 	rowMap, err = me.Map(ctx)
 	require.NoError(t, err)
 
-	empty, err := types.NewMap(ctx, vrw)
-	require.NoError(t, err)
-	tbl, err := doltdb.NewTable(ctx, vrw, sch, rowMap, empty, nil)
+	tbl, err := doltdb.NewTable(ctx, vrw, sch, rowMap, nil, nil)
 	require.NoError(t, err)
 	tbl, err = editor.RebuildAllIndexes(ctx, tbl, editor.TestEditorOptions(vrw))
 	require.NoError(t, err)
@@ -128,7 +127,7 @@ func CreateTestTable(t *testing.T, dEnv *env.DoltEnv, tableName string, sch sche
 	require.NoError(t, err)
 }
 
-func putTableToWorking(ctx context.Context, dEnv *env.DoltEnv, sch schema.Schema, rows types.Map, indexData types.Map, tableName string, autoVal types.Value) error {
+func putTableToWorking(ctx context.Context, dEnv *env.DoltEnv, sch schema.Schema, rows types.Map, indexData durable.IndexSet, tableName string, autoVal types.Value) error {
 	root, err := dEnv.WorkingRoot(ctx)
 	if err != nil {
 		return doltdb.ErrNomsIO

go/libraries/doltcore/dtestutils/testcommands/multienv.go

@@ -20,6 +20,8 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb/durable"
+
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
 	"github.com/dolthub/dolt/go/libraries/doltcore/dtestutils"
@@ -330,11 +332,8 @@ func createTestTable(dEnv *env.DoltEnv, tableName string, sch schema.Schema, err
 	if err != nil {
 		errhand(err)
 	}
-	empty, err := types.NewMap(ctx, vrw)
-	if err != nil {
-		errhand(err)
-	}
-	tbl, err := doltdb.NewTable(ctx, vrw, sch, rowMap, empty, nil)
+
+	tbl, err := doltdb.NewTable(ctx, vrw, sch, rowMap, nil, nil)
 	if err != nil {
 		errhand(err)
 	}
@@ -361,7 +360,7 @@ func createTestTable(dEnv *env.DoltEnv, tableName string, sch schema.Schema, err
 	}
 }
 
-func putTableToWorking(ctx context.Context, dEnv *env.DoltEnv, sch schema.Schema, rows types.Map, indexData types.Map, tableName string, autoVal types.Value) error {
+func putTableToWorking(ctx context.Context, dEnv *env.DoltEnv, sch schema.Schema, rows types.Map, indexData durable.IndexSet, tableName string, autoVal types.Value) error {
 	root, err := dEnv.WorkingRoot(ctx)
 	if err != nil {
 		return doltdb.ErrNomsIO

go/libraries/doltcore/merge/merge_test.go

@@ -347,20 +347,17 @@ func setupMergeTest(t *testing.T) (types.ValueReadWriter, *doltdb.Commit, *doltd
 	)
 	require.NoError(t, err)
 
-	emptyMap, err := types.NewMap(context.Background(), vrw)
-	require.NoError(t, err)
-
-	tbl, err := doltdb.NewTable(context.Background(), vrw, sch, initialRows, emptyMap, nil)
+	tbl, err := doltdb.NewTable(context.Background(), vrw, sch, initialRows, nil, nil)
 	require.NoError(t, err)
 	tbl, err = editor.RebuildAllIndexes(context.Background(), tbl, editor.TestEditorOptions(vrw))
 	require.NoError(t, err)
 
-	updatedTbl, err := doltdb.NewTable(context.Background(), vrw, sch, updatedRows, emptyMap, nil)
+	updatedTbl, err := doltdb.NewTable(context.Background(), vrw, sch, updatedRows, nil, nil)
 	require.NoError(t, err)
 	updatedTbl, err = editor.RebuildAllIndexes(context.Background(), updatedTbl, editor.TestEditorOptions(vrw))
 	require.NoError(t, err)
 
-	mergeTbl, err := doltdb.NewTable(context.Background(), vrw, sch, mergeRows, emptyMap, nil)
+	mergeTbl, err := doltdb.NewTable(context.Background(), vrw, sch, mergeRows, nil, nil)
 	require.NoError(t, err)
 	mergeTbl, err = editor.RebuildAllIndexes(context.Background(), mergeTbl, editor.TestEditorOptions(vrw))
 	require.NoError(t, err)
@@ -434,9 +431,7 @@ func TestMergeCommits(t *testing.T) {
 	assert.NoError(t, err)
 	sch, err := tbl.GetSchema(context.Background())
 	assert.NoError(t, err)
-	emptyMap, err := types.NewMap(context.Background(), vrw)
-	assert.NoError(t, err)
-	expected, err := doltdb.NewTable(context.Background(), vrw, sch, expectedRows, emptyMap, nil)
+	expected, err := doltdb.NewTable(context.Background(), vrw, sch, expectedRows, nil, nil)
 	assert.NoError(t, err)
 	expected, err = editor.RebuildAllIndexes(context.Background(), expected, editor.TestEditorOptions(vrw))
 	assert.NoError(t, err)

go/libraries/doltcore/schema/alterschema/addpk.go

@@ -114,7 +114,7 @@ func insertKeyedData(ctx context.Context, nbf *types.NomsBinFormat, oldTable *do
 	}
 
 	// Create the new Table and rebuild all the indexes
-	newTable, err := doltdb.NewTable(ctx, oldTable.ValueReadWriter(), newSchema, empty, empty, nil)
+	newTable, err := doltdb.NewTable(ctx, oldTable.ValueReadWriter(), newSchema, empty, nil, nil)
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/tables.go

@@ -510,7 +510,7 @@ func (t *WritableDoltTable) Truncate(ctx *sql.Context) (int, error) {
 		return 0, err
 	}
 	// truncate table resets auto-increment value
-	newTable, err := doltdb.NewTable(ctx, table.ValueReadWriter(), t.sch, empty, empty, nil)
+	newTable, err := doltdb.NewTable(ctx, table.ValueReadWriter(), t.sch, empty, nil, nil)
 	if err != nil {
 		return 0, err
 	}

go/libraries/doltcore/sqle/testdata.go

@@ -25,6 +25,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb/durable"
 	"github.com/dolthub/dolt/go/libraries/doltcore/dtestutils"
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
 	"github.com/dolthub/dolt/go/libraries/doltcore/ref"
@@ -533,12 +534,13 @@ func UpdateTables(t *testing.T, ctx context.Context, root *doltdb.RootValue, tbl
 			require.NoError(t, err)
 		}
 
-		indexData, err := types.NewMap(ctx, root.VRW())
+		var indexData durable.IndexSet
 		require.NoError(t, err)
 		if tbl != nil {
 			indexData, err = tbl.GetIndexData(ctx)
 			require.NoError(t, err)
 		}
+
 		tbl, err = doltdb.NewTable(ctx, root.VRW(), sch, rowData, indexData, nil)
 		require.NoError(t, err)
 

go/libraries/doltcore/table/editor/index_editor.go

@@ -309,7 +309,7 @@ func RebuildAllIndexes(ctx context.Context, t *doltdb.Table, opts Options) (*dol
 		return nil, err
 	}
 
-	indexesMap, err := t.GetIndexData(ctx)
+	indexes, err := t.GetIndexData(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -319,17 +319,12 @@ func RebuildAllIndexes(ctx context.Context, t *doltdb.Table, opts Options) (*dol
 		if err != nil {
 			return nil, err
 		}
-		rebuiltIndexRowDataRef, err := doltdb.WriteValAndGetRef(ctx, t.ValueReadWriter(), rebuiltIndexRowData)
-		if err != nil {
-			return nil, err
-		}
-		indexesMap, err = indexesMap.Edit().Set(types.String(index.Name()), rebuiltIndexRowDataRef).Map(ctx)
-		if err != nil {
+		if err = indexes.PutIndex(ctx, index.Name(), rebuiltIndexRowData); err != nil {
 			return nil, err
 		}
 	}
 
-	return t.SetIndexData(ctx, indexesMap)
+	return t.SetIndexData(ctx, indexes)
 }
 
 func rebuildIndexRowData(ctx context.Context, vrw types.ValueReadWriter, sch schema.Schema, tblRowData types.Map, index schema.Index, opts Options) (types.Map, error) {

go/libraries/doltcore/table/editor/index_editor_test.go

@@ -838,8 +838,7 @@ func createTestSchema(t *testing.T) schema.Schema {
 }
 
 func createTableWithoutIndexRebuilding(ctx context.Context, vrw types.ValueReadWriter, sch schema.Schema, rowData types.Map) (*doltdb.Table, error) {
-	empty, _ := types.NewMap(ctx, vrw)
-	return doltdb.NewTable(ctx, vrw, sch, rowData, empty, nil)
+	return doltdb.NewTable(ctx, vrw, sch, rowData, nil, nil)
 }
 
 func rowsToIndexRows(t *testing.T, rows []row.Row, indexName schema.Index, indexAge schema.Index) (indexNameExpectedRows []row.Row, indexAgeExpectedRows []row.Row) {

go/libraries/doltcore/table/editor/keyless_table_editor_test.go

@@ -42,7 +42,7 @@ func TestKeylessTableEditorConcurrency(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(context.Background(), db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 
 	opts := TestEditorOptions(db)
@@ -150,7 +150,7 @@ func TestKeylessTableEditorConcurrencyPostInsert(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(context.Background(), db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 
 	opts := TestEditorOptions(db)
@@ -257,7 +257,7 @@ func TestKeylessTableEditorWriteAfterFlush(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(context.Background(), db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 
 	opts := TestEditorOptions(db)
@@ -338,7 +338,7 @@ func TestKeylessTableEditorDuplicateKeyHandling(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(context.Background(), db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 
 	opts := TestEditorOptions(db)
@@ -437,7 +437,7 @@ func TestKeylessTableEditorMultipleIndexErrorHandling(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(ctx, db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(ctx, db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(ctx, db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 	table, err = RebuildAllIndexes(ctx, table, opts)
 	require.NoError(t, err)
@@ -590,7 +590,7 @@ func TestKeylessTableEditorIndexCardinality(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(ctx, db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(ctx, db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(ctx, db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 	table, err = RebuildAllIndexes(ctx, table, opts)
 	require.NoError(t, err)

go/libraries/doltcore/table/editor/pk_table_editor_test.go

@@ -53,7 +53,7 @@ func TestTableEditorConcurrency(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(context.Background(), db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 
 	for i := 0; i < tableEditorConcurrencyIterations; i++ {
@@ -148,7 +148,7 @@ func TestTableEditorConcurrencyPostInsert(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(context.Background(), db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 
 	tableEditor, err := newPkTableEditor(context.Background(), table, tableSch, tableName, opts)
@@ -241,7 +241,7 @@ func TestTableEditorWriteAfterFlush(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(context.Background(), db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 
 	tableEditor, err := newPkTableEditor(context.Background(), table, tableSch, tableName, opts)
@@ -311,7 +311,7 @@ func TestTableEditorDuplicateKeyHandling(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(context.Background(), db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(context.Background(), db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 
 	tableEditor, err := newPkTableEditor(context.Background(), table, tableSch, tableName, opts)
@@ -398,7 +398,7 @@ func TestTableEditorMultipleIndexErrorHandling(t *testing.T) {
 	require.NoError(t, err)
 	emptyMap, err := types.NewMap(ctx, db)
 	require.NoError(t, err)
-	table, err := doltdb.NewTable(ctx, db, tableSch, emptyMap, emptyMap, nil)
+	table, err := doltdb.NewTable(ctx, db, tableSch, emptyMap, nil, nil)
 	require.NoError(t, err)
 	table, err = RebuildAllIndexes(ctx, table, opts)
 	require.NoError(t, err)

go/libraries/doltcore/table/keyless_reader_test.go

@@ -115,7 +115,6 @@ func TestKeylessTableReader(t *testing.T) {
 	dEnv := dtu.CreateTestEnv()
 	ctx := context.Background()
 	vrw := dEnv.DoltDB.ValueReadWriter()
-	empty := dtu.MustMap(t, vrw)
 
 	compareRows := func(t *testing.T, expected []sql.Row, rdr table.SqlTableReader) {
 		for _, exp := range expected {
@@ -131,7 +130,7 @@ func TestKeylessTableReader(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			rowMap := makeBag(vrw, sch, test.rows...)
-			tbl, err := doltdb.NewTable(ctx, vrw, sch, rowMap, empty, nil)
+			tbl, err := doltdb.NewTable(ctx, vrw, sch, rowMap, nil, nil)
 			require.NoError(t, err)
 			rdr, err := table.NewTableReader(ctx, tbl)
 			require.NoError(t, err)
@@ -139,7 +138,7 @@ func TestKeylessTableReader(t *testing.T) {
 		})
 		t.Run(test.name+"_buffered", func(t *testing.T) {
 			rowMap := makeBag(vrw, sch, test.rows...)
-			tbl, err := doltdb.NewTable(ctx, vrw, sch, rowMap, empty, nil)
+			tbl, err := doltdb.NewTable(ctx, vrw, sch, rowMap, nil, nil)
 			require.NoError(t, err)
 			rdr, err := table.NewBufferedTableReader(ctx, tbl)
 			require.NoError(t, err)

go/libraries/doltcore/table/untyped/sqlexport/sqlwriter_test.go

@@ -24,6 +24,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb/durable"
 	"github.com/dolthub/dolt/go/libraries/doltcore/dtestutils"
 	"github.com/dolthub/dolt/go/libraries/doltcore/row"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
@@ -81,11 +82,12 @@ func TestEndToEnd(t *testing.T) {
 
 			empty, err := types.NewMap(ctx, root.VRW())
 			require.NoError(t, err)
-			idxRef, err := types.NewRef(empty, root.VRW().Format())
+
+			indexes := durable.NewIndexSet(ctx, root.VRW())
+			err = indexes.PutIndex(ctx, dtestutils.IndexName, empty)
 			require.NoError(t, err)
-			idxMap, err := types.NewMap(ctx, root.VRW(), types.String(dtestutils.IndexName), idxRef)
-			require.NoError(t, err)
-			tbl, err := doltdb.NewTable(ctx, root.VRW(), tt.sch, empty, idxMap, nil)
+
+			tbl, err := doltdb.NewTable(ctx, root.VRW(), tt.sch, empty, indexes, nil)
 			require.NoError(t, err)
 			root, err = root.PutTable(ctx, tableName, tbl)
 			require.NoError(t, err)