Implement the docs read writer. (#1120)

This pr implements the DocsReadWriter interface. It allows both dolt cli and dolt sql commands to read and write the docs.

go/cmd/dolt/commands/add.go

@@ -89,7 +89,7 @@ func (cmd AddCmd) Exec(ctx context.Context, commandStr string, args []string, dE
 	if apr.NArg() == 0 && !allFlag {
 		cli.Println("Nothing specified, nothing added.\n Maybe you wanted to say 'dolt add .'?")
 	} else if allFlag || apr.NArg() == 1 && apr.Arg(0) == "." {
-		err = actions.StageAllTables(ctx, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+		err = actions.StageAllTables(ctx, dEnv.DbData())
 	} else {
 		err = actions.StageTables(ctx, dEnv, apr.Args())
 	}

go/cmd/dolt/commands/commit.go

@@ -78,7 +78,7 @@ func (cmd CommitCmd) Exec(ctx context.Context, commandStr string, args []string,
 
 	var err error
 	if allFlag {
-		err = actions.StageAllTables(ctx, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+		err = actions.StageAllTables(ctx, dEnv.DbData())
 	}
 
 	if err != nil {
@@ -112,7 +112,9 @@ func (cmd CommitCmd) Exec(ctx context.Context, commandStr string, args []string,
 		}
 	}
 
-	_, err = actions.CommitStaged(ctx, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter(), actions.CommitStagedProps{
+	dbData := dEnv.DbData()
+
+	_, err = actions.CommitStaged(ctx, dbData, actions.CommitStagedProps{
 		Message:          msg,
 		Date:             t,
 		AllowEmpty:       apr.Contains(cli.AllowEmptyFlag),
@@ -204,7 +206,7 @@ func buildInitalCommitMsg(ctx context.Context, dEnv *env.DoltEnv) string {
 		workingTblsInConflict = []string{}
 	}
 
-	stagedDocDiffs, notStagedDocDiffs, _ := diff.GetDocDiffs(ctx, dEnv.DoltDB, dEnv.RepoStateReader())
+	stagedDocDiffs, notStagedDocDiffs, _ := diff.GetDocDiffs(ctx, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.DocsReadWriter())
 
 	buf := bytes.NewBuffer([]byte{})
 	n := printStagedDiffs(buf, stagedTblDiffs, stagedDocDiffs, true)

go/cmd/dolt/commands/filter-branch.go

@@ -239,7 +239,7 @@ func monoSqlEngine(ctx context.Context, dEnv *env.DoltEnv, cm *doltdb.Commit) (*
 		sql.WithViewRegistry(sql.NewViewRegistry()))
 	_ = sqlCtx.Set(sqlCtx, sql.AutoCommitSessionVar, sql.Boolean, true)
 
-	db := dsqle.NewDatabase(dbName, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := dsqle.NewDatabase(dbName, dEnv.DbData())
 
 	cat := sql.NewCatalog()
 	err := cat.Register(dfunctions.DoltFunctions...)

go/cmd/dolt/commands/merge.go

@@ -262,7 +262,9 @@ func execNoFFMerge(ctx context.Context, apr *argparser.ArgParseResults, dEnv *en
 		return errhand.BuildDError("error: committing").AddCause(err).Build()
 	}
 
-	_, err = actions.CommitStaged(ctx, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter(), actions.CommitStagedProps{
+	dbData := dEnv.DbData()
+
+	_, err = actions.CommitStaged(ctx, dbData, actions.CommitStagedProps{
 		Message:          msg,
 		Date:             t,
 		AllowEmpty:       apr.Contains(cli.AllowEmptyFlag),

go/cmd/dolt/commands/sql.go

@@ -367,11 +367,11 @@ func execBatch(sqlCtx *sql.Context, readOnly bool, mrEnv env.MultiRepoEnv, roots
 type createDBFunc func(name string, dEnv *env.DoltEnv) dsqle.Database
 
 func newDatabase(name string, dEnv *env.DoltEnv) dsqle.Database {
-	return dsqle.NewDatabase(name, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	return dsqle.NewDatabase(name, dEnv.DbData())
 }
 
 func newBatchedDatabase(name string, dEnv *env.DoltEnv) dsqle.Database {
-	return dsqle.NewBatchedDatabase(name, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	return dsqle.NewBatchedDatabase(name, dEnv.DbData())
 }
 
 func execQuery(sqlCtx *sql.Context, readOnly bool, mrEnv env.MultiRepoEnv, roots map[string]*doltdb.RootValue, query string, format resultFormat) (newRoot map[string]*doltdb.RootValue, verr errhand.VerboseError) {

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

@@ -203,7 +203,7 @@ func newSessionBuilder(sqlEngine *sqle.Engine, username, email string, autocommi
 }
 
 func newDatabase(name string, dEnv *env.DoltEnv) dsqle.Database {
-	return dsqle.NewDatabase(name, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	return dsqle.NewDatabase(name, dEnv.DbData())
 }
 
 func dbsAsDSQLDBs(dbs []sql.Database) []dsqle.Database {

go/cmd/dolt/commands/status.go

@@ -83,7 +83,7 @@ func (cmd StatusCmd) Exec(ctx context.Context, commandStr string, args []string,
 		return 1
 	}
 
-	stagedDocDiffs, notStagedDocDiffs, err := diff.GetDocDiffs(ctx, dEnv.DoltDB, dEnv.RepoStateReader())
+	stagedDocDiffs, notStagedDocDiffs, err := diff.GetDocDiffs(ctx, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.DocsReadWriter())
 
 	if err != nil {
 		cli.PrintErrln(toStatusVErr(err).Verbose())

go/libraries/doltcore/diff/querydiff/query_differ.go

@@ -249,7 +249,7 @@ func nullSafeRowEquality(left, right sql.Row, sch sql.Schema) (bool, error) {
 }
 
 func makeSqlEngine(ctx context.Context, dEnv *env.DoltEnv, root *doltdb.RootValue) (*sql.Context, *sqle.Engine, error) {
-	doltSqlDB := dsqle.NewDatabase("db", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	doltSqlDB := dsqle.NewDatabase("db", dEnv.DbData())
 
 	sqlCtx := sql.NewContext(ctx,
 		sql.WithSession(dsqle.DefaultDoltSession()),

go/libraries/doltcore/diff/table_deltas.go

@@ -139,8 +139,8 @@ func (nd *DocDiffs) Len() int {
 }
 
 // GetDocDiffs retrieves staged and unstaged DocDiffs.
-func GetDocDiffs(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader) (*DocDiffs, *DocDiffs, error) {
-	docDetails, err := rsr.GetAllValidDocDetails()
+func GetDocDiffs(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader, drw env.DocsReadWriter) (*DocDiffs, *DocDiffs, error) {
+	docDetails, err := drw.GetAllValidDocDetails()
 	if err != nil {
 		return nil, nil, err
 	}

go/libraries/doltcore/dtestutils/testcommands/command.go

@@ -45,7 +45,7 @@ func (a StageAll) CommandString() string { return "stage_all" }
 
 // Exec executes a StageAll command on a test dolt environment.
 func (a StageAll) Exec(t *testing.T, dEnv *env.DoltEnv) error {
-	return actions.StageAllTables(context.Background(), dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	return actions.StageAllTables(context.Background(), dEnv.DbData())
 }
 
 type CommitStaged struct {
@@ -63,7 +63,9 @@ func (c CommitStaged) Exec(t *testing.T, dEnv *env.DoltEnv) error {
 		return err
 	}
 
-	_, err = actions.CommitStaged(context.Background(), dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter(), actions.CommitStagedProps{
+	dbData := dEnv.DbData()
+
+	_, err = actions.CommitStaged(context.Background(), dbData, actions.CommitStagedProps{
 		Message:          c.Message,
 		Date:             time.Now(),
 		AllowEmpty:       false,
@@ -84,7 +86,7 @@ func (c CommitAll) CommandString() string { return fmt.Sprintf("commit: %s", c.M
 
 // Exec executes a CommitAll command on a test dolt environment.
 func (c CommitAll) Exec(t *testing.T, dEnv *env.DoltEnv) error {
-	err := actions.StageAllTables(context.Background(), dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	err := actions.StageAllTables(context.Background(), dEnv.DbData())
 	require.NoError(t, err)
 
 	name, email, err := actions.GetNameAndEmail(dEnv.Config)
@@ -93,7 +95,9 @@ func (c CommitAll) Exec(t *testing.T, dEnv *env.DoltEnv) error {
 		return err
 	}
 
-	_, err = actions.CommitStaged(context.Background(), dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter(), actions.CommitStagedProps{
+	dbData := dEnv.DbData()
+
+	_, err = actions.CommitStaged(context.Background(), dbData, actions.CommitStagedProps{
 		Message:          c.Message,
 		Date:             time.Now(),
 		AllowEmpty:       false,
@@ -142,7 +146,7 @@ func (q Query) CommandString() string { return fmt.Sprintf("query %s", q.Query)
 func (q Query) Exec(t *testing.T, dEnv *env.DoltEnv) error {
 	root, err := dEnv.WorkingRoot(context.Background())
 	require.NoError(t, err)
-	sqlDb := dsqle.NewDatabase("dolt", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	sqlDb := dsqle.NewDatabase("dolt", dEnv.DbData())
 	engine, sqlCtx, err := dsqle.NewTestEngine(context.Background(), sqlDb, root)
 	require.NoError(t, err)
 

go/libraries/doltcore/env/actions/commit.go

@@ -62,7 +62,12 @@ func GetNameAndEmail(cfg config.ReadableConfig) (string, string, error) {
 }
 
 // CommitStaged adds a new commit to HEAD with the given props. Returns the new commit's hash as a string and an error.
-func CommitStaged(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader, rsw env.RepoStateWriter, props CommitStagedProps) (string, error) {
+func CommitStaged(ctx context.Context, dbData env.DbData, props CommitStagedProps) (string, error) {
+	ddb := dbData.Ddb
+	rsr := dbData.Rsr
+	rsw := dbData.Rsw
+	drw := dbData.Drw
+
 	if props.Message == "" {
 		return "", ErrEmptyCommitMessage
 	}
@@ -82,7 +87,7 @@ func CommitStaged(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateRead
 	}
 
 	if len(staged) == 0 && !rsr.IsMergeActive() && !props.AllowEmpty {
-		_, notStagedDocs, err := diff.GetDocDiffs(ctx, ddb, rsr)
+		_, notStagedDocs, err := diff.GetDocDiffs(ctx, ddb, rsr, drw)
 		if err != nil {
 			return "", err
 		}

go/libraries/doltcore/env/actions/docs.go

@@ -143,7 +143,7 @@ func getUpdatedWorkingAndStagedWithDocs(ctx context.Context, dEnv *env.DoltEnv,
 
 // GetUnstagedDocs retrieves the unstaged docs (docs from the filesystem).
 func GetUnstagedDocs(ctx context.Context, dEnv *env.DoltEnv) (env.Docs, error) {
-	_, unstagedDocDiffs, err := diff.GetDocDiffs(ctx, dEnv.DoltDB, dEnv.RepoStateReader())
+	_, unstagedDocDiffs, err := diff.GetDocDiffs(ctx, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.DocsReadWriter())
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/env/actions/staged.go

@@ -67,8 +67,13 @@ func GetTblsAndDocDetails(dEnv *env.DoltEnv, tbls []string) (tables []string, do
 	return tbls, docDetails, nil
 }
 
-func StageAllTables(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateReader, rsw env.RepoStateWriter) error {
-	err := rsw.PutDocsToWorking(ctx, nil)
+func StageAllTables(ctx context.Context, dbData env.DbData) error {
+	ddb := dbData.Ddb
+	rsr := dbData.Rsr
+	rsw := dbData.Rsw
+	drw := dbData.Drw
+
+	err := drw.PutDocsToWorking(ctx, nil)
 
 	if err != nil {
 		return err
@@ -94,7 +99,7 @@ func StageAllTables(ctx context.Context, ddb *doltdb.DoltDB, rsr env.RepoStateRe
 
 	err = stageTables(ctx, ddb, rsw, tbls, staged, working)
 	if err != nil {
-		rsw.ResetWorkingDocsToStagedDos(ctx)
+		drw.ResetWorkingDocsToStagedDocs(ctx)
 		return err
 	}
 

go/libraries/doltcore/env/environment.go

@@ -445,6 +445,26 @@ func (dEnv *DoltEnv) RepoStateWriter() RepoStateWriter {
 	return &repoStateWriter{dEnv}
 }
 
+type docsReadWriter struct {
+	dEnv *DoltEnv
+}
+
+func (d *docsReadWriter) GetAllValidDocDetails() ([]doltdb.DocDetails, error) {
+	return d.dEnv.GetAllValidDocDetails()
+}
+
+func (d *docsReadWriter) PutDocsToWorking(ctx context.Context, docDetails []doltdb.DocDetails) error {
+	return d.dEnv.PutDocsToWorking(ctx, docDetails)
+}
+
+func (d *docsReadWriter) ResetWorkingDocsToStagedDocs(ctx context.Context) error {
+	return d.dEnv.ResetWorkingDocsToStagedDocs(ctx)
+}
+
+func (dEnv *DoltEnv) DocsReadWriter() DocsReadWriter {
+	return &docsReadWriter{dEnv}
+}
+
 func (dEnv *DoltEnv) HeadRoot(ctx context.Context) (*doltdb.RootValue, error) {
 	commit, err := dEnv.DoltDB.ResolveRef(ctx, dEnv.RepoState.CWBHeadRef())
 
@@ -455,6 +475,15 @@ func (dEnv *DoltEnv) HeadRoot(ctx context.Context) (*doltdb.RootValue, error) {
 	return commit.GetRootValue()
 }
 
+func (dEnv *DoltEnv) DbData() DbData {
+	return DbData{
+		Ddb: dEnv.DoltDB,
+		Rsw: dEnv.RepoStateWriter(),
+		Rsr: dEnv.RepoStateReader(),
+		Drw: dEnv.DocsReadWriter(),
+	}
+}
+
 func (dEnv *DoltEnv) StagedRoot(ctx context.Context) (*doltdb.RootValue, error) {
 	return dEnv.DoltDB.ReadRootValue(ctx, dEnv.RepoState.StagedHash())
 }

go/libraries/doltcore/env/repo_state.go

@@ -31,7 +31,6 @@ type RepoStateReader interface {
 	StagedHash() hash.Hash
 	IsMergeActive() bool
 	GetMergeCommit() string
-	GetAllValidDocDetails() ([]doltdb.DocDetails, error)
 }
 
 type RepoStateWriter interface {
@@ -40,8 +39,19 @@ type RepoStateWriter interface {
 	SetStagedHash(context.Context, hash.Hash) error
 	SetWorkingHash(context.Context, hash.Hash) error
 	ClearMerge() error
+}
+
+type DocsReadWriter interface {
+	GetAllValidDocDetails() ([]doltdb.DocDetails, error)
 	PutDocsToWorking(ctx context.Context, docDetails []doltdb.DocDetails) error
-	ResetWorkingDocsToStagedDos(ctx context.Context) error
+	ResetWorkingDocsToStagedDocs(ctx context.Context) error
+}
+
+type DbData struct {
+	Ddb *doltdb.DoltDB
+	Rsw RepoStateWriter
+	Rsr RepoStateReader
+	Drw DocsReadWriter
 }
 
 type BranchConfig struct {

go/libraries/doltcore/envtestutils/rebase_tag_test.go

@@ -538,7 +538,7 @@ func checkSchema(t *testing.T, r *doltdb.RootValue, tableName string, expectedSc
 }
 
 func checkRows(t *testing.T, dEnv *env.DoltEnv, root *doltdb.RootValue, tableName string, sch schema.Schema, selectQuery string, expectedRows []row.Row) {
-	sqlDb := dsqle.NewDatabase("dolt", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	sqlDb := dsqle.NewDatabase("dolt", dEnv.DbData())
 	engine, sqlCtx, err := dsqle.NewTestEngine(context.Background(), sqlDb, root)
 	require.NoError(t, err)
 

go/libraries/doltcore/sqle/common_test.go

@@ -42,7 +42,7 @@ type SetupFn func(t *testing.T, dEnv *env.DoltEnv)
 // the targetSchema given is used to prepare all rows.
 func executeSelect(ctx context.Context, dEnv *env.DoltEnv, root *doltdb.RootValue, query string) ([]sql.Row, sql.Schema, error) {
 	var err error
-	db := NewDatabase("dolt", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := NewDatabase("dolt", dEnv.DbData())
 	engine, sqlCtx, err := NewTestEngine(ctx, db, root)
 	if err != nil {
 		return nil, nil, err
@@ -68,7 +68,7 @@ func executeSelect(ctx context.Context, dEnv *env.DoltEnv, root *doltdb.RootValu
 
 // Runs the query given and returns the error (if any).
 func executeModify(ctx context.Context, dEnv *env.DoltEnv, root *doltdb.RootValue, query string) (*doltdb.RootValue, error) {
-	db := NewDatabase("dolt", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := NewDatabase("dolt", dEnv.DbData())
 	engine, sqlCtx, err := NewTestEngine(ctx, db, root)
 
 	if err != nil {

go/libraries/doltcore/sqle/database.go

@@ -137,6 +137,7 @@ type Database struct {
 	ddb       *doltdb.DoltDB
 	rsr       env.RepoStateReader
 	rsw       env.RepoStateWriter
+	drw       env.DocsReadWriter
 	batchMode commitBehavior
 	tc        *tableCache
 }
@@ -149,12 +150,13 @@ var _ sql.TableRenamer = Database{}
 var _ sql.TriggerDatabase = Database{}
 
 // NewDatabase returns a new dolt database to use in queries.
-func NewDatabase(name string, ddb *doltdb.DoltDB, rsr env.RepoStateReader, rsw env.RepoStateWriter) Database {
+func NewDatabase(name string, dbData env.DbData) Database {
 	return Database{
 		name:      name,
-		ddb:       ddb,
-		rsr:       rsr,
-		rsw:       rsw,
+		ddb:       dbData.Ddb,
+		rsr:       dbData.Rsr,
+		rsw:       dbData.Rsw,
+		drw:       dbData.Drw,
 		batchMode: single,
 		tc:        &tableCache{&sync.Mutex{}, make(map[*doltdb.RootValue]map[string]sql.Table)},
 	}
@@ -162,12 +164,13 @@ func NewDatabase(name string, ddb *doltdb.DoltDB, rsr env.RepoStateReader, rsw e
 
 // NewBatchedDatabase returns a new dolt database executing in batch insert mode. Integrators must call Flush() to
 // commit any outstanding edits.
-func NewBatchedDatabase(name string, ddb *doltdb.DoltDB, rsr env.RepoStateReader, rsw env.RepoStateWriter) Database {
+func NewBatchedDatabase(name string, dbData env.DbData) Database {
 	return Database{
 		name:      name,
-		ddb:       ddb,
-		rsr:       rsr,
-		rsw:       rsw,
+		ddb:       dbData.Ddb,
+		rsr:       dbData.Rsr,
+		rsw:       dbData.Rsw,
+		drw:       dbData.Drw,
 		batchMode: batched,
 		tc:        &tableCache{&sync.Mutex{}, make(map[*doltdb.RootValue]map[string]sql.Table)},
 	}
@@ -193,6 +196,10 @@ func (db Database) GetStateWriter() env.RepoStateWriter {
 	return db.rsw
 }
 
+func (db Database) GetDocsReadWriter() env.DocsReadWriter {
+	return db.drw
+}
+
 // 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) {

go/libraries/doltcore/sqle/dfunctions/dolt_commit.go

@@ -42,24 +42,14 @@ func (d DoltCommitFunc) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 	// Get the information for the sql context.
 	dbName := ctx.GetCurrentDatabase()
 	dSess := sqle.DSessFromSess(ctx.Session)
-
-	ddb, ok := dSess.GetDoltDB(dbName)
+	dbData, ok := dSess.GetDbData(dbName)
 
 	if !ok {
 		return nil, fmt.Errorf("Could not load %s", dbName)
 	}
 
-	rsr, ok := dSess.GetDoltDBRepoStateReader(dbName)
-
-	if !ok {
-		return nil, fmt.Errorf("Could not load the %s RepoStateReader", dbName)
-	}
-
-	rsw, ok := dSess.GetDoltDBRepoStateWriter(dbName)
-
-	if !ok {
-		return nil, fmt.Errorf("Could not load the %s RepoStateWriter", dbName)
-	}
+	ddb := dbData.Ddb
+	rsr := dbData.Rsr
 
 	ap := cli.CreateCommitArgParser()
 
@@ -91,7 +81,7 @@ func (d DoltCommitFunc) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 	}
 
 	if allFlag {
-		err = actions.StageAllTables(ctx, ddb, rsr, rsw)
+		err = actions.StageAllTables(ctx, dbData)
 	}
 
 	if err != nil {
@@ -127,7 +117,7 @@ func (d DoltCommitFunc) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 		}
 	}
 
-	h, err := actions.CommitStaged(ctx, ddb, rsr, rsw, actions.CommitStagedProps{
+	h, err := actions.CommitStaged(ctx, dbData, actions.CommitStagedProps{
 		Message:          msg,
 		Date:             t,
 		AllowEmpty:       apr.Contains(cli.AllowEmptyFlag),

go/libraries/doltcore/sqle/dolt_index_test.go

@@ -973,7 +973,7 @@ func testDoltIndex(t *testing.T, keys []interface{}, expectedRows []sql.Row, ind
 func doltIndexSetup(t *testing.T) map[string]DoltIndex {
 	ctx := NewTestSQLCtx(context.Background())
 	dEnv := dtestutils.CreateTestEnv()
-	db := NewDatabase("dolt", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := NewDatabase("dolt", dEnv.DbData())
 	root, err := dEnv.WorkingRoot(ctx)
 	if err != nil {
 		panic(err)

go/libraries/doltcore/sqle/dolt_session.go

@@ -31,19 +31,13 @@ type dbRoot struct {
 	root    *doltdb.RootValue
 }
 
-type dbData struct {
-	ddb *doltdb.DoltDB
-	rsw env.RepoStateWriter
-	rsr env.RepoStateReader
-}
-
 var _ sql.Session = &DoltSession{}
 
 // DoltSession is the sql.Session implementation used by dolt.  It is accessible through a *sql.Context instance
 type DoltSession struct {
 	sql.Session
 	dbRoots   map[string]dbRoot
-	dbDatas   map[string]dbData
+	dbDatas   map[string]env.DbData
 	dbEditors map[string]*editor.TableEditSession
 
 	Username string
@@ -55,7 +49,7 @@ func DefaultDoltSession() *DoltSession {
 	sess := &DoltSession{
 		Session:   sql.NewBaseSession(),
 		dbRoots:   make(map[string]dbRoot),
-		dbDatas:   make(map[string]dbData),
+		dbDatas:   make(map[string]env.DbData),
 		dbEditors: make(map[string]*editor.TableEditSession),
 		Username:  "",
 		Email:     "",
@@ -66,10 +60,10 @@ func DefaultDoltSession() *DoltSession {
 // NewDoltSession creates a DoltSession object from a standard sql.Session and 0 or more Database objects.
 func NewDoltSession(ctx context.Context, sqlSess sql.Session, username, email string, dbs ...Database) (*DoltSession, error) {
 	dbRoots := make(map[string]dbRoot)
-	dbDatas := make(map[string]dbData)
+	dbDatas := make(map[string]env.DbData)
 	dbEditors := make(map[string]*editor.TableEditSession)
 	for _, db := range dbs {
-		dbDatas[db.Name()] = dbData{rsw: db.rsw, ddb: db.ddb, rsr: db.rsr}
+		dbDatas[db.Name()] = env.DbData{Rsw: db.rsw, Ddb: db.ddb, Rsr: db.rsr, Drw: db.drw}
 		dbEditors[db.Name()] = editor.CreateTableEditSession(nil, editor.TableEditSessionProps{})
 	}
 
@@ -104,12 +98,12 @@ func (sess *DoltSession) CommitTransaction(ctx *sql.Context) error {
 	dbData := sess.dbDatas[currentDb]
 
 	root := dbRoot.root
-	h, err := dbData.ddb.WriteRootValue(ctx, root)
+	h, err := dbData.Ddb.WriteRootValue(ctx, root)
 	if err != nil {
 		return err
 	}
 
-	return dbData.rsw.SetWorkingHash(ctx, h)
+	return dbData.Rsw.SetWorkingHash(ctx, h)
 }
 
 // GetDoltDB returns the *DoltDB for a given database by name
@@ -120,7 +114,7 @@ func (sess *DoltSession) GetDoltDB(dbName string) (*doltdb.DoltDB, bool) {
 		return nil, false
 	}
 
-	return d.ddb, true
+	return d.Ddb, true
 }
 
 func (sess *DoltSession) GetDoltDBRepoStateWriter(dbName string) (env.RepoStateWriter, bool) {
@@ -130,7 +124,7 @@ func (sess *DoltSession) GetDoltDBRepoStateWriter(dbName string) (env.RepoStateW
 		return nil, false
 	}
 
-	return d.rsw, true
+	return d.Rsw, true
 }
 
 func (sess *DoltSession) GetDoltDBRepoStateReader(dbName string) (env.RepoStateReader, bool) {
@@ -140,7 +134,50 @@ func (sess *DoltSession) GetDoltDBRepoStateReader(dbName string) (env.RepoStateR
 		return nil, false
 	}
 
-	return d.rsr, true
+	return d.Rsr, true
+}
+
+func (sess *DoltSession) GetDoltDBDocsReadWriter(dbName string) (env.DocsReadWriter, bool) {
+	d, ok := sess.dbDatas[dbName]
+
+	if !ok {
+		return nil, false
+	}
+
+	return d.Drw, true
+}
+
+func (sess *DoltSession) GetDbData(dbName string) (env.DbData, bool) {
+	ddb, ok := sess.GetDoltDB(dbName)
+
+	if !ok {
+		return env.DbData{}, false
+	}
+
+	rsr, ok := sess.GetDoltDBRepoStateReader(dbName)
+
+	if !ok {
+		return env.DbData{}, false
+	}
+
+	rsw, ok := sess.GetDoltDBRepoStateWriter(dbName)
+
+	if !ok {
+		return env.DbData{}, false
+	}
+
+	drw, ok := sess.GetDoltDBDocsReadWriter(dbName)
+
+	if !ok {
+		return env.DbData{}, false
+	}
+
+	return env.DbData{
+		Ddb: ddb,
+		Rsr: rsr,
+		Rsw: rsw,
+		Drw: drw,
+	}, true
 }
 
 // GetRoot returns the current *RootValue for a given database associated with the session
@@ -176,7 +213,7 @@ func (sess *DoltSession) GetParentCommit(ctx context.Context, dbName string) (*d
 		return nil, hash.Hash{}, err
 	}
 
-	cm, err := dbd.ddb.Resolve(ctx, cs, nil)
+	cm, err := dbd.Ddb.Resolve(ctx, cs, nil)
 
 	if err != nil {
 		return nil, hash.Hash{}, err
@@ -205,7 +242,7 @@ func (sess *DoltSession) Set(ctx context.Context, key string, typ sql.Type, valu
 			return err
 		}
 
-		cm, err := dbd.ddb.Resolve(ctx, cs, nil)
+		cm, err := dbd.Ddb.Resolve(ctx, cs, nil)
 
 		if err != nil {
 			return err
@@ -272,9 +309,10 @@ func (sess *DoltSession) AddDB(ctx context.Context, db Database) error {
 	name := db.Name()
 	rsr := db.GetStateReader()
 	rsw := db.GetStateWriter()
+	drw := db.GetDocsReadWriter()
 	ddb := db.GetDoltDB()
 
-	sess.dbDatas[db.Name()] = dbData{rsr: rsr, rsw: rsw, ddb: ddb}
+	sess.dbDatas[db.Name()] = env.DbData{Drw: drw, Rsr: rsr, Rsw: rsw, Ddb: ddb}
 
 	sess.dbEditors[db.Name()] = editor.CreateTableEditSession(nil, editor.TableEditSessionProps{})
 

go/libraries/doltcore/sqle/enginetest/dolt_harness.go

@@ -123,7 +123,7 @@ func (d *DoltHarness) NewDatabase(name string) sql.Database {
 	require.NoError(d.t, err)
 
 	d.mrEnv.AddEnv(name, dEnv)
-	db := sqle.NewDatabase(name, dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := sqle.NewDatabase(name, dEnv.DbData())
 	require.NoError(d.t, d.session.AddDB(enginetest.NewContext(d), db))
 	require.NoError(d.t, db.SetRoot(enginetest.NewContext(d).WithCurrentDB(db.Name()), root))
 	return db

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

@@ -334,7 +334,7 @@ func resetEnv(root *doltdb.RootValue) *doltdb.RootValue {
 }
 
 func sqlNewEngine(dEnv *env.DoltEnv) (*sqle.Engine, error) {
-	db := dsql.NewDatabase("dolt", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := dsql.NewDatabase("dolt", dEnv.DbData())
 	engine := sqle.NewDefault()
 	engine.AddDatabase(db)
 

go/libraries/doltcore/sqle/mergeable_indexes_setup_test.go

@@ -35,7 +35,7 @@ func setupMergeableIndexes(t *testing.T, tableName, insertQuery string) (*sqle.E
 	dEnv := dtestutils.CreateTestEnv()
 	root, err := dEnv.WorkingRoot(context.Background())
 	require.NoError(t, err)
-	db := NewDatabase("dolt", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := NewDatabase("dolt", dEnv.DbData())
 	engine, sqlCtx, err := NewTestEngine(context.Background(), db, root)
 	require.NoError(t, err)
 

go/libraries/doltcore/sqle/schema_table_test.go

@@ -32,7 +32,7 @@ import (
 func TestSchemaTableRecreation(t *testing.T) {
 	ctx := NewTestSQLCtx(context.Background())
 	dEnv := dtestutils.CreateTestEnv()
-	db := NewDatabase("dolt", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := NewDatabase("dolt", dEnv.DbData())
 	err := DSessFromSess(ctx.Session).AddDB(ctx, db)
 	require.NoError(t, err)
 	ctx.SetCurrentDatabase(db.Name())

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", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := NewBatchedDatabase("dolt", dEnv.DbData())
 	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", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := NewBatchedDatabase("dolt", dEnv.DbData())
 	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", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := NewBatchedDatabase("dolt", dEnv.DbData())
 	engine, sqlCtx, err := NewTestEngine(ctx, db, root)
 	require.NoError(t, err)
 

go/libraries/doltcore/sqle/table_editor_test.go

@@ -158,7 +158,7 @@ func TestTableEditor(t *testing.T) {
 
 			ctx := NewTestSQLCtx(context.Background())
 			root, _ := dEnv.WorkingRoot(context.Background())
-			db := NewDatabase("dolt", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+			db := NewDatabase("dolt", dEnv.DbData())
 			_ = DSessFromSess(ctx.Session).AddDB(ctx, db)
 			ctx.SetCurrentDatabase(db.Name())
 			err := db.SetRoot(ctx, root)

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", dEnv.DoltDB, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+	db := NewBatchedDatabase("dolt", dEnv.DbData())
 	engine, ctx, err := NewTestEngine(context.Background(), db, root)
 
 	if err != nil {
@@ -124,7 +124,15 @@ func NewTestEngine(ctx context.Context, db Database, root *doltdb.RootValue) (*s
 // 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(dEnv *env.DoltEnv, ddb *doltdb.DoltDB, root *doltdb.RootValue, query string) ([]sql.Row, error) {
-	db := NewDatabase("dolt", ddb, dEnv.RepoStateReader(), dEnv.RepoStateWriter())
+
+	dbData := env.DbData{
+		Ddb: ddb,
+		Rsw: dEnv.RepoStateWriter(),
+		Rsr: dEnv.RepoStateReader(),
+		Drw: dEnv.DocsReadWriter(),
+	}
+
+	db := NewDatabase("dolt", dbData)
 	engine, ctx, err := NewTestEngine(context.Background(), db, root)
 	if err != nil {
 		return nil, err