[no-review-notes] Removed most of the remaining LD_1 specific codepaths and types

go/cmd/dolt/dolt.go

@@ -74,7 +74,6 @@ var commandsWithoutCliCtx = []cli.Command{
 	credcmds.Commands,
 	cvcmds.Commands,
 	commands.SendMetricsCmd{},
-	commands.MigrateCmd{},
 	indexcmds.Commands,
 	commands.ReadTablesCmd{},
 	commands.FilterBranchCmd{},
@@ -96,7 +95,6 @@ var commandsWithoutGlobalArgSupport = []cli.Command{
 	commands.InitCmd{},
 	commands.CloneCmd{},
 	docscmds.Commands,
-	commands.MigrateCmd{},
 	commands.ReadTablesCmd{},
 	commands.LoginCmd{},
 	credcmds.Commands,

go/cmd/dolt/doltcmd/doltcmd.go

@@ -68,7 +68,6 @@ var doltSubCommands = []cli.Command{
 	commands.BlameCmd{},
 	cvcmds.Commands,
 	commands.SendMetricsCmd{},
-	commands.MigrateCmd{},
 	indexcmds.Commands,
 	commands.ReadTablesCmd{},
 	commands.GarbageCollectionCmd{},

go/libraries/doltcore/diff/async_differ.go

@@ -22,27 +22,11 @@ import (
 	"golang.org/x/sync/errgroup"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/row"
-	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/utils/async"
 	"github.com/dolthub/dolt/go/store/diff"
 	"github.com/dolthub/dolt/go/store/types"
 )
 
-func NewRowDiffer(ctx context.Context, format *types.NomsBinFormat, fromSch, toSch schema.Schema, buf int) RowDiffer {
-	ad := NewAsyncDiffer(buf)
-
-	// Returns an EmptyRowDiffer if the two schemas are not diffable.
-	if !schema.ArePrimaryKeySetsDiffable(format, fromSch, toSch) {
-		return &EmptyRowDiffer{}
-	}
-
-	if schema.IsKeyless(fromSch) || schema.IsKeyless(toSch) {
-		return &keylessDiffer{AsyncDiffer: ad}
-	}
-
-	return ad
-}
-
 // todo: make package private
 type AsyncDiffer struct {
 	diffChan   chan diff.Difference

go/libraries/doltcore/diff/diff_source.go

@@ -14,17 +14,6 @@
 
 package diff
 
-import (
-	"errors"
-	"io"
-	"time"
-
-	"github.com/dolthub/dolt/go/libraries/doltcore/row"
-	"github.com/dolthub/dolt/go/libraries/doltcore/rowconv"
-	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
-	"github.com/dolthub/dolt/go/store/types"
-)
-
 const (
 	From = "from"
 	To   = "to"
@@ -37,103 +26,3 @@ func ToColNamer(name string) string {
 func FromColNamer(name string) string {
 	return From + "_" + name
 }
-
-type RowDiffSource struct {
-	ad         RowDiffer
-	joiner     *rowconv.Joiner
-	oldRowConv *rowconv.RowConverter
-	newRowConv *rowconv.RowConverter
-	warnFn     rowconv.WarnFunction
-}
-
-func NewRowDiffSource(ad RowDiffer, joiner *rowconv.Joiner, warnFn rowconv.WarnFunction) *RowDiffSource {
-	return &RowDiffSource{
-		ad:         ad,
-		joiner:     joiner,
-		oldRowConv: rowconv.IdentityConverter,
-		newRowConv: rowconv.IdentityConverter,
-		warnFn:     warnFn,
-	}
-}
-
-func (rdRd *RowDiffSource) AddInputRowConversion(oldConv, newConv *rowconv.RowConverter) {
-	rdRd.oldRowConv = oldConv
-	rdRd.newRowConv = newConv
-}
-
-// GetSchema gets the schema of the rows that this reader will return
-func (rdRd *RowDiffSource) GetSchema() schema.Schema {
-	return rdRd.joiner.GetSchema()
-}
-
-// NextDiff reads a row from a table.  If there is a bad row the returned error will be non nil, and calling IsBadRow(err)
-// will be return true. This is a potentially non-fatal error and callers can decide if they want to continue on a bad row, or fail.
-func (rdRd *RowDiffSource) NextDiff() (row.Row, error) {
-	diffs, hasMore, err := rdRd.ad.GetDiffs(1, time.Second)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(diffs) == 0 {
-		if !hasMore {
-			return nil, io.EOF
-		}
-		return nil, errors.New("timeout")
-	}
-
-	if len(diffs) != 1 {
-		panic("only a single diff requested, multiple returned.  bug in AsyncDiffer")
-	}
-
-	d := diffs[0]
-	rows := make(map[string]row.Row)
-	if d.OldValue != nil {
-		sch := rdRd.joiner.SchemaForName(From)
-		if !rdRd.oldRowConv.IdentityConverter {
-			sch = rdRd.oldRowConv.SrcSch
-		}
-
-		oldRow, err := row.FromNoms(sch, d.KeyValue.(types.Tuple), d.OldValue.(types.Tuple))
-
-		if err != nil {
-			return nil, err
-		}
-
-		rows[From], err = rdRd.oldRowConv.ConvertWithWarnings(oldRow, rdRd.warnFn)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	if d.NewValue != nil {
-		sch := rdRd.joiner.SchemaForName(To)
-		if !rdRd.newRowConv.IdentityConverter {
-			sch = rdRd.newRowConv.SrcSch
-		}
-
-		newRow, err := row.FromNoms(sch, d.KeyValue.(types.Tuple), d.NewValue.(types.Tuple))
-
-		if err != nil {
-			return nil, err
-		}
-
-		rows[To], err = rdRd.newRowConv.ConvertWithWarnings(newRow, rdRd.warnFn)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	joinedRow, err := rdRd.joiner.Join(rows)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return joinedRow, nil
-}
-
-// Close should release resources being held
-func (rdRd *RowDiffSource) Close() error {
-	rdRd.ad.Close()
-	return nil
-}

go/libraries/doltcore/diff/diff_stat.go

@@ -62,11 +62,8 @@ func Stat(ctx context.Context, ch chan DiffStatProgress, from, to durable.Index,
 		return fmt.Errorf("cannot perform a diff between keyless and keyed schema")
 	}
 
-	if types.IsFormat_DOLT(from.Format()) {
-		return diffProllyTrees(ctx, ch, keyless, from, to, fromSch, toSch)
-	}
-
-	return diffNomsMaps(ctx, ch, keyless, from, to, fromSch, toSch)
+	types.AssertFormat_DOLT(from.Format())
+	return diffProllyTrees(ctx, ch, keyless, from, to, fromSch, toSch)
 }
 
 // StatForTableDelta pushes diff stat progress messages for the table delta given to the channel given
@@ -88,7 +85,7 @@ func StatForTableDelta(ctx context.Context, ch chan DiffStatProgress, td TableDe
 		return errhand.BuildDError("cannot retrieve schema for table %s", td.ToName).AddCause(err).Build()
 	}
 
-	if !schema.ArePrimaryKeySetsDiffable(td.Format(), fromSch, toSch) {
+	if !schema.ArePrimaryKeySetsDiffable(fromSch, toSch) {
 		return fmt.Errorf("failed to compute diff stat for table %s: %w", td.CurName(), ErrPrimaryKeySetChanged)
 	}
 
@@ -102,11 +99,7 @@ func StatForTableDelta(ctx context.Context, ch chan DiffStatProgress, td TableDe
 		return err
 	}
 
-	if types.IsFormat_DOLT(td.Format()) {
-		return diffProllyTrees(ctx, ch, keyless, fromRows, toRows, fromSch, toSch)
-	} else {
-		return diffNomsMaps(ctx, ch, keyless, fromRows, toRows, fromSch, toSch)
-	}
+	return diffProllyTrees(ctx, ch, keyless, fromRows, toRows, fromSch, toSch)
 }
 
 func diffProllyTrees(ctx context.Context, ch chan DiffStatProgress, keyless bool, from, to durable.Index, fromSch, toSch schema.Schema) error {
@@ -175,33 +168,6 @@ func diffProllyTrees(ctx context.Context, ch chan DiffStatProgress, keyless bool
 	return nil
 }
 
-func diffNomsMaps(ctx context.Context, ch chan DiffStatProgress, keyless bool, fromRows durable.Index, toRows durable.Index, fromSch, toSch schema.Schema) error {
-	var rpr nomsReporter
-	if keyless {
-		rpr = reportNomsKeylessChanges
-	} else {
-		fc, err := fromRows.Count()
-		if err != nil {
-			return err
-		}
-		cfc := uint64(len(fromSch.GetAllCols().GetColumns())) * fc
-		tc, err := toRows.Count()
-		if err != nil {
-			return err
-		}
-		ctc := uint64(len(toSch.GetAllCols().GetColumns())) * tc
-		rpr = reportNomsPkChanges
-		ch <- DiffStatProgress{
-			OldRowSize:  fc,
-			NewRowSize:  tc,
-			OldCellSize: cfc,
-			NewCellSize: ctc,
-		}
-	}
-
-	return statWithReporter(ctx, ch, durable.NomsMapFromIndex(fromRows), durable.NomsMapFromIndex(toRows), rpr, fromSch, toSch)
-}
-
 func statWithReporter(ctx context.Context, ch chan DiffStatProgress, from, to types.Map, rpr nomsReporter, fromSch, toSch schema.Schema) (err error) {
 	ad := NewAsyncDiffer(1024)
 	ad.Start(ctx, from, to)

go/libraries/doltcore/diff/table_deltas.go

@@ -594,7 +594,7 @@ func (td TableDelta) HasDataChanged(ctx context.Context) (bool, error) {
 }
 
 func (td TableDelta) HasPrimaryKeySetChanged() bool {
-	return !schema.ArePrimaryKeySetsDiffable(td.Format(), td.FromSch, td.ToSch)
+	return !schema.ArePrimaryKeySetsDiffable(td.FromSch, td.ToSch)
 }
 
 func (td TableDelta) HasChanges() (bool, error) {
@@ -658,17 +658,6 @@ func (td TableDelta) GetSchemas(ctx context.Context) (from, to schema.Schema, er
 	return td.FromSch, td.ToSch, nil
 }
 
-// Format returns the format of the tables in this delta.
-func (td TableDelta) Format() *types.NomsBinFormat {
-	if td.FromRootObject != nil || td.ToRootObject != nil {
-		return types.Format_DOLT
-	}
-	if td.FromTable != nil {
-		return td.FromTable.Format()
-	}
-	return td.ToTable.Format()
-}
-
 func (td TableDelta) IsKeyless(ctx context.Context) (bool, error) {
 	f, t, err := td.GetSchemas(ctx)
 	if err != nil {