got rid of unused fields on EditorOpts

go/cmd/dolt/commands/dump.go

@@ -623,16 +623,6 @@ func dumpTable(ctx *sql.Context, dEnv *env.DoltEnv, engine *sqle.Engine, root do
 }
 
 func getTableWriter(ctx context.Context, dEnv *env.DoltEnv, tblOpts *tableOptions, outSch schema.Schema, filePath string) (table.SqlRowWriter, errhand.VerboseError) {
-	tmpDir, err := dEnv.TempTableFilesDir()
-	if err != nil {
-		return nil, errhand.BuildDError("error: ").AddCause(err).Build()
-	}
-	deaf, err := dEnv.DbEaFactory(ctx)
-	if err != nil {
-		return nil, errhand.BuildDError("error: ").AddCause(err).Build()
-	}
-	opts := editor.Options{Deaf: deaf, Tempdir: tmpDir}
-
 	writer, err := dEnv.FS.OpenForWriteAppend(filePath, os.ModePerm)
 	if err != nil {
 		return nil, errhand.BuildDError("Error opening writer for %s.", tblOpts.DestName()).AddCause(err).Build()
@@ -643,7 +633,7 @@ func getTableWriter(ctx context.Context, dEnv *env.DoltEnv, tblOpts *tableOption
 		return nil, errhand.BuildDError("Could not create table writer for %s", tblOpts.tableName).AddCause(err).Build()
 	}
 
-	wr, err := tblOpts.dest.NewCreatingWriter(ctx, tblOpts, root, outSch, opts, writer)
+	wr, err := tblOpts.dest.NewCreatingWriter(ctx, tblOpts, root, outSch, editor.Options{}, writer)
 	if err != nil {
 		return nil, errhand.BuildDError("Could not create table writer for %s", tblOpts.tableName).AddCause(err).Build()
 	}

go/cmd/dolt/commands/engine/utils.go

@@ -51,18 +51,6 @@ func CollectDBs(ctx context.Context, mrEnv *env.MultiRepoEnv) ([]dsess.SqlDataba
 }
 
 func newDatabase(ctx context.Context, name string, dEnv *env.DoltEnv) (sqle.Database, error) {
-	deaf, err := dEnv.DbEaFactory(ctx)
-	if err != nil {
-		return sqle.Database{}, err
-	}
-	tmpDir, err := dEnv.TempTableFilesDir()
-	if err != nil {
-		return sqle.Database{}, err
-	}
-	opts := editor.Options{
-		Deaf:    deaf,
-		Tempdir: tmpDir,
-	}
 	dbdata := dEnv.DbData(ctx)
 	// Databases registered with the SQL engine are always
 	// configured for FatalBehaviorCrash. These are local
@@ -75,5 +63,5 @@ func newDatabase(ctx context.Context, name string, dEnv *env.DoltEnv) (sqle.Data
 	// See also sqle/database_provider.go, where we do this when
 	// creating new databases as well.
 	dbdata.Ddb.SetCrashOnFatalError()
-	return sqle.NewDatabase(ctx, name, dbdata, opts)
+	return sqle.NewDatabase(ctx, name, dbdata, editor.Options{})
 }

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

@@ -335,16 +335,7 @@ func processFilterQuery(ctx context.Context, dEnv *env.DoltEnv, root doltdb.Root
 // we set manually with the one at the working set of the HEAD being rebased.
 // Some functionality will not work on this kind of engine, e.g. many DOLT_ functions.
 func rebaseSqlEngine(ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootValue) (*sql.Context, *engine.SqlEngine, error) {
-	tmpDir, err := dEnv.TempTableFilesDir()
-	if err != nil {
-		return nil, nil, err
-	}
-	deaf, err := dEnv.DbEaFactory(ctx)
-	if err != nil {
-		return nil, nil, err
-	}
-	opts := editor.Options{Deaf: deaf, Tempdir: tmpDir}
-	db, err := dsqle.NewDatabase(ctx, filterDbName, dEnv.DbData(ctx), opts)
+	db, err := dsqle.NewDatabase(ctx, filterDbName, dEnv.DbData(ctx), editor.Options{})
 	if err != nil {
 		return nil, nil, err
 	}

go/cmd/dolt/commands/indexcmds/rebuild.go

@@ -87,15 +87,7 @@ func (cmd RebuildCmd) Exec(ctx context.Context, commandStr string, args []string
 	if !ok {
 		return HandleErr(errhand.BuildDError("The table `%s` does not exist.", tableName).Build(), nil)
 	}
-	tmpDir, err := dEnv.TempTableFilesDir()
-	if err != nil {
-		return HandleErr(errhand.BuildDError("error: ").AddCause(err).Build(), nil)
-	}
-	deaf, err := dEnv.DbEaFactory(ctx)
-	if err != nil {
-		return HandleErr(errhand.BuildDError("error: ").AddCause(err).Build(), nil)
-	}
-	opts := editor.Options{Deaf: deaf, Tempdir: tmpDir}
+
 	sch, err := table.GetSchema(ctx)
 	if err != nil {
 		return HandleErr(errhand.BuildDError("could not get table schema").AddCause(err).Build(), nil)
@@ -104,7 +96,7 @@ func (cmd RebuildCmd) Exec(ctx context.Context, commandStr string, args []string
 	if idxSch == nil {
 		return HandleErr(errhand.BuildDError("the index `%s` does not exist on table `%s`", indexName, tableName).Build(), nil)
 	}
-	indexRowData, err := creation.BuildSecondaryIndex(sql.NewContext(ctx), table, idxSch, tableName, opts)
+	indexRowData, err := creation.BuildSecondaryIndex(sql.NewContext(ctx), table, idxSch, tableName, editor.Options{})
 	if err != nil {
 		return HandleErr(errhand.BuildDError("Unable to rebuild index `%s` on table `%s`.", indexName, tableName).AddCause(err).Build(), nil)
 	}

go/cmd/dolt/commands/schcmds/export.go

@@ -134,16 +134,7 @@ func exportSchemas(ctx context.Context, apr *argparser.ArgParseResults, root dol
 	}
 
 	for _, tn := range tablesToExport {
-		tmpDir, err := dEnv.TempTableFilesDir()
-		if err != nil {
-			return errhand.BuildDError("error: ").AddCause(err).Build()
-		}
-		deaf, err := dEnv.DbEaFactory(ctx)
-		if err != nil {
-			return errhand.BuildDError("error: ").AddCause(err).Build()
-		}
-		opts := editor.Options{Deaf: deaf, Tempdir: tmpDir}
-		verr := exportTblSchema(ctx, tn, root, wr, opts)
+		verr := exportTblSchema(ctx, tn, root, wr, editor.Options{})
 		if verr != nil {
 			return verr
 		}

go/cmd/dolt/commands/schcmds/show.go

@@ -133,16 +133,7 @@ func printSchemas(ctx context.Context, apr *argparser.ArgParseResults, dEnv *env
 			}
 		}
 
-		tmpDir, err := dEnv.TempTableFilesDir()
-		if err != nil {
-			return errhand.BuildDError("error: ").AddCause(err).Build()
-		}
-		deaf, err := dEnv.DbEaFactory(ctx)
-		if err != nil {
-			return errhand.BuildDError("error: ").AddCause(err).Build()
-		}
-		opts := editor.Options{Deaf: deaf, Tempdir: tmpDir}
-		sqlCtx, engine, _ := dsqle.PrepareCreateTableStmt(ctx, dsqle.NewUserSpaceDatabase(root, opts))
+		sqlCtx, engine, _ := dsqle.PrepareCreateTableStmt(ctx, dsqle.NewUserSpaceDatabase(root, editor.Options{}))
 
 		var notFound []string
 		for _, tblName := range tables {

go/cmd/dolt/commands/tblcmds/export.go

@@ -258,11 +258,7 @@ func getTableWriter(ctx context.Context, root doltdb.RootValue, dEnv *env.DoltEn
 		return nil, errhand.BuildDError("Error opening writer for %s.", exOpts.DestName()).AddCause(err).Build()
 	}
 
-	deaf, err := dEnv.DbEaFactory(ctx)
-	if err != nil {
-		return nil, errhand.BuildDError("Error opening writer for %s.", exOpts.DestName()).AddCause(err).Build()
-	}
-	wr, err := exOpts.dest.NewCreatingWriter(ctx, exOpts, root, rdSchema, editor.Options{Deaf: deaf}, writer)
+	wr, err := exOpts.dest.NewCreatingWriter(ctx, exOpts, root, rdSchema, editor.Options{}, writer)
 	if err != nil {
 		return nil, errhand.BuildDError("Error opening writer for %s.", exOpts.DestName()).AddCause(err).Build()
 	}

go/libraries/doltcore/merge/data_merge_test.go

@@ -127,7 +127,6 @@ func testDataMergeHelper(t *testing.T, tests []dataMergeTest, flipSides bool) {
 
 					var mo merge.MergeOpts
 					var eo editor.Options
-					eo = eo.WithDeaf(editor.NewInMemDeaf(a.VRW()))
 					// attempt merge before skipping to assert no panics
 					result, err := merge.MergeRoots(sql.NewContext(ctx), doltdb.SimpleTableResolver{}, l, r, a, rootish{r}, rootish{a}, eo, mo)
 
@@ -147,7 +146,6 @@ func testDataMergeHelper(t *testing.T, tests []dataMergeTest, flipSides bool) {
 func setupDataMergeTest(ctx context.Context, t *testing.T, schema namedSchema, test dataTest) (anc, left, right, merged doltdb.RootValue) {
 	denv := dtestutils.CreateTestEnv()
 	var eo editor.Options
-	eo = eo.WithDeaf(editor.NewInMemDeaf(denv.DoltDB(ctx).ValueReadWriter()))
 
 	ancestorTable := tbl(schema, test.ancestor...)
 	anc = makeRootWithTable(t, denv.DoltDB(ctx), eo, *ancestorTable)

go/libraries/doltcore/merge/schema_merge_test.go

@@ -1650,7 +1650,6 @@ func testSchemaMergeHelper(t *testing.T, tests []schemaMergeTest, flipSides bool
 
 				var mo merge.MergeOpts
 				var eo editor.Options
-				eo = eo.WithDeaf(editor.NewInMemDeaf(a.VRW()))
 				// attempt merge before skipping to assert no panics
 				result, err := merge.MergeRoots(sql.NewContext(ctx), doltdb.SimpleTableResolver{}, l, r, a, rootish{r}, rootish{a}, eo, mo)
 				maybeSkip(t, test, flipSides)
@@ -1693,7 +1692,6 @@ func testSchemaMergeHelper(t *testing.T, tests []schemaMergeTest, flipSides bool
 func setupSchemaMergeTest(ctx context.Context, t *testing.T, test schemaMergeTest) (anc, left, right, merged doltdb.RootValue) {
 	denv := dtestutils.CreateTestEnv()
 	var eo editor.Options
-	eo = eo.WithDeaf(editor.NewInMemDeaf(denv.DoltDB(ctx).ValueReadWriter()))
 	anc = makeRootWithTable(t, denv.DoltDB(ctx), eo, test.ancestor)
 	assert.NotNil(t, anc)
 	if test.left != nil {

go/libraries/doltcore/sqle/binlogreplication/binlog_replica_applier.go

@@ -841,9 +841,7 @@ func getTableWriter(ctx *sql.Context, engine *gms.Engine, tableName, databaseNam
 		return nil, nil, err
 	}
 
-	options := sqlDatabase.EditOptions()
-	options.ForeignKeyChecksDisabled = foreignKeyChecksDisabled
-	writeSession := writer.NewWriteSession(binFormat, ws, tracker, options)
+	writeSession := writer.NewWriteSession(binFormat, ws, tracker, sqlDatabase.EditOptions())
 
 	ds := dsess.DSessFromSess(ctx.Session)
 	setter := ds.SetWorkingRoot

go/libraries/doltcore/sqle/database_provider.go

@@ -990,23 +990,7 @@ func (p *DoltDatabaseProvider) registerNewDatabase(ctx *sql.Context, name string
 	// Ensure any provider-supplied DB load params are applied before any lazy DB load occurs.
 	p.applyDBLoadParamsToEnv(newEnv)
 
-	fkChecks, err := ctx.GetSessionVariable(ctx, "foreign_key_checks")
-	if err != nil {
-		return err
-	}
-
-	deaf, err := newEnv.DbEaFactory(ctx)
-	if err != nil {
-		return err
-	}
-
-	opts := editor.Options{
-		Deaf: deaf,
-		// TODO: this doesn't seem right, why is this getting set in the constructor to the DB
-		ForeignKeyChecksDisabled: fkChecks.(int8) == 0,
-	}
-
-	db, err := NewDatabase(ctx, name, newEnv.DbData(ctx), opts)
+	db, err := NewDatabase(ctx, name, newEnv.DbData(ctx), editor.Options{})
 	if err != nil {
 		return err
 	}

go/libraries/doltcore/sqle/dprocedures/dolt_stash.go

@@ -392,14 +392,6 @@ func parseStashIndex(apr *argparser.ArgParseResults) (int, error) {
 	return idx, nil
 }
 
-func bulkDbEaFactory(dbData env.DbData[*sql.Context]) editor.DbEaFactory {
-	tmpDir, err := dbData.Rsw.TempTableFilesDir()
-	if err != nil {
-		return nil
-	}
-	return editor.NewBulkImportTEAFactory(dbData.Ddb.ValueReadWriter(), tmpDir)
-}
-
 func updateWorkingRoot(ctx *sql.Context, dbData env.DbData[*sql.Context], newRoot doltdb.RootValue) error {
 	var h hash.Hash
 	var wsRef ref.WorkingSetRef
@@ -510,16 +502,12 @@ func handleMerge(ctx *sql.Context, dbName string, dbData env.DbData[*sql.Context
 		return nil, nil, nil, err
 	}
 
-	tmpDir, err := dbData.Rsw.TempTableFilesDir()
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
 	tableResolver, err := dsess.GetTableResolver(ctx, dbName)
 	if err != nil {
 		return nil, nil, nil, err
 	}
-	opts := editor.Options{Deaf: bulkDbEaFactory(dbData), Tempdir: tmpDir}
+
+	opts := editor.Options{}
 	result, err := merge.MergeRoots(ctx, tableResolver, curWorkingRoot, stashRoot, parentRoot, stashRoot, parentCommit, opts, merge.MergeOpts{IsCherryPick: false})
 	if err != nil {
 		return nil, nil, nil, err

go/libraries/doltcore/sqle/dsess/session.go

@@ -24,7 +24,6 @@ import (
 	"time"
 
 	"github.com/dolthub/go-mysql-server/sql"
-	sqltypes "github.com/dolthub/go-mysql-server/sql/types"
 	"github.com/shopspring/decimal"
 
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
@@ -1302,40 +1301,6 @@ func (d *DoltSession) setHeadRefSessionVar(ctx *sql.Context, db, value string) e
 func (d *DoltSession) setForeignKeyChecksSessionVar(ctx *sql.Context, key string, value interface{}) error {
 	d.mu.Lock()
 	defer d.mu.Unlock()
-
-	convertedVal, _, err := sqltypes.Int64.Convert(ctx, value)
-	if err != nil {
-		return err
-	}
-	intVal := int64(0)
-	if convertedVal != nil {
-		intVal = convertedVal.(int64)
-	}
-
-	if intVal == 0 {
-		for _, dbState := range d.dbStates {
-			for _, branchState := range dbState.heads {
-				if ws := branchState.WriteSession(); ws != nil {
-					opts := ws.GetOptions()
-					opts.ForeignKeyChecksDisabled = true
-					ws.SetOptions(opts)
-				}
-			}
-		}
-	} else if intVal == 1 {
-		for _, dbState := range d.dbStates {
-			for _, branchState := range dbState.heads {
-				if ws := branchState.WriteSession(); ws != nil {
-					opts := ws.GetOptions()
-					opts.ForeignKeyChecksDisabled = false
-					ws.SetOptions(opts)
-				}
-			}
-		}
-	} else {
-		return sql.ErrInvalidSystemVariableValue.New("foreign_key_checks", intVal)
-	}
-
 	return d.Session.SetSessionVariable(ctx, key, value)
 }
 

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

@@ -301,16 +301,7 @@ func schemaToSchemaString(sch sql.Schema) (string, error) {
 }
 
 func sqlNewEngine(ctx context.Context, dEnv *env.DoltEnv) (*sqle.Engine, dsess.DoltDatabaseProvider, error) {
-	tmpDir, err := dEnv.TempTableFilesDir()
-	if err != nil {
-		return nil, nil, err
-	}
-	deaf, err := dEnv.DbEaFactory(ctx)
-	if err != nil {
-		return nil, nil, err
-	}
-	opts := editor.Options{Deaf: deaf, Tempdir: tmpDir}
-	db, err := dsql.NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts)
+	db, err := dsql.NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), editor.Options{})
 	if err != nil {
 		return nil, nil, err
 	}

go/libraries/doltcore/sqle/replication.go

@@ -55,16 +55,7 @@ func GetCommitHooks(ctx context.Context, dEnv *env.DoltEnv, logger io.Writer) ([
 // skip errors related to database construction only and return a partially functional dsqle.ReadReplicaDatabase
 // that will log warnings when attempting to perform replica commands.
 func newReplicaDatabase(ctx context.Context, name string, remoteName string, dEnv *env.DoltEnv) (ReadReplicaDatabase, error) {
-	deaf, err := dEnv.DbEaFactory(ctx)
-	if err != nil {
-		return ReadReplicaDatabase{}, err
-	}
-
-	opts := editor.Options{
-		Deaf: deaf,
-	}
-
-	db, err := NewDatabase(ctx, name, dEnv.DbData(ctx), opts)
+	db, err := NewDatabase(ctx, name, dEnv.DbData(ctx), editor.Options{})
 	if err != nil {
 		return ReadReplicaDatabase{}, err
 	}

go/libraries/doltcore/sqle/statspro/controller.go

@@ -611,21 +611,7 @@ func (sc *StatsController) initStorage(ctx context.Context, fs filesys.Filesys)
 		return nil, err
 	}
 
-	deaf, err := dEnv.DbEaFactory(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	tmpDir, err := dEnv.TempTableFilesDir()
-	if err != nil {
-		return nil, err
-	}
-	opts := editor.Options{
-		Deaf:    deaf,
-		Tempdir: tmpDir,
-	}
-
-	statsDb, err := sqle.NewDatabase(ctx, "stats", dEnv.DbData(ctx), opts)
+	statsDb, err := sqle.NewDatabase(ctx, "stats", dEnv.DbData(ctx), editor.Options{})
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/sqle/tables.go

@@ -1798,9 +1798,7 @@ func (t *AlterableDoltTable) RewriteInserter(
 		return nil, fmt.Errorf("cannot rebuild index on a headless branch")
 	}
 
-	opts := dbState.WriteSession().GetOptions()
-	opts.ForeignKeyChecksDisabled = true
-	writeSession := writer.NewWriteSession(dt.Format(), newWs, ait, opts)
+	writeSession := writer.NewWriteSession(dt.Format(), newWs, ait, dbState.WriteSession().GetOptions())
 
 	ed, err := writeSession.GetTableWriter(ctx, t.TableName(), t.db.RevisionQualifiedName(), sess.SetWorkingRoot, false)
 	if err != nil {
@@ -1847,9 +1845,7 @@ func fullTextRewriteEditor(
 		return nil, fmt.Errorf("cannot rebuild index on read only database %s", t.Name())
 	}
 
-	opts := dbState.WriteSession().GetOptions()
-	opts.ForeignKeyChecksDisabled = true
-	writeSession := writer.NewWriteSession(dt.Format(), newWs, ait, opts)
+	writeSession := writer.NewWriteSession(dt.Format(), newWs, ait, dbState.WriteSession().GetOptions())
 
 	parentEditor, err := writeSession.GetTableWriter(ctx, t.TableName(), t.db.RevisionQualifiedName(), sess.SetWorkingRoot, false)
 	if err != nil {

go/libraries/doltcore/sqle/testutil.go

@@ -46,17 +46,7 @@ import (
 // ExecuteSql 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(ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootValue, statements string) (doltdb.RootValue, error) {
-	tmpDir, err := dEnv.TempTableFilesDir()
-	if err != nil {
-		return nil, err
-	}
-
-	deaf, err := dEnv.DbEaFactory(ctx)
-	if err != nil {
-		return nil, err
-	}
-	opts := editor.Options{Deaf: deaf, Tempdir: tmpDir}
-	db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), opts)
+	db, err := NewDatabase(context.Background(), "dolt", dEnv.DbData(ctx), editor.Options{})
 	if err != nil {
 		return nil, err
 	}
@@ -166,17 +156,7 @@ func ExecuteSelect(ctx context.Context, dEnv *env.DoltEnv, root doltdb.RootValue
 		Rsr: dEnv.RepoStateReader(),
 	}
 
-	tmpDir, err := dEnv.TempTableFilesDir()
-	if err != nil {
-		return nil, err
-	}
-
-	deaf, err := dEnv.DbEaFactory(ctx)
-	if err != nil {
-		return nil, err
-	}
-	opts := editor.Options{Deaf: deaf, Tempdir: tmpDir}
-	db, err := NewDatabase(context.Background(), "dolt", dbData, opts)
+	db, err := NewDatabase(context.Background(), "dolt", dbData, editor.Options{})
 	if err != nil {
 		return nil, err
 	}

go/libraries/doltcore/table/editor/editor_options.go

@@ -25,26 +25,14 @@ import (
 type PKDuplicateCb func(newKeyString, indexName string, existingKey, existingVal types.Tuple, isPk bool) error
 
 // Options are properties that define different functionality for the tableEditSession.
+// TODO next: all these fields are write-only, remove them
 type Options struct {
-	ForeignKeyChecksDisabled bool // If true, then ALL foreign key checks AND updates (through CASCADE, etc.) are skipped
-	Deaf                     DbEaFactory
-	Tempdir                  string
-
 	// TargetStaging is true if the table is being edited in the staging root, as opposed to the working root (rare).
 	TargetStaging bool
 }
 
-// WithDeaf returns a new Options with the given  edit accumulator factory class
-func (o Options) WithDeaf(deaf DbEaFactory) Options {
-	o.Deaf = deaf
-	return o
-}
-
 func TestEditorOptions(vrw types.ValueReadWriter) Options {
-	return Options{
-		ForeignKeyChecksDisabled: false,
-		Deaf:                     NewInMemDeaf(vrw),
-	}
+	return Options{}
 }
 
 // formatKey returns a comma-separated string representation of the key given.

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

@@ -221,7 +221,7 @@ func (ie *IndexEditor) Undo(ctx context.Context) {
 		err := ie.DeleteRow(ctx, indexOp.fullKey, indexOp.partialKey, indexOp.value)
 		if err != nil {
 			ie.permanentErr = fmt.Errorf("index '%s' is in an invalid and unrecoverable state: "+
-					"attempted to undo previous insertion but encountered the following error: %v",
+				"attempted to undo previous insertion but encountered the following error: %v",
 				ie.idx.Name(), err)
 			return
 		}
@@ -229,7 +229,7 @@ func (ie *IndexEditor) Undo(ctx context.Context) {
 		err := ie.InsertRow(ctx, indexOp.fullKey, indexOp.partialKey, indexOp.value)
 		if err != nil {
 			ie.permanentErr = fmt.Errorf("index '%s' is in an invalid and unrecoverable state: "+
-					"attempted to undo previous deletion but encountered the following error: %v",
+				"attempted to undo previous deletion but encountered the following error: %v",
 				ie.idx.Name(), err)
 			return
 		}