fix(table): advance ConcatIterator past fully version-pruned first table

Block-level version skipping (SetVersionBounds) can leave a table iterator invalid
after Rewind when every block falls outside the window (seekToFirst/seekToLast set
io.EOF). ConcatIterator.Rewind only positioned on the first table without looping,
so if that table was fully pruned the ConcatIterator — and its MergeIterator level —
looked exhausted and stranded every later table, silently dropping in-window entries
(reachable at L1+ where a level uses a ConcatIterator; e.g. a table with old keys in
early blocks and recent keys in later blocks, scanned with a mid version window).

Add skipInvalidTables(), called from Rewind, mirroring the empty-table loop already
in Next(). No-op when version bounds are disabled. Seek is unaffected: seekFrom does
not version-skip blocks and the binary search guarantees the chosen table holds a key
>= the seek key. Adds TestConcatIteratorSkipsFullyPrunedFirstTable (fails without the fix).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: shaunpatterson

table/iterator.go

@@ -559,6 +559,27 @@ func (s *ConcatIterator) Rewind() {
 		s.setIdx(len(s.iters) - 1)
 	}
 	s.cur.Rewind()
+	s.skipInvalidTables()
+}
+
+// skipInvalidTables advances to the next table (in iteration direction) whose
+// iterator is valid, after Rewind/Seek positioned us on one that is not. Version-range
+// block skipping (SetVersionBounds) can leave a table iterator invalid when all its
+// blocks fall outside the window; without this, the ConcatIterator — and hence its
+// MergeIterator level — would look exhausted and strand later tables' in-window keys.
+// Mirrors the empty-table loop in Next(). When version bounds are disabled this is a
+// no-op, since a non-empty table is always valid after Rewind.
+func (s *ConcatIterator) skipInvalidTables() {
+	for s.cur != nil && !s.cur.Valid() {
+		if s.options&REVERSED == 0 {
+			s.setIdx(s.idx + 1)
+		} else {
+			s.setIdx(s.idx - 1)
+		}
+		if s.cur != nil {
+			s.cur.Rewind()
+		}
+	}
 }
 
 // Valid implements y.Interface

table/version_range_test.go

@@ -344,3 +344,38 @@ func TestOldFormatTableNeverSkipped(t *testing.T) {
 	}
 	require.Equal(t, 50, count)
 }
+
+// TestConcatIteratorSkipsFullyPrunedFirstTable is a regression test for the
+// ConcatIterator stranding later tables when the first table's blocks are all
+// outside the version window. Table 1 (keys a1,a2) holds only old versions and is
+// fully block-pruned by the window [5,10]; table 2 (key m1) holds an in-window
+// version. A version-bounded ConcatIterator's Rewind must still surface table 2's key
+// instead of treating the whole level as exhausted, which dropped in-window data
+// before the fix. (Seek can't hit this: seekFrom does not version-skip blocks, and the
+// binary search guarantees the chosen table holds a key >= the seek key.)
+func TestConcatIteratorSkipsFullyPrunedFirstTable(t *testing.T) {
+	lower, upper := uint64(5), uint64(10)
+
+	t1 := buildVersionTable(t, []vkv{
+		{key: "a1", version: 1, value: "x"},
+		{key: "a2", version: 2, value: "x"},
+	}, 512)
+	defer func() { require.NoError(t, t1.DecrRef()) }()
+	t2 := buildVersionTable(t, []vkv{
+		{key: "m1", version: 7, value: "y"},
+	}, 512)
+	defer func() { require.NoError(t, t2.DecrRef()) }()
+
+	require.Less(t, t1.MaxVersion(), lower, "table1 must lie entirely below the window")
+
+	ci := NewConcatIterator([]*Table{t1, t2}, 0)
+	ci.SetVersionBounds(lower, upper)
+	defer func() { require.NoError(t, ci.Close()) }()
+
+	var got []string
+	for ci.Rewind(); ci.Valid(); ci.Next() {
+		got = append(got, string(y.ParseKey(ci.Key())))
+	}
+	require.Equal(t, []string{"m1"}, got,
+		"Rewind must surface the in-window key in table 2 despite table 1 being fully pruned")
+}