.

wcfs/internal/xbtree/δbtail.go

@@ -166,10 +166,10 @@ type ΔBtail struct {
 type _ΔTtail struct {
 	// XXX explain about snapshot mode + RCU
 	// ...
-	// XXX text from rebuild:
-	// clone vδT before modifying it
-	// queries such as SliceByRootRev return slices of vδT and we do not
-	// want to change data that is already returned to user.
+	// XXX text from old rebuild:
+	//	clone vδT before modifying it
+	//	queries such as SliceByRootRev return slices of vδT and we do not
+	//	want to change data that is already returned to user.
 	vδT []ΔTree // changes to tree keys; rev↑. covers keys ∈ tracked subset
 
 //	// set of keys(nodes) that were requested to be tracked in this tree,
@@ -515,7 +515,6 @@ func (δBtail *ΔBtail) rebuild1KeyIfNeeded(root zodb.Oid, key Key) error {
 func (δBtail *ΔBtail) rebuild1(root zodb.Oid) error {
 	// XXX locking
 	δTtail := δBtail.byRoot[root] // must be there
-//	δtrackSet, δrevSet, err := δTtail.rebuild(root, δBtail.δZtail, δBtail.db)
 	trackNew := δTtail.trackNew
 	δTtail.trackNew = blib.PPTreeSubSet{}
 	vδTnew, δtrackSet, err := vδTBuild(root, trackNew, δBtail.δZtail, δBtail.db)
@@ -531,6 +530,8 @@ func (δBtail *ΔBtail) rebuild1(root zodb.Oid) error {
 }
 
 
+// XXX move vδTBuild/vδTBuild1/Merge,Widen to after Update?
+
 // vδTBuild builds vδT from vδZ for root/tracked=trackNew.
 //
 // It returns:
@@ -732,188 +733,6 @@ func vδTMerge1Inplace(pvδT *[]ΔTree, δT ΔTree) (newRevEntry bool) {
 	return newRevEntry
 }
 
-
-/*
-// rebuild rebuilds _ΔTtail taking trackNew requests into account.
-//
-// It returns:
-//
-// - set of nodes that must be added to ΔBtail.trackSet to account for
-//   keys that becomes tracked. Note: this set is potentially wider compared to what was in .trackNew.
-// - set of revisions for which new entries in .vδT have been created.
-func (δTtail *_ΔTtail) rebuild(root zodb.Oid, δZtail *zodb.ΔTail, db *zodb.DB) (δtrackSet blib.PPTreeSubSet, δrevSet setTid, err error) {
-	defer xerr.Contextf(&err, "ΔTtail<%s> rebuild", root)
-	// XXX locking
-
-	tracefΔBtail("\nRebuild %s @%s .. @%s\n", root, δZtail.Tail(), δZtail.Head())
-	tracefΔBtail("trackNew:       %v\n", δTtail.trackNew)
-
-	trackNew := δTtail.trackNew
-	δTtail.trackNew = blib.PPTreeSubSet{}
-
-	if len(trackNew) == 0 {
-		return nil, nil, nil
-	}
-
-	δrevSet = setTid{}
-
-	// clone vδT before modifying it
-	// queries such as SliceByRootRev return slices of vδT and we do not
-	// want to change data that is already returned to user.
-	δTtail.vδT = vδTClone(δTtail.vδT)
-
-	// go backwards and merge vδT <- treediff(lo..hi/trackNew)
-	vδZ := δZtail.Data()
-	for {
-		δtkeycov := &blib.RangedKeySet{} // all keys coming into tracking set during this lo<-hi scan
-		trackNewCur := trackNew.Clone()  // trackNew adjusted as of when going to i<- entry
-		for i := len(vδZ)-1; i>=0; i-- {
-			δZ := vδZ[i]
-
-			var atPrev zodb.Tid
-			if i > 0 {
-				atPrev = vδZ[i-1].Rev
-			} else {
-				atPrev = δZtail.Tail()
-			}
-
-			δtrackNew, δtkeycov_, newRevEntry, err := δTtail.rebuild1(atPrev, δZ, trackNewCur, db)
-			if err != nil {
-				return nil, nil, err
-			}
-
-			trackNewCur.ApplyΔ(δtrackNew)
-			δtkeycov.UnionInplace(δtkeycov_)
-			if newRevEntry {
-				δrevSet.Add(δZ.Rev)
-			}
-		}
-
-		// an iteration closer to tail may turn out to add a key to the tracking set.
-		// We have to recheck all entries newer that revision for changes to that key,
-		// for example:
-		//
-		//              8        5*
-		//             / \  <-  / \
-		//            2   8    2*  7
-		//
-		//     here initial tracked set is 5*-2*. Going to earlier revision
-		//     2'th keycov range is widen from [-∞,5) to [-∞,7), so 5*-7 in
-		//     later revision have to be rechecked because 7 was added into
-		//     tracking set.
-		//
-		// Implement this via restarting from head and cycling until
-		// set of tracked keys does not grow anymore.
-		if δtkeycov.Empty() {
-			break
-		}
-
-		err := widenTrackNew(trackNew, δtkeycov, root, δZtail.Head(), db)
-		if err != nil {
-			return nil, nil, err
-		}
-	}
-
-	return trackNew, δrevSet, nil
-}
-*/
-
-/*
-// rebuild1 rebuilds δT for single δZ.
-//
-// δtrackNew/δtkeycov represents how trackNew changes when going through `atPrev <- δZ.Rev` .
-// newRevEntry indicates whether δZ.Rev was not there before in .vδT and new corresponding δT entry was created.
-func (δTtail *_ΔTtail) rebuild1(atPrev zodb.Tid, δZ zodb.ΔRevEntry, trackNew blib.PPTreeSubSet, db *zodb.DB) (δtrackNew *blib.ΔPPTreeSubSet, δtkeycov *blib.RangedKeySet, newRevEntry bool, err error) {
-	defer xerr.Contextf(&err, "rebuild1 %s<-%s", atPrev, δZ.Rev)
-
-	debugfΔBtail("\n  rebuild1 @%s <- @%s\n", atPrev, δZ.Rev)
-	debugfΔBtail("  δZ:\t%v\n", δZ.Changev)
-	debugfΔBtail("  trackNew:  %v\n", trackNew)
-	defer func() {
-		debugfΔBtail("-> δtrackNew:   %v\n", δtrackNew)
-		debugfΔBtail("-> δtkeycov:    %v\n", δtkeycov)
-		debugfΔBtail("-> newRevEntry: %v\n", newRevEntry)
-		debugfΔBtail("\n\n")
-	}()
-
-	// NOTE: keep vvv in sync with ΔBtail._Update1
-
-	δZTC, δtopsByRoot := δZConnectTracked(δZ.Changev, trackNew)
-
-	// skip opening DB connections if there is no change to this tree
-	if len(δtopsByRoot) == 0 {
-		return blib.NewΔPPTreeSubSet(), &blib.RangedKeySet{}, false, nil
-	}
-
-	if len(δtopsByRoot) != 1 {
-		panicf("BUG: δtopsByRoot has > 1 entries: %v\ntrackNew: %v\nδZ: %v", δtopsByRoot, trackNew, δZ)
-	}
-	var root  zodb.Oid
-	var δtops setOid
-	for root_, δtops_ := range δtopsByRoot {
-		root  = root_
-		δtops = δtops_
-	}
-
-
-	// open ZODB connection corresponding to "current" and "prev" states
-	txn, ctx := transaction.New(context.TODO()) // TODO - merge in cancel via ctx arg
-	defer txn.Abort()
-
-	zconnPrev, err := db.Open(ctx, &zodb.ConnOptions{At: atPrev})
-	if err != nil {
-		return nil, nil, false, err
-	}
-	zconnCurr, err := db.Open(ctx, &zodb.ConnOptions{At: δZ.Rev})
-	if err != nil {
-		return nil, nil, false, err
-	}
-
-	// diff backwards curr -> prev
-	δT, δtrack, δtkeycov, err := treediff(ctx, root, δtops, δZTC, trackNew, zconnCurr, zconnPrev)
-	if err != nil {
-		return nil, nil, false, err
-	}
-
-	debugfΔBtail("  -> root<%s>  δkv*: %v  δtrack*: %v  δtkeycov*: %v\n", root, δT, δtrack, δtkeycov)
-
-	if len(δT) == 0 { // an object might be resaved without change
-		return δtrack, δtkeycov, false, nil
-	}
-
-	// δTtail.vδT <- merge δT*
-	l := len(δTtail.vδT)
-	j := sort.Search(l, func(k int) bool {
-		return δZ.Rev <= δTtail.vδT[k].Rev
-	})
-	if j == l || δTtail.vδT[j].Rev != δZ.Rev {
-		newRevEntry = true
-		δTcurr := ΔTree{Rev: δZ.Rev, KV: map[Key]ΔValue{}}
-		// insert(@j, δTcurr)
-		δTtail.vδT = append(δTtail.vδT[:j],
-				    append([]ΔTree{δTcurr},
-				    δTtail.vδT[j:]...)...)
-	}
-	δTcurr := δTtail.vδT[j]
-
-	for k, δv := range δT {
-		// the diff was backward; δTtail entries are with diff forward
-		δv.New, δv.Old = δv.Old, δv.New
-
-		δv_, already := δTcurr.KV[k]
-		if already {
-			if δv != δv_ {
-				panicf("[%v] inconsistent δv:\nδTcurr: %v\nδT:  %v", k, δTcurr, δT)
-			}
-		} else {
-			δTcurr.KV[k] = δv
-		}
-	}
-
-	return δtrack, δtkeycov, newRevEntry, nil
-}
-*/
-
 // widenTrackNew widens trackNew to cover δtkeycov.
 func widenTrackNew(trackNew blib.PPTreeSubSet, δtkeycov *blib.RangedKeySet, root zodb.Oid, at zodb.Tid, db *zodb.DB) (err error) {
 	defer xerr.Contextf(&err, "widenTrackNew tree<%s> @%s +%s", root, at, δtkeycov)
@@ -976,15 +795,13 @@ func (δBtail *ΔBtail) Update(δZ *zodb.EventCommit) (_ ΔB, err error) {
 			if err != nil {
 				return ΔB{}, err
 			}
-			// XXX vvv kill?
+			// XXX kill vvv check?
 			if !δTtail.trackNew.Empty() {
 				panicf("BUG: ΔBtail.Update: ΔTtail<%s>.trackNew != ø after _Update1", root)
 			}
-//			δTtail.trackNew = trackNew
 
 			// NOTE we cannot skip computing diff for HEAD~..HEAD
 			// even after _Update1 because _Update1 was working with different trackNew.
-//			δtrackSet, δrevSet, err := δTtail.rebuild(root, δBtail.δZtail, δBtail.db)
 			vδTnew, δtrackSet, err := vδTBuild(root, trackNew, δBtail.δZtail, δBtail.db)
 			if err != nil {
 				return ΔB{}, err