minor refactor

Author: darkcoderrises

posting/list.go

@@ -321,10 +321,6 @@ func NewPosting(t *pb.DirectedEdge) *pb.Posting {
 	return p
 }
 
-func HasDeleteAll(mpost *pb.Posting) bool {
-	return hasDeleteAll(mpost)
-}
-
 func hasDeleteAll(mpost *pb.Posting) bool {
 	return mpost.Op == Del && bytes.Equal(mpost.Value, []byte(x.Star)) && len(mpost.LangTag) == 0
 }

posting/lists.go

@@ -157,7 +157,7 @@ func (lc *LocalCache) getSingleInternal(key []byte, readFromDisk bool) (*List, e
 		lc.RLock()
 		defer lc.RUnlock()
 		if lc.plists == nil {
-			pl, err, _ := GetSingleValueForKey(key, lc.startTs)
+			pl, err := GetSingleValueForKey(key, lc.startTs)
 			return pl, err
 		}
 		return nil, nil
@@ -173,27 +173,23 @@ func (lc *LocalCache) getSingleInternal(key []byte, readFromDisk bool) (*List, e
 	}
 
 	var pl *List
-	var k int
 	var err error
 	if readFromDisk {
-		pl, err, k = GetSingleValueForKey(key, lc.startTs)
+		pl, err = GetSingleValueForKey(key, lc.startTs)
 	} else {
 		pl = &List{
 			key:   key,
 			plist: new(pb.PostingList),
 		}
 	}
 
-	fmt.Println(k)
-
 	// If we just brought this posting list into memory and we already have a delta for it, let's
 	// apply it before returning the list.
 	lc.RLock()
 	if delta, ok := lc.deltas[skey]; ok && len(delta) > 0 {
 		pl.setMutation(lc.startTs, delta)
 	}
 	lc.RUnlock()
-	fmt.Println("Here6")
 	return pl, err
 }
 

posting/mvcc.go

@@ -457,7 +457,7 @@ func ReadPostingList(key []byte, it *badger.Iterator) (*List, error) {
 	return l, nil
 }
 
-func GetSingleValueForKey(key []byte, readTs uint64) (*List, error, int) {
+func GetSingleValueForKey(key []byte, readTs uint64) (*List, error) {
 	cachedVal, ok := lCache.Get(key)
 	if ok {
 		l, ok := cachedVal.(*List)
@@ -477,25 +477,23 @@ func GetSingleValueForKey(key []byte, readTs uint64) (*List, error, int) {
 				}
 			}
 			l.RUnlock()
-			return lCopy, nil, 0
+			return lCopy, nil
 		}
 	}
 
 	if pstore.IsClosed() {
-		return nil, badger.ErrDBClosed, 0
+		return nil, badger.ErrDBClosed
 	}
 
 	l := new(List)
 	l.key = key
 	l.plist = new(pb.PostingList)
 
-	//fmt.Println("KEY:", key)
 	txn := pstore.NewTransactionAt(readTs, false)
 	item, err := txn.Get(key)
 	if err != nil {
-		return l, err, 0
+		return l, err
 	}
-	k := 0
 
 	l.maxTs = x.Max(l.maxTs, item.Version())
 
@@ -504,7 +502,7 @@ func GetSingleValueForKey(key []byte, readTs uint64) (*List, error, int) {
 		l.minTs = item.Version()
 	case BitCompletePosting:
 		if err := unmarshalOrCopy(l.plist, item); err != nil {
-			return l, nil, k
+			return l, nil
 		}
 		l.minTs = item.Version()
 
@@ -527,11 +525,11 @@ func GetSingleValueForKey(key []byte, readTs uint64) (*List, error, int) {
 			return nil
 		})
 		if err != nil {
-			return l, nil, k
+			return l, nil
 		}
 	}
 
-	return l, nil, k
+	return l, nil
 }
 
 func getNew(key []byte, pstore *badger.DB, readTs uint64) (*List, error) {

worker/task.go

@@ -400,27 +400,25 @@ func (qs *queryState) handleValuePostings(ctx context.Context, args funcArgs) er
 
 			if !getMultiplePosting {
 				pl, _ := qs.cache.GetSinglePosting(key)
-				if pl != nil {
-					vals = make([]types.Val, len(pl.Postings))
-					for i, p := range pl.Postings {
-						vals[i] = types.Val{
-							Tid:   types.TypeID(p.ValType),
-							Value: p.Value,
-						}
-
-						// TODO Apply facet tree before
-						if q.FacetParam != nil {
-							fcs.FacetsList = append(fcs.FacetsList, &pb.Facets{Facets: facets.CopyFacets(p.Facets, q.FacetParam)})
-						}
-					}
-				}
-				if pl == nil || len(vals) == 0 {
+				if pl == nil || len(pl.Postings) == 0 {
 					out.UidMatrix = append(out.UidMatrix, &pb.List{})
 					out.FacetMatrix = append(out.FacetMatrix, &pb.FacetsList{})
 					out.ValueMatrix = append(out.ValueMatrix,
 						&pb.ValueList{Values: []*pb.TaskValue{}})
 					continue
 				}
+				vals = make([]types.Val, len(pl.Postings))
+				for i, p := range pl.Postings {
+					vals[i] = types.Val{
+						Tid:   types.TypeID(p.ValType),
+						Value: p.Value,
+					}
+
+					// TODO Apply facet tree before
+					if q.FacetParam != nil {
+						fcs.FacetsList = append(fcs.FacetsList, &pb.Facets{Facets: facets.CopyFacets(p.Facets, q.FacetParam)})
+					}
+				}
 			} else {
 				pl, err := qs.cache.Get(key)
 				if err != nil {