Correctly handle the cache in the presence of SPARQL UPDATE

src/engine/Operation.cpp

@@ -176,7 +176,7 @@ ProtoResult Operation::runComputation(const ad_utility::Timer& timer,
 // _____________________________________________________________________________
 CacheValue Operation::runComputationAndPrepareForCache(
     const ad_utility::Timer& timer, ComputationMode computationMode,
-    const std::string& cacheKey, bool pinned) {
+    const QueryCacheKey& cacheKey, bool pinned) {
   auto& cache = _executionContext->getQueryTreeCache();
   auto result = runComputation(timer, computationMode);
   if (!result.isFullyMaterialized() &&
@@ -233,7 +233,8 @@ std::shared_ptr<const Result> Operation::getResult(
     signalQueryUpdate();
   }
   auto& cache = _executionContext->getQueryTreeCache();
-  const string cacheKey = getCacheKey();
+  const QueryCacheKey cacheKey = {getCacheKey(),
+                                  &_executionContext->locatedTriplesSnapshot()};
   const bool pinFinalResultButNotSubtrees =
       _executionContext->_pinResult && isRoot;
   const bool pinResult =
@@ -453,8 +454,8 @@ void Operation::createRuntimeInfoFromEstimates(
   }
   _runtimeInfo->multiplicityEstimates_ = multiplicityEstimates;
 
-  auto cachedResult =
-      _executionContext->getQueryTreeCache().getIfContained(getCacheKey());
+  auto cachedResult = _executionContext->getQueryTreeCache().getIfContained(
+      {getCacheKey(), &locatedTriplesSnapshot()});
   if (cachedResult.has_value()) {
     const auto& [resultPointer, cacheStatus] = cachedResult.value();
     _runtimeInfo->cacheStatus_ = cacheStatus;

src/engine/Operation.h

@@ -307,7 +307,7 @@ class Operation {
   // into the cache.
   CacheValue runComputationAndPrepareForCache(const ad_utility::Timer& timer,
                                               ComputationMode computationMode,
-                                              const std::string& cacheKey,
+                                              const QueryCacheKey& cacheKey,
                                               bool pinned);
 
   // Create and store the complete runtime information for this operation after

src/engine/QueryExecutionContext.h

@@ -61,11 +61,23 @@ class CacheValue {
   };
 };
 
+struct QueryCacheKey {
+  std::string key_;
+  const LocatedTriplesSnapshot* locatedTriplesSnapshotKey_;
+
+  bool operator==(const QueryCacheKey&) const = default;
+
+  template <typename H>
+  friend H AbslHashValue(H h, const QueryCacheKey& key) {
+    return H::combine(std::move(h), key.key_, key.locatedTriplesSnapshotKey_);
+  }
+};
+
 // Threadsafe LRU cache for (partial) query results, that
 // checks on insertion, if the result is currently being computed
 // by another query.
 using QueryResultCache = ad_utility::ConcurrentCache<
-    ad_utility::LRUCache<string, CacheValue, CacheValue::SizeGetter>>;
+    ad_utility::LRUCache<QueryCacheKey, CacheValue, CacheValue::SizeGetter>>;
 
 // Execution context for queries.
 // Holds references to index and engine, implements caching.

src/engine/QueryExecutionTree.cpp

@@ -125,7 +125,8 @@ void QueryExecutionTree::readFromCache() {
     return;
   }
   auto& cache = qec_->getQueryTreeCache();
-  auto res = cache.getIfContained(getCacheKey());
+  auto res =
+      cache.getIfContained({getCacheKey(), &(qec_->locatedTriplesSnapshot())});
   if (res.has_value()) {
     cachedResult_ = res->_resultPointer->resultTablePtr();
   }

src/engine/Server.cpp

@@ -915,6 +915,12 @@
             << std::endl;
   LOG(DEBUG) << "Runtime Info:\n"
              << qet.getRootOperation()->runtimeInfo().toString() << std::endl;
+
+  // Clear the cache, because all new queries won't benefit from the old cached
+  // values, which have been invalidated by the UPDATE operation.
+  // TODO<joka921> Should we do this before or after the above logging?.
+  // Or even only after we have reported the update as successful?
+  cache_.clearAll();
 }
 
 // ____________________________________________________________________________

test/OperationTest.cpp

@@ -523,6 +523,13 @@ TEST(Operation, verifyLimitIsProperlyAppliedAndUpdatesRuntimeInfoCorrectly) {
   expectRtiHasDimensions(childRti, 2, 3);
 }
 
+namespace {
+QueryCacheKey toCacheKey(std::string s) {
+  return {std::move(s), reinterpret_cast<const LocatedTriplesSnapshot*>(
+                            std::intptr_t{102394857})};
+}
+}  // namespace
+
 // _____________________________________________________________________________
 TEST(Operation, ensureLazyOperationIsCachedIfSmallEnough) {
   auto qec = getQec();
@@ -536,14 +543,15 @@ TEST(Operation, ensureLazyOperationIsCachedIfSmallEnough) {
   ad_utility::Timer timer{ad_utility::Timer::InitialStatus::Started};
 
   auto cacheValue = valuesForTesting.runComputationAndPrepareForCache(
-      timer, ComputationMode::LAZY_IF_SUPPORTED, "test", false);
-  EXPECT_FALSE(qec->getQueryTreeCache().cacheContains("test"));
+      timer, ComputationMode::LAZY_IF_SUPPORTED, toCacheKey("test"), false);
+  EXPECT_FALSE(qec->getQueryTreeCache().cacheContains(toCacheKey("test")));
 
   for ([[maybe_unused]] Result::IdTableVocabPair& _ :
        cacheValue.resultTable().idTables()) {
   }
 
-  auto aggregatedValue = qec->getQueryTreeCache().getIfContained("test");
+  auto aggregatedValue =
+      qec->getQueryTreeCache().getIfContained(toCacheKey("test"));
   ASSERT_TRUE(aggregatedValue.has_value());
 
   ASSERT_TRUE(aggregatedValue.value()._resultPointer);
@@ -588,15 +596,15 @@ TEST(Operation, checkLazyOperationIsNotCachedIfTooLarge) {
   qec->getQueryTreeCache().setMaxSizeSingleEntry(1_B);
 
   auto cacheValue = valuesForTesting.runComputationAndPrepareForCache(
-      timer, ComputationMode::LAZY_IF_SUPPORTED, "test", false);
-  EXPECT_FALSE(qec->getQueryTreeCache().cacheContains("test"));
+      timer, ComputationMode::LAZY_IF_SUPPORTED, toCacheKey("test"), false);
+  EXPECT_FALSE(qec->getQueryTreeCache().cacheContains(toCacheKey("test")));
   qec->getQueryTreeCache().setMaxSizeSingleEntry(originalSize);
 
   for ([[maybe_unused]] Result::IdTableVocabPair& _ :
        cacheValue.resultTable().idTables()) {
   }
 
-  EXPECT_FALSE(qec->getQueryTreeCache().cacheContains("test"));
+  EXPECT_FALSE(qec->getQueryTreeCache().cacheContains(toCacheKey("test")));
 }
 
 // _____________________________________________________________________________
@@ -612,12 +620,12 @@ TEST(Operation, checkLazyOperationIsNotCachedIfUnlikelyToFitInCache) {
   ad_utility::Timer timer{ad_utility::Timer::InitialStatus::Started};
 
   auto cacheValue = valuesForTesting.runComputationAndPrepareForCache(
-      timer, ComputationMode::LAZY_IF_SUPPORTED, "test", false);
-  EXPECT_FALSE(qec->getQueryTreeCache().cacheContains("test"));
+      timer, ComputationMode::LAZY_IF_SUPPORTED, toCacheKey("test"), false);
+  EXPECT_FALSE(qec->getQueryTreeCache().cacheContains(toCacheKey("test")));
 
   for ([[maybe_unused]] Result::IdTableVocabPair& _ :
        cacheValue.resultTable().idTables()) {
   }
 
-  EXPECT_FALSE(qec->getQueryTreeCache().cacheContains("test"));
+  EXPECT_FALSE(qec->getQueryTreeCache().cacheContains(toCacheKey("test")));
 }