Method GetBatch

pkg/localcache/lru/lru_lazy.go:91–152

(keys []K, fetch func(keys []K) (map[K]V, error))

}

func (x *LazyLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error) {
	var (
		err  error
		once sync.Once
	)

	res := make(map[K]V)
	queries := make([]K, 0, len(keys))

	for _, key := range keys {
		x.lock.Lock()
		v, ok := x.core.Get(key)
		x.lock.Unlock()
		if ok {
			v.lock.Lock()
			expires, value, err1 := v.expires, v.value, v.err
			v.lock.Unlock()
			if expires != 0 && expires > time.Now().UnixMilli() {
				x.target.IncrGetHit()
				res[key] = value
				if err1 != nil {
					once.Do(func() {
						err = err1
					})
				}
				continue
			}
		}
		queries = append(queries, key)
	}

	if len(queries) == 0 {
		return res, err
	}

	values, fetchErr := fetch(queries)
	if fetchErr != nil {
		once.Do(func() {
			err = fetchErr
		})
	}

	for key, val := range values {
		v := &lazyLruItem[V]{}
		v.value = val

		if err == nil {
			v.expires = time.Now().Add(x.successTTL).UnixMilli()
			x.target.IncrGetSuccess()
		} else {
			v.expires = time.Now().Add(x.failedTTL).UnixMilli()
			x.target.IncrGetFailed()
		}

		x.lock.Lock()
		x.core.Add(key, v)
		x.lock.Unlock()
		res[key] = val