Reverted back to non-pointer receivers for Database, added repoStateWriter for all database constructors.

Signed-off-by: Zach Musgrave <zach@liquidata.co>

go/cmd/dolt/commands/sql.go

@@ -346,12 +346,12 @@ func execBatch(sqlCtx *sql.Context, mrEnv env.MultiRepoEnv, roots map[string]*do
 	return newRoots, nil
 }
 
-func newDatabase(name string, defRoot *doltdb.RootValue, dEnv *env.DoltEnv) *dsqle.Database {
-	return dsqle.NewDatabase(name, defRoot, dEnv.DoltDB, dEnv.RepoState)
+func newDatabase(name string, defRoot *doltdb.RootValue, dEnv *env.DoltEnv) dsqle.Database {
+	return dsqle.NewDatabase(name, defRoot, dEnv.DoltDB, dEnv.RepoState, dEnv.RepoStateWriter())
 }
 
-func newBatchedDatabase(name string, defRoot *doltdb.RootValue, dEnv *env.DoltEnv) *dsqle.Database {
-	return dsqle.NewBatchedDatabase(name, defRoot, dEnv.DoltDB, dEnv.RepoState)
+func newBatchedDatabase(name string, defRoot *doltdb.RootValue, dEnv *env.DoltEnv) dsqle.Database {
+	return dsqle.NewBatchedDatabase(name, defRoot, dEnv.DoltDB, dEnv.RepoState, dEnv.RepoStateWriter())
 }
 
 func execQuery(sqlCtx *sql.Context, mrEnv env.MultiRepoEnv, roots map[string]*doltdb.RootValue, query string, format resultFormat) (map[string]*doltdb.RootValue, errhand.VerboseError) {
@@ -383,12 +383,12 @@ func execQuery(sqlCtx *sql.Context, mrEnv env.MultiRepoEnv, roots map[string]*do
 	return newRoots, nil
 }
 
-type createDBFunc func(name string, defRoot *doltdb.RootValue, dEnv *env.DoltEnv) *dsqle.Database
+type createDBFunc func(name string, defRoot *doltdb.RootValue, dEnv *env.DoltEnv) dsqle.Database
 
 // CollectDBs takes a MultiRepoEnv and creates Database objects from each environment and returns a slice of these
 // objects.
-func CollectDBs(mrEnv env.MultiRepoEnv, roots map[string]*doltdb.RootValue, createDB createDBFunc) []*dsqle.Database {
-	dbs := make([]*dsqle.Database, 0, len(mrEnv))
+func CollectDBs(mrEnv env.MultiRepoEnv, roots map[string]*doltdb.RootValue, createDB createDBFunc) []dsqle.Database {
+	dbs := make([]dsqle.Database, 0, len(mrEnv))
 	_ = mrEnv.Iter(func(name string, dEnv *env.DoltEnv) (stop bool, err error) {
 		root := roots[name]
 		db := createDB(name, root, dEnv)
@@ -906,7 +906,7 @@ func (s *stats) shouldFlush() bool {
 }
 
 func flushBatchedEdits(ctx *sql.Context, se *sqlEngine) error {
-	err := se.iterDBs(func(_ string, db *dsqle.Database) (bool, error) {
+	err := se.iterDBs(func(_ string, db dsqle.Database) (bool, error) {
 		err := db.Flush(ctx)
 
 		if err != nil {
@@ -1071,7 +1071,7 @@ const (
 )
 
 type sqlEngine struct {
-	dbs          map[string]*dsqle.Database
+	dbs          map[string]dsqle.Database
 	mrEnv        env.MultiRepoEnv
 	engine       *sqle.Engine
 	resultFormat resultFormat
@@ -1080,11 +1080,11 @@ type sqlEngine struct {
 var ErrDBNotFoundKind = errors.NewKind("database '%s' not found")
 
 // sqlEngine packages up the context necessary to run sql queries against sqle.
-func newSqlEngine(sqlCtx *sql.Context, mrEnv env.MultiRepoEnv, roots map[string]*doltdb.RootValue, format resultFormat, dbs ...*dsqle.Database) (*sqlEngine, error) {
+func newSqlEngine(sqlCtx *sql.Context, mrEnv env.MultiRepoEnv, roots map[string]*doltdb.RootValue, format resultFormat, dbs ...dsqle.Database) (*sqlEngine, error) {
 	engine := sqle.NewDefault()
 	engine.AddDatabase(sql.NewInformationSchemaDatabase(engine.Catalog))
 
-	nameToDB := make(map[string]*dsqle.Database)
+	nameToDB := make(map[string]dsqle.Database)
 	for _, db := range dbs {
 		nameToDB[db.Name()] = db
 		root := roots[db.Name()]
@@ -1110,17 +1110,17 @@ func newSqlEngine(sqlCtx *sql.Context, mrEnv env.MultiRepoEnv, roots map[string]
 	return &sqlEngine{nameToDB, mrEnv, engine, format}, nil
 }
 
-func (se *sqlEngine) getDB(name string) (*dsqle.Database, error) {
+func (se *sqlEngine) getDB(name string) (dsqle.Database, error) {
 	db, ok := se.dbs[name]
 
 	if !ok {
-		return nil, ErrDBNotFoundKind.New(name)
+		return dsqle.Database{}, ErrDBNotFoundKind.New(name)
 	}
 
 	return db, nil
 }
 
-func (se *sqlEngine) iterDBs(cb func(name string, db *dsqle.Database) (stop bool, err error)) error {
+func (se *sqlEngine) iterDBs(cb func(name string, db dsqle.Database) (stop bool, err error)) error {
 	for name, db := range se.dbs {
 		stop, err := cb(name, db)
 

go/cmd/dolt/commands/sqlserver/server.go

@@ -186,15 +186,15 @@ func newSessionBuilder(sqlEngine *sqle.Engine) server.SessionBuilder {
 	}
 }
 
-func newAutoCommmitDatabase(name string, defRoot *doltdb.RootValue, dEnv *env.DoltEnv) *dsqle.Database {
-	return dsqle.NewAutoCommitDatabase(name, defRoot, dEnv.DoltDB, dEnv.RepoState, dEnv.RepoStateWriter())
+func newAutoCommmitDatabase(name string, defRoot *doltdb.RootValue, dEnv *env.DoltEnv) dsqle.Database {
+	return dsqle.NewDatabase(name, defRoot, dEnv.DoltDB, dEnv.RepoState, dEnv.RepoStateWriter())
 }
 
-func dbsAsDSQLDBs(dbs []sql.Database) []*dsqle.Database {
-	dsqlDBs := make([]*dsqle.Database, 0, len(dbs))
+func dbsAsDSQLDBs(dbs []sql.Database) []dsqle.Database {
+	dsqlDBs := make([]dsqle.Database, 0, len(dbs))
 
 	for _, db := range dbs {
-		dsqlDB, ok := db.(*dsqle.Database)
+		dsqlDB, ok := db.(dsqle.Database)
 
 		if ok {
 			dsqlDBs = append(dsqlDBs, dsqlDB)

go/cmd/dolt/commands/sqlserver/server_test.go

@@ -46,7 +46,7 @@ var (
 func TestServerArgs(t *testing.T) {
 	serverController := CreateServerController()
 	go func() {
-		SqlServerImpl(context.Background(), "dolt sql-server", []string{
+		startServer(context.Background(), "test", "dolt sql-server", []string{
 			"-H", "localhost",
 			"-P", "15200",
 			"-u", "username",
@@ -84,7 +84,7 @@ func TestServerBadArgs(t *testing.T) {
 		t.Run(strings.Join(test, " "), func(t *testing.T) {
 			serverController := CreateServerController()
 			go func(serverController *ServerController) {
-				SqlServerImpl(context.Background(), "dolt sql-server", test, env, serverController)
+				startServer(context.Background(), "test", "dolt sql-server", test, env, serverController)
 			}(serverController)
 			// In the event that a test fails, we need to prevent a test from hanging due to a running server
 			err := serverController.WaitForStart()

go/cmd/dolt/commands/sqlserver/sqlserver.go

@@ -97,12 +97,12 @@ func (cmd SqlServerCmd) RequiresRepo() bool {
 
 // Exec executes the command
 func (cmd SqlServerCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv) int {
-	return cmd.startServer(ctx, commandStr, args, dEnv, nil)
+	return startServer(ctx, commandStr, cmd.VersionStr, args, dEnv, nil)
 }
 
-func (cmd SqlServerCmd) startServer(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, serverController *ServerController) int {
+func startServer(ctx context.Context, versionStr, commandStr string, args []string, dEnv *env.DoltEnv, serverController *ServerController) int {
 	serverConfig := DefaultServerConfig()
-	serverConfig.Version = cmd.VersionStr
+	serverConfig.Version = versionStr
 
 	ap := createArgParser(serverConfig)
 	help, _ := cli.HelpAndUsagePrinters(cli.GetCommandDocumentation(commandStr, sqlServerDocs, ap))

go/libraries/doltcore/sqle/common_test.go

@@ -34,7 +34,7 @@ import (
 // the targetSchema given is used to prepare all rows.
 func executeSelect(ctx context.Context, dEnv *env.DoltEnv, targetSch schema.Schema, root *doltdb.RootValue, query string) ([]row.Row, schema.Schema, error) {
 	var err error
-	db := NewDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState)
+	db := NewDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState, dEnv.RepoStateWriter())
 	engine, sqlCtx, err := NewTestEngine(ctx, db, root)
 	if err != nil {
 		return nil, nil, err
@@ -70,7 +70,7 @@ func executeSelect(ctx context.Context, dEnv *env.DoltEnv, targetSch schema.Sche
 
 // Runs the query given and returns the error (if any).
 func executeModify(ctx context.Context, ddb *doltdb.DoltDB, root *doltdb.RootValue, query string) (*doltdb.RootValue, error) {
-	db := NewDatabase("dolt", root, ddb, nil)
+	db := NewDatabase("dolt", root, ddb, nil, nil)
 	engine, sqlCtx, err := NewTestEngine(ctx, db, root)
 
 	if err != nil {

go/libraries/doltcore/sqle/database.go

@@ -46,7 +46,6 @@ var ErrSystemTableAlter = errors.NewKind("Cannot alter table %s: system tables c
 const (
 	batched commitBehavior = iota
 	single
-	autoCommit
 )
 
 type tableCache struct {
@@ -112,19 +111,20 @@ type Database struct {
 	tc        *tableCache
 }
 
-var _ sql.Database = (*Database)(nil)
-var _ sql.VersionedDatabase = (*Database)(nil)
-var _ sql.TableDropper = (*Database)(nil)
-var _ sql.TableCreator = (*Database)(nil)
-var _ sql.TableRenamer = (*Database)(nil)
+var _ sql.Database = Database{}
+var _ sql.VersionedDatabase = Database{}
+var _ sql.TableDropper = Database{}
+var _ sql.TableCreator = Database{}
+var _ sql.TableRenamer = Database{}
 
 // NewDatabase returns a new dolt database to use in queries.
-func NewDatabase(name string, defRoot *doltdb.RootValue, ddb *doltdb.DoltDB, rsr env.RepoStateReader) *Database {
-	return &Database{
+func NewDatabase(name string, defRoot *doltdb.RootValue, ddb *doltdb.DoltDB, rsr env.RepoStateReader, rsw env.RepoStateWriter) Database {
+	return Database{
 		name:      name,
 		defRoot:   defRoot,
 		ddb:       ddb,
 		rsr:       rsr,
+		rsw:       rsw,
 		batchMode: single,
 		tc:        &tableCache{&sync.Mutex{}, make(map[*doltdb.RootValue]map[string]sql.Table)},
 	}
@@ -132,50 +132,36 @@ func NewDatabase(name string, defRoot *doltdb.RootValue, ddb *doltdb.DoltDB, rsr
 
 // NewBatchedDatabase returns a new dolt database executing in batch insert mode. Integrators must call Flush() to
 // commit any outstanding edits.
-func NewBatchedDatabase(name string, root *doltdb.RootValue, ddb *doltdb.DoltDB, rsr env.RepoStateReader) *Database {
-	return &Database{
-		name:      name,
-		defRoot:   root,
-		ddb:       ddb,
-		rsr:       rsr,
-		batchMode: batched,
-		tc:        &tableCache{&sync.Mutex{}, make(map[*doltdb.RootValue]map[string]sql.Table)},
-	}
-}
-
-// NewAutoCommitDatabase returns a new dolt database executing in autocommit mode. Every write operation will update
-// the working set with the new root value.
-func NewAutoCommitDatabase(name string, root *doltdb.RootValue, ddb *doltdb.DoltDB, rsr env.RepoStateReader, rsw env.RepoStateWriter) *Database {
-	return &Database{
+func NewBatchedDatabase(name string, root *doltdb.RootValue, ddb *doltdb.DoltDB, rsr env.RepoStateReader, rsw env.RepoStateWriter) Database {
+	return Database{
 		name:      name,
 		defRoot:   root,
 		ddb:       ddb,
 		rsr:       rsr,
 		rsw:       rsw,
-		batchMode: autoCommit,
+		batchMode: batched,
 		tc:        &tableCache{&sync.Mutex{}, make(map[*doltdb.RootValue]map[string]sql.Table)},
 	}
 }
 
-
 // Name returns the name of this database, set at creation time.
-func (db *Database) Name() string {
+func (db Database) Name() string {
 	return db.name
 }
 
 // GetDefaultRoot returns the default root of the database that is used by new sessions.
-func (db *Database) GetDefaultRoot() *doltdb.RootValue {
+func (db Database) GetDefaultRoot() *doltdb.RootValue {
 	return db.defRoot
 }
 
 // GetDoltDB gets the underlying DoltDB of the Database
-func (db *Database) GetDoltDB() *doltdb.DoltDB {
+func (db Database) GetDoltDB() *doltdb.DoltDB {
 	return db.ddb
 }
 
 // GetTableInsensitive is used when resolving tables in queries. It returns a best-effort case-insensitive match for
 // the table name given.
-func (db *Database) GetTableInsensitive(ctx *sql.Context, tblName string) (sql.Table, bool, error) {
+func (db Database) GetTableInsensitive(ctx *sql.Context, tblName string) (sql.Table, bool, error) {
 	root, err := db.GetRoot(ctx)
 
 	if err != nil {
@@ -185,7 +171,7 @@ func (db *Database) GetTableInsensitive(ctx *sql.Context, tblName string) (sql.T
 	return db.GetTableInsensitiveWithRoot(ctx, root, tblName)
 }
 
-func (db *Database) GetTableInsensitiveWithRoot(ctx context.Context, root *doltdb.RootValue, tblName string) (sql.Table, bool, error) {
+func (db Database) GetTableInsensitiveWithRoot(ctx context.Context, root *doltdb.RootValue, tblName string) (sql.Table, bool, error) {
 	lwrName := strings.ToLower(tblName)
 	if strings.HasPrefix(lwrName, DoltDiffTablePrefix) {
 		tblName = tblName[len(DoltDiffTablePrefix):]
@@ -217,7 +203,7 @@ func (db *Database) GetTableInsensitiveWithRoot(ctx context.Context, root *doltd
 }
 
 // GetTableInsensitiveAsOf implements sql.VersionedDatabase
-func (db *Database) GetTableInsensitiveAsOf(ctx *sql.Context, tableName string, asOf interface{}) (sql.Table, bool, error) {
+func (db Database) GetTableInsensitiveAsOf(ctx *sql.Context, tableName string, asOf interface{}) (sql.Table, bool, error) {
 	root, err := db.rootAsOf(ctx, asOf)
 	if err != nil {
 		return nil, false, err
@@ -230,7 +216,7 @@ func (db *Database) GetTableInsensitiveAsOf(ctx *sql.Context, tableName string,
 
 // rootAsOf returns the root of the DB as of the expression given, which may be nil in the case that it refers to an
 // expression before the first commit.
-func (db *Database) rootAsOf(ctx *sql.Context, asOf interface{}) (*doltdb.RootValue, error) {
+func (db Database) rootAsOf(ctx *sql.Context, asOf interface{}) (*doltdb.RootValue, error) {
 	switch x := asOf.(type) {
 	case string:
 		return db.getRootForCommitRef(ctx, x)
@@ -241,7 +227,7 @@ func (db *Database) rootAsOf(ctx *sql.Context, asOf interface{}) (*doltdb.RootVa
 	}
 }
 
-func (db *Database) getRootForTime(ctx *sql.Context, asOf time.Time) (*doltdb.RootValue, error) {
+func (db Database) getRootForTime(ctx *sql.Context, asOf time.Time) (*doltdb.RootValue, error) {
 	cs, err := doltdb.NewCommitSpec("HEAD", db.rsr.CWBHeadRef().String())
 	if err != nil {
 		return nil, err
@@ -283,7 +269,7 @@ func (db *Database) getRootForTime(ctx *sql.Context, asOf time.Time) (*doltdb.Ro
 	return nil, nil
 }
 
-func (db *Database) getRootForCommitRef(ctx *sql.Context, commitRef string) (*doltdb.RootValue, error) {
+func (db Database) getRootForCommitRef(ctx *sql.Context, commitRef string) (*doltdb.RootValue, error) {
 	cs, err := doltdb.NewCommitSpec(commitRef, db.rsr.CWBHeadRef().String())
 	if err != nil {
 		return nil, err
@@ -303,7 +289,7 @@ func (db *Database) getRootForCommitRef(ctx *sql.Context, commitRef string) (*do
 }
 
 // GetTableNamesAsOf implements sql.VersionedDatabase
-func (db *Database) GetTableNamesAsOf(ctx *sql.Context, time interface{}) ([]string, error) {
+func (db Database) GetTableNamesAsOf(ctx *sql.Context, time interface{}) ([]string, error) {
 	root, err := db.rootAsOf(ctx, time)
 	if err != nil {
 		return nil, err
@@ -320,7 +306,7 @@ func (db *Database) GetTableNamesAsOf(ctx *sql.Context, time interface{}) ([]str
 
 // getTable gets the table with the exact name given at the root value given. The database caches tables for all root
 // values to avoid doing schema lookups on every table lookup, which are expensive.
-func (db *Database) getTable(ctx context.Context, root *doltdb.RootValue, tableName string) (sql.Table, bool, error) {
+func (db Database) getTable(ctx context.Context, root *doltdb.RootValue, tableName string) (sql.Table, bool, error) {
 	if table, ok := db.tc.Get(tableName, root); ok {
 		return table, true, nil
 	}
@@ -368,7 +354,7 @@ func (db *Database) getTable(ctx context.Context, root *doltdb.RootValue, tableN
 // are filtered out. This method is used for queries that examine the schema of the database, e.g. show tables. Table
 // name resolution in queries is handled by GetTableInsensitive. Use GetAllTableNames for an unfiltered list of all
 // tables in user space.
-func (db *Database) GetTableNames(ctx *sql.Context) ([]string, error) {
+func (db Database) GetTableNames(ctx *sql.Context) ([]string, error) {
 	tblNames, err := db.GetAllTableNames(ctx)
 	if err != nil {
 		return nil, err
@@ -378,7 +364,7 @@ func (db *Database) GetTableNames(ctx *sql.Context) ([]string, error) {
 
 // GetAllTableNames returns all user-space tables, including system tables in user space
 // (e.g. dolt_docs, dolt_query_catalog).
-func (db *Database) GetAllTableNames(ctx *sql.Context) ([]string, error) {
+func (db Database) GetAllTableNames(ctx *sql.Context) ([]string, error) {
 	root, err := db.GetRoot(ctx)
 
 	if err != nil {
@@ -402,13 +388,13 @@ func filterDoltInternalTables(tblNames []string) []string {
 	return result
 }
 
-func (db *Database) headKeyForDB() string {
+func (db Database) headKeyForDB() string {
 	return fmt.Sprintf("%s_head", db.name)
 }
 
 var hashType = sql.MustCreateString(query.Type_TEXT, 32, sql.Collation_ascii_bin)
 
-func (db *Database) GetRoot(ctx *sql.Context) (*doltdb.RootValue, error) {
+func (db Database) GetRoot(ctx *sql.Context) (*doltdb.RootValue, error) {
 	dsess := DSessFromSess(ctx.Session)
 	currRoot, dbRootOk := dsess.dbRoots[db.name]
 
@@ -458,7 +444,7 @@ func (db *Database) GetRoot(ctx *sql.Context) (*doltdb.RootValue, error) {
 
 // Set a new root value for the database. Can be used if the dolt working
 // set value changes outside of the basic SQL execution engine.
-func (db *Database) SetRoot(ctx *sql.Context, newRoot *doltdb.RootValue) error {
+func (db Database) SetRoot(ctx *sql.Context, newRoot *doltdb.RootValue) error {
 	h, err := newRoot.HashOf()
 
 	if err != nil {
@@ -477,7 +463,7 @@ func (db *Database) SetRoot(ctx *sql.Context, newRoot *doltdb.RootValue) error {
 
 // LoadRootFromRepoState loads the root value from the repo state's working hash, then calls SetRoot with the loaded
 // root value.
-func (db *Database) LoadRootFromRepoState(ctx *sql.Context) error {
+func (db Database) LoadRootFromRepoState(ctx *sql.Context) error {
 	workingHash := db.rsr.WorkingHash()
 	root, err := db.ddb.ReadRootValue(ctx, workingHash)
 	if err != nil {
@@ -488,7 +474,7 @@ func (db *Database) LoadRootFromRepoState(ctx *sql.Context) error {
 }
 
 // DropTable drops the table with the name given
-func (db *Database) DropTable(ctx *sql.Context, tableName string) error {
+func (db Database) DropTable(ctx *sql.Context, tableName string) error {
 	root, err := db.GetRoot(ctx)
 
 	if err != nil {
@@ -517,7 +503,7 @@ func (db *Database) DropTable(ctx *sql.Context, tableName string) error {
 }
 
 // CreateTable creates a table with the name and schema given.
-func (db *Database) CreateTable(ctx *sql.Context, tableName string, sch sql.Schema) error {
+func (db Database) CreateTable(ctx *sql.Context, tableName string, sch sql.Schema) error {
 	if doltdb.HasDoltPrefix(tableName) {
 		return ErrReservedTableName.New(tableName)
 	}
@@ -541,7 +527,7 @@ func (db *Database) CreateTable(ctx *sql.Context, tableName string, sch sql.Sche
 }
 
 // Unlike the exported version, createTable doesn't enforce any table name checks.
-func (db *Database) createTable(ctx *sql.Context, tableName string, sch sql.Schema) error {
+func (db Database) createTable(ctx *sql.Context, tableName string, sch sql.Schema) error {
 	root, err := db.GetRoot(ctx)
 
 	if err != nil {
@@ -583,7 +569,7 @@ func (db *Database) createTable(ctx *sql.Context, tableName string, sch sql.Sche
 }
 
 // RenameTable implements sql.TableRenamer
-func (db *Database) RenameTable(ctx *sql.Context, oldName, newName string) error {
+func (db Database) RenameTable(ctx *sql.Context, oldName, newName string) error {
 	root, err := db.GetRoot(ctx)
 
 	if err != nil {
@@ -612,7 +598,7 @@ func (db *Database) RenameTable(ctx *sql.Context, oldName, newName string) error
 }
 
 // Flush flushes the current batch of outstanding changes and returns any errors.
-func (db *Database) Flush(ctx *sql.Context) error {
+func (db Database) Flush(ctx *sql.Context) error {
 	root, err := db.GetRoot(ctx)
 
 	if err != nil {
@@ -641,7 +627,7 @@ func (db *Database) Flush(ctx *sql.Context) error {
 // CreateView implements sql.ViewCreator. Persists the view in the dolt database, so
 // it can exist in a sql session later. Returns sql.ErrExistingView if a view
 // with that name already exists.
-func (db *Database) CreateView(ctx *sql.Context, name string, definition string) error {
+func (db Database) CreateView(ctx *sql.Context, name string, definition string) error {
 	tbl, err := GetOrCreateDoltSchemasTable(ctx, db)
 	if err != nil {
 		return err
@@ -668,7 +654,7 @@ func (db *Database) CreateView(ctx *sql.Context, name string, definition string)
 // DropView implements sql.ViewDropper. Removes a view from persistence in the
 // dolt database. Returns sql.ErrNonExistingView if the view did not
 // exist.
-func (db *Database) DropView(ctx *sql.Context, name string) error {
+func (db Database) DropView(ctx *sql.Context, name string) error {
 	stbl, found, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
 	if err != nil {
 		return err
@@ -702,7 +688,7 @@ func (db *Database) DropView(ctx *sql.Context, name string) error {
 // there are I/O issues, but currently silently fails to register some
 // schema fragments if they don't parse, or if registries within the
 // `catalog` return errors.
-func RegisterSchemaFragments(ctx *sql.Context, db *Database, root *doltdb.RootValue) error {
+func RegisterSchemaFragments(ctx *sql.Context, db Database, root *doltdb.RootValue) error {
 	stbl, found, err := db.GetTableInsensitiveWithRoot(ctx, root, doltdb.SchemasTableName)
 	if err != nil {
 		return err

go/libraries/doltcore/sqle/dolt_session.go

@@ -42,7 +42,7 @@ func DefaultDoltSession() *DoltSession {
 }
 
 // NewSessionWithDefaultRoot creates a DoltSession object from a standard sql.Session and 0 or more Database objects.
-func NewSessionWithDefaultRoots(sqlSess sql.Session, dbs ...*Database) (*DoltSession, error) {
+func NewSessionWithDefaultRoots(sqlSess sql.Session, dbs ...Database) (*DoltSession, error) {
 	dbRoots := make(map[string]dbRoot)
 	for _, db := range dbs {
 		defRoot := db.GetDefaultRoot()

go/libraries/doltcore/sqle/indexes.go

@@ -29,11 +29,11 @@ import (
 // IndexDriver implementation. Not ready for prime time.
 
 type DoltIndexDriver struct {
-	dbs map[string]*Database
+	dbs map[string]Database
 }
 
-func NewDoltIndexDriver(dbs ...*Database) *DoltIndexDriver {
-	nameToDB := make(map[string]*Database)
+func NewDoltIndexDriver(dbs ...Database) *DoltIndexDriver {
+	nameToDB := make(map[string]Database)
 	for _, db := range dbs {
 		nameToDB[db.Name()] = db
 	}
@@ -91,7 +91,7 @@ func (i *DoltIndexDriver) LoadAll(ctx *sql.Context, db, table string) ([]sql.Ind
 type doltIndex struct {
 	sch       schema.Schema
 	tableName string
-	db        *Database
+	db        Database
 	driver    *DoltIndexDriver
 }
 

go/libraries/doltcore/sqle/logictest/dolt/doltharness.go

@@ -335,7 +335,7 @@ func resetEnv(root *doltdb.RootValue) *doltdb.RootValue {
 }
 
 func sqlNewEngine(ddb *doltdb.DoltDB, root *doltdb.RootValue) (*sqle.Engine, error) {
-	db := dsql.NewDatabase("dolt", root, ddb, nil)
+	db := dsql.NewDatabase("dolt", root, ddb, nil, nil)
 	engine := sqle.NewDefault()
 	engine.AddDatabase(db)
 

go/libraries/doltcore/sqle/schema_table.go

@@ -35,7 +35,7 @@ func SchemasTableSchema() sql.Schema {
 }
 
 // GetOrCreateDoltSchemasTable returns the `dolt_schemas` table in `db`, creating it if it does not already exist.
-func GetOrCreateDoltSchemasTable(ctx *sql.Context, db *Database) (*WritableDoltTable, error) {
+func GetOrCreateDoltSchemasTable(ctx *sql.Context, db Database) (*WritableDoltTable, error) {
 	tbl, found, err := db.GetTableInsensitive(ctx, doltdb.SchemasTableName)
 	if err != nil {
 		return nil, err

go/libraries/doltcore/sqle/sqlbatch_test.go

@@ -63,7 +63,7 @@ func TestSqlBatchInserts(t *testing.T) {
 	CreateTestDatabase(dEnv, t)
 	root, _ := dEnv.WorkingRoot(ctx)
 
-	db := NewBatchedDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState)
+	db := NewBatchedDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState, dEnv.RepoStateWriter())
 	engine, sqlCtx, err := NewTestEngine(ctx, db, root)
 	require.NoError(t, err)
 
@@ -151,7 +151,7 @@ func TestSqlBatchInsertIgnoreReplace(t *testing.T) {
 	CreateTestDatabase(dEnv, t)
 	root, _ := dEnv.WorkingRoot(ctx)
 
-	db := NewBatchedDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState)
+	db := NewBatchedDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState, dEnv.RepoStateWriter())
 	engine, sqlCtx, err := NewTestEngine(ctx, db, root)
 	require.NoError(t, err)
 
@@ -189,7 +189,7 @@ func TestSqlBatchInsertErrors(t *testing.T) {
 	CreateTestDatabase(dEnv, t)
 	root, _ := dEnv.WorkingRoot(ctx)
 
-	db := NewBatchedDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState)
+	db := NewBatchedDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState, dEnv.RepoStateWriter())
 	engine, sqlCtx, err := NewTestEngine(ctx, db, root)
 	require.NoError(t, err)
 

go/libraries/doltcore/sqle/table_editor_test.go

@@ -157,7 +157,7 @@ func TestTableEditor(t *testing.T) {
 
 			ctx := NewTestSQLCtx(context.Background())
 			root, _ := dEnv.WorkingRoot(context.Background())
-			db := NewDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState)
+			db := NewDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState, dEnv.RepoStateWriter())
 			err := db.SetRoot(ctx, root)
 			require.NoError(t, err)
 			peopleTable, _, err := db.GetTableInsensitive(ctx, "people")

go/libraries/doltcore/sqle/tables.go

@@ -35,7 +35,7 @@ type DoltTable struct {
 	table  *doltdb.Table
 	sch    schema.Schema
 	sqlSch sql.Schema
-	db     *Database
+	db     Database
 }
 
 var _ sql.Table = (*DoltTable)(nil)

go/libraries/doltcore/sqle/testutil.go

@@ -32,7 +32,7 @@ import (
 // Executes all the SQL non-select statements given in the string against the root value given and returns the updated
 // root, or an error. Statements in the input string are split by `;\n`
 func ExecuteSql(dEnv *env.DoltEnv, root *doltdb.RootValue, statements string) (*doltdb.RootValue, error) {
-	db := NewBatchedDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState)
+	db := NewBatchedDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState, dEnv.RepoStateWriter())
 	engine, ctx, err := NewTestEngine(context.Background(), db, root)
 
 	if err != nil {
@@ -99,7 +99,7 @@ func NewTestSQLCtx(ctx context.Context) *sql.Context {
 }
 
 // NewTestEngine creates a new default engine, and a *sql.Context and initializes indexes and schema fragments.
-func NewTestEngine(ctx context.Context, db *Database, root *doltdb.RootValue) (*sqle.Engine, *sql.Context, error) {
+func NewTestEngine(ctx context.Context, db Database, root *doltdb.RootValue) (*sqle.Engine, *sql.Context, error) {
 	engine := sqle.NewDefault()
 	engine.AddDatabase(db)
 
@@ -130,7 +130,7 @@ func NewTestEngine(ctx context.Context, db *Database, root *doltdb.RootValue) (*
 // Executes the select statement given and returns the resulting rows, or an error if one is encountered.
 // This uses the index functionality, which is not ready for prime time. Use with caution.
 func ExecuteSelect(ddb *doltdb.DoltDB, root *doltdb.RootValue, query string) ([]sql.Row, error) {
-	db := NewDatabase("dolt", root, ddb, nil)
+	db := NewDatabase("dolt", root, ddb, nil, nil)
 	engine, ctx, err := NewTestEngine(context.Background(), db, root)
 	if err != nil {
 		return nil, err