Add count of exclusively covered digests to each ignore rule

golden/go/ignore/sqlignorestore.go

 package ignore
 
 import (
         "fmt"
         "net/url"
         "sync"
         "time"
 
         "github.com/skia-dev/glog"
 
         "go.skia.org/infra/go/database"
         "go.skia.org/infra/go/util"
         "go.skia.org/infra/golden/go/expstorage"
         "go.skia.org/infra/golden/go/types"
 )
 
 type SQLIgnoreStore struct {
-        vdb        *database.VersionedDB
-        mutex      sync.Mutex
-        revision   int64
-        tileStream <-chan *types.TilePair
-        expStore   expstorage.ExpectationsStore
+        vdb          *database.VersionedDB
+        mutex        sync.Mutex
+        revision     int64
+        tileStream   <-chan *types.TilePair
+        lastTilePair *types.TilePair
+        expStore     expstorage.ExpectationsStore
 }
 
 // NewSQLIgnoreStore creates a new SQL based IgnoreStore.
 //   vdb - database to connect to.
 //   expStore - expectations store needed to cound the untriaged digests per rule.
 //   tileStream - continously provides an updated copy of the current tile.
 func NewSQLIgnoreStore(vdb *database.VersionedDB, expStore expstorage.ExpectationsStore, tileStream <-chan *types.TilePair) IgnoreStore {
         ret := &SQLIgnoreStore{
                 vdb:        vdb,
                 tileStream: tileStream,
@@ skipping 93 matching lines @@
         ignoreMatcher, err := m.BuildRuleMatcher()
         if err != nil {
                 return err
         }
 
         // Get the next tile.
         var tilePair *types.TilePair = nil
         select {
         case tilePair = <-m.tileStream:
         default:
+                tilePair = m.lastTilePair
         }
         if tilePair == nil {
                 return fmt.Errorf("No tile available to count ignores")
         }
+        m.lastTilePair = tilePair
 
         // Count the untriaged digests in HEAD.
+        // matchingDigests[rule.ID]map[digest]bool
         matchingDigests := make(map[int]map[string]bool, len(rules))
+        rulesByDigest := map[string]map[int]bool{}
         for _, trace := range tilePair.TileWithIgnores.Traces {
                 gTrace := trace.(*types.GoldenTrace)
                 if matchRules, ok := ignoreMatcher(gTrace.Params_); ok {
                         testName := gTrace.Params_[types.PRIMARY_KEY_FIELD]
-                        if digest := gTrace.LastDigest(); digest != "" && (exp.Classification(testName, digest) == types.UNTRIAGED) {
+                        if digest := gTrace.LastDigest(); digest != types.MISSING_DIGEST && (exp.Classification(testName, digest) == types.UNTRIAGED) {
                                 k := testName + ":" + digest
                                 for _, r := range matchRules {
+                                        // Add the digest to all matching rules.
                                         if t, ok := matchingDigests[r.ID]; ok {
                                                 t[k] = true
                                         } else {
                                                 matchingDigests[r.ID] = map[string]bool{k: true}
                                         }
+
+                                        // Add the rule to the test-digest.
+                                        if t, ok := rulesByDigest[k]; ok {
+                                                t[r.ID] = true
+                                        } else {
+                                                rulesByDigest[k] = map[int]bool{r.ID: true}
+                                        }
                                 }
                         }
                 }
         }
 
         for _, r := range rules {
                 r.Count = len(matchingDigests[r.ID])
+                r.ExclusiveCount = 0
+                for testDigestKey := range matchingDigests[r.ID] {
+                        // If exactly this one rule matches then account for it.
+                        if len(rulesByDigest[testDigestKey]) == 1 {
+                                r.ExclusiveCount++
+                        }
+                }
         }
         return nil
 }
 
 // Delete, see IgnoreStore interface.
 func (m *SQLIgnoreStore) Delete(id int, userId string) (int, error) {
         stmt := "DELETE FROM ignorerule WHERE id=?"
         ret, err := m.vdb.DB.Exec(stmt, id)
         if err != nil {
                 return 0, err
@@ skipping 40 matching lines @@
 
                 for ruleIdx, rule := range ignoreRules {
                         if rule.IsMatch(params) {
                                 result = append(result, rulesList[ruleIdx])
                         }
                 }
 
                 return result, len(result) > 0
         }, nil
 }