@Nullable private byte[] computeQueryCacheKey() { if ((populateCache || useCache) // implies strategy != null && !isBySegment) { // explicit bySegment queries are never cached assert strategy != null; return strategy.computeCacheKey(query); } else { return null; } }
private Sequence<T> deserializeResults(final byte[] cachedResult, CacheStrategy strategy, String resultSetId) { if (cachedResult == null) { log.error("Cached result set is null"); } final Function<Object, T> pullFromCacheFunction = strategy.pullFromCache(true); final TypeReference<Object> cacheObjectClazz = strategy.getCacheObjectClazz(); //Skip the resultsetID and its length bytes Sequence<T> cachedSequence = Sequences.simple(() -> { try { int resultOffset = Integer.BYTES + resultSetId.length(); return objectMapper.readValues( objectMapper.getFactory().createParser( cachedResult, resultOffset, cachedResult.length - resultOffset ), cacheObjectClazz ); } catch (IOException e) { throw new RE(e, "Failed to retrieve results from cache for query ID [%s]", query.getId()); } }); return Sequences.map(cachedSequence, pullFromCacheFunction); }
default Function<T, CacheType> prepareForSegmentLevelCache() { return prepareForCache(false); }
final Function<Object, T> pullFromCacheFunction = strategy.pullFromSegmentLevelCache(); final TypeReference<Object> cacheObjectClazz = strategy.getCacheObjectClazz(); for (Pair<Interval, byte[]> cachedResultPair : cachedResults) { final byte[] cachedResult = cachedResultPair.rhs;
Object preparedValue = strategy.prepareForSegmentLevelCache().apply(result1); strategy.getCacheObjectClazz() ); Result<TimeseriesResultValue> fromCacheResult = strategy.pullFromSegmentLevelCache().apply(fromCacheValue); Object preparedResultLevelCacheValue = strategy.prepareForCache(true).apply(result2); Object fromResultLevelCacheValue = objectMapper.readValue( objectMapper.writeValueAsBytes(preparedResultLevelCacheValue), strategy.getCacheObjectClazz() ); Result<TimeseriesResultValue> fromResultLevelCacheRes = strategy.pullFromCache(true).apply(fromResultLevelCacheValue); Assert.assertEquals(result2, fromResultLevelCacheRes);
cacheId, segmentDescriptor, strategy.computeCacheKey(query) ); } else { final Function cacheFn = strategy.pullFromSegmentLevelCache(); final byte[] cachedResult = cache.get(key); if (cachedResult != null) { final TypeReference cacheObjectClazz = strategy.getCacheObjectClazz(); final Function cacheFn = strategy.prepareForSegmentLevelCache(); return cachePopulator.wrap(base.run(queryPlus, responseContext), value -> cacheFn.apply(value), cache, key); } else {
Object preparedValue = strategy.prepareForSegmentLevelCache().apply( result ); Object fromCacheValue = objectMapper.readValue( objectMapper.writeValueAsBytes(preparedValue), strategy.getCacheObjectClazz() ); Result<TimeBoundaryResultValue> fromCacheResult = strategy.pullFromSegmentLevelCache().apply(fromCacheValue);
cacheId, segmentDescriptor, cacheStrategy.computeCacheKey(query) ); Assert.assertNotNull(cacheValue); Function<Object, Result> fn = cacheStrategy.pullFromSegmentLevelCache(); List<Result> cacheResults = Lists.newArrayList( Iterators.transform( objectMapper.readValues( objectMapper.getFactory().createParser(cacheValue), cacheStrategy.getCacheObjectClazz() ), fn
final String cacheKeyStr = StringUtils.fromUtf8(strategy.computeCacheKey(query)); final byte[] cachedResultSet = fetchResultsFromResultLevelCache(cacheKeyStr); String existingResultSetId = extractEtagFromResults(cachedResultSet); return resultFromClient; final Function<T, Object> cacheFn = strategy.prepareForCache(true);
cacheId, segmentDescriptor, cacheStrategy.computeCacheKey(query) ); cache.put(cacheKey, toByteArray(Iterables.transform(expectedResults, cacheStrategy.prepareForSegmentLevelCache())));
default Function<CacheType, T> pullFromSegmentLevelCache() { return pullFromCache(false); } }
responseContext ); final Function<T, Object> cacheFn = strategy.prepareForSegmentLevelCache();
public static <T> boolean useCacheOnBrokers( Query<T> query, CacheStrategy<T, Object, Query<T>> strategy, CacheConfig cacheConfig ) { return useCache(query, strategy, cacheConfig) && strategy.isCacheable(query, false); }
Object preparedValue = strategy.prepareForSegmentLevelCache().apply( result1 ); Object fromCacheValue = objectMapper.readValue( objectMapper.writeValueAsBytes(preparedValue), strategy.getCacheObjectClazz() ); Result<TopNResultValue> fromCacheResult = strategy.pullFromSegmentLevelCache().apply(fromCacheValue); Object preparedResultCacheValue = strategy.prepareForCache(true).apply( result2 ); strategy.getCacheObjectClazz() ); Result<TopNResultValue> fromResultCacheResult = strategy.pullFromCache(true).apply(fromResultCacheValue); Assert.assertEquals(result2, fromResultCacheResult);
byte[] actualKey = strategy.computeCacheKey(query); Assert.assertArrayEquals(expectedKey, actualKey); ); Object preparedValue = strategy.prepareForSegmentLevelCache().apply(result); strategy.getCacheObjectClazz() ); SegmentAnalysis fromCacheResult = strategy.pullFromSegmentLevelCache().apply(fromCacheValue);
); Object preparedValue = strategy.prepareForSegmentLevelCache().apply( result ); Object fromCacheValue = objectMapper.readValue( objectMapper.writeValueAsBytes(preparedValue), strategy.getCacheObjectClazz() ); Result<SearchResultValue> fromCacheResult = strategy.pullFromSegmentLevelCache().apply(fromCacheValue);
final Function<Object, T> pullFromCacheFunction = strategy.pullFromSegmentLevelCache(); final TypeReference<Object> cacheObjectClazz = strategy.getCacheObjectClazz(); for (Pair<Interval, byte[]> cachedResultPair : cachedResults) { final byte[] cachedResult = cachedResultPair.rhs;
final String cacheKeyStr = StringUtils.fromUtf8(strategy.computeCacheKey(query)); final byte[] cachedResultSet = fetchResultsFromResultLevelCache(cacheKeyStr); String existingResultSetId = extractEtagFromResults(cachedResultSet); return resultFromClient; final Function<T, Object> cacheFn = strategy.prepareForCache(true);
default Function<CacheType, T> pullFromSegmentLevelCache() { return pullFromCache(false); } }
responseContext ); final Function<T, Object> cacheFn = strategy.prepareForSegmentLevelCache();