refactored prolly diff iter to accept zero-value maps

go/libraries/doltcore/sqle/dtables/diff_iter.go

@@ -242,19 +242,31 @@ func newProllyDiffIter(ctx *sql.Context, dp DiffPartition, ddb *doltdb.DoltDB, t
 		name: dp.toName,
 		ts:   (*time.Time)(dp.toDate),
 	}
+	var from, to prolly.Map
 
-	// dp.from may be nil
-	f, fSch, err := tableData(ctx, dp.from, ddb)
-	if err != nil {
-		return prollyDiffIter{}, err
+	var fsch schema.Schema = schema.EmptySchema
+	if dp.from != nil {
+		idx, err := dp.from.GetRowData(ctx)
+		if err != nil {
+			return prollyDiffIter{}, err
+		}
+		from = durable.ProllyMapFromIndex(idx)
+		if fsch, err = dp.from.GetSchema(ctx); err != nil {
+			return prollyDiffIter{}, err
+		}
 	}
-	from := durable.ProllyMapFromIndex(f)
 
-	t, tSch, err := tableData(ctx, dp.to, ddb)
-	if err != nil {
-		return prollyDiffIter{}, err
+	var tsch schema.Schema = schema.EmptySchema
+	if dp.to != nil {
+		idx, err := dp.to.GetRowData(ctx)
+		if err != nil {
+			return prollyDiffIter{}, err
+		}
+		to = durable.ProllyMapFromIndex(idx)
+		if tsch, err = dp.to.GetSchema(ctx); err != nil {
+			return prollyDiffIter{}, err
+		}
 	}
-	to := durable.ProllyMapFromIndex(t)
 
 	var nodeStore tree.NodeStore
 	if dp.to != nil {
@@ -263,25 +275,25 @@ func newProllyDiffIter(ctx *sql.Context, dp DiffPartition, ddb *doltdb.DoltDB, t
 		nodeStore = dp.from.NodeStore()
 	}
 
-	fromConverter, err := NewProllyRowConverter(fSch, targetFromSchema, ctx.Warn, nodeStore)
+	fromConverter, err := NewProllyRowConverter(fsch, targetFromSchema, ctx.Warn, nodeStore)
 	if err != nil {
 		return prollyDiffIter{}, err
 	}
 
-	toConverter, err := NewProllyRowConverter(tSch, targetToSchema, ctx.Warn, nodeStore)
+	toConverter, err := NewProllyRowConverter(tsch, targetToSchema, ctx.Warn, nodeStore)
 	if err != nil {
 		return prollyDiffIter{}, err
 	}
 
-	fromVD := fSch.GetValueDescriptor()
-	toVD := tSch.GetValueDescriptor()
+	fromVD := fsch.GetValueDescriptor()
+	toVD := tsch.GetValueDescriptor()
 	keyless := schema.IsKeyless(targetFromSchema) && schema.IsKeyless(targetToSchema)
 	child, cancel := context.WithCancel(ctx)
 	iter := prollyDiffIter{
 		from:          from,
 		to:            to,
-		fromSch:       fSch,
-		toSch:         tSch,
+		fromSch:       fsch,
+		toSch:         tsch,
 		targetFromSch: targetFromSchema,
 		targetToSch:   targetToSchema,
 		fromConverter: fromConverter,

go/store/prolly/map_diff_test.go

@@ -95,6 +95,15 @@ func TestMapDiff(t *testing.T) {
 					testUpdateDiffs(t, prollyMap.(Map), tuples, s/2)
 				}
 			})
+
+			// one-sided diffs
+			var empty Map
+			t.Run("empty from map", func(t *testing.T) {
+				testOneSidedDiff(t, s, empty, prollyMap.(Map), tree.AddedDiff)
+			})
+			t.Run("empty to map", func(t *testing.T) {
+				testOneSidedDiff(t, s, prollyMap.(Map), empty, tree.RemovedDiff)
+			})
 		})
 	}
 }
@@ -218,6 +227,17 @@ func testUpdateDiffs(t *testing.T, from Map, tups [][2]val.Tuple, numUpdates int
 	assert.Equal(t, numUpdates, cnt)
 }
 
+func testOneSidedDiff(t *testing.T, sz int, from, to Map, typ tree.DiffType) {
+	var seen int
+	err := DiffMaps(context.Background(), from, to, func(ctx context.Context, diff tree.Diff) error {
+		assert.Equal(t, diff.Type, typ)
+		seen++
+		return nil
+	})
+	assert.Error(t, err, io.EOF)
+	assert.Equal(t, sz, seen)
+}
+
 func makeMapWithDeletes(t *testing.T, m Map, deletes ...[2]val.Tuple) Map {
 	ctx := context.Background()
 	mut := m.Mutate()

go/store/prolly/tree/diff.go

@@ -48,14 +48,25 @@ func DifferFromRoots[K ~[]byte, O Ordering[K]](
 	from, to Node,
 	order O,
 ) (Differ[K, O], error) {
-	fc, err := NewCursorAtStart(ctx, fromNs, from)
-	if err != nil {
-		return Differ[K, O]{}, err
+	var fc, tc *Cursor
+	var err error
+
+	if !from.empty() {
+		fc, err = NewCursorAtStart(ctx, fromNs, from)
+		if err != nil {
+			return Differ[K, O]{}, err
+		}
+	} else {
+		fc = &Cursor{}
 	}
 
-	tc, err := NewCursorAtStart(ctx, toNs, to)
-	if err != nil {
-		return Differ[K, O]{}, err
+	if !to.empty() {
+		tc, err = NewCursorAtStart(ctx, toNs, to)
+		if err != nil {
+			return Differ[K, O]{}, err
+		}
+	} else {
+		tc = &Cursor{}
 	}
 
 	fs, err := NewCursorPastEnd(ctx, fromNs, from)