New data APIs 16 (final?!): introduce non-cacheable components (#6037)

Make it possible to not cache some components, all while pretending
really hard that they've been cached.

- Related: #5974 

---

Part of a PR series to completely revamp the data APIs in preparation
for the removal of instance keys and the introduction of promises:
- #5573
- #5574
- #5581
- #5605
- #5606
- #5633
- #5673
- #5679
- #5687
- #5755
- #5990
- #5992
- #5993 
- #5994
- #6035
- #6036
- #6037

Builds on top of the static data PR series:
- #5534

crates/re_query/src/latest_at/query.rs

@@ -33,12 +33,19 @@ impl Caches {
 
         for component_name in component_names {
             let key = CacheKey::new(entity_path.clone(), query.timeline(), component_name);
-            let cache = Arc::clone(
-                self.latest_at_per_cache_key
-                    .write()
-                    .entry(key.clone())
-                    .or_insert_with(|| Arc::new(RwLock::new(LatestAtCache::new(key.clone())))),
-            );
+
+            let cache = if crate::cacheable(component_name) {
+                Arc::clone(
+                    self.latest_at_per_cache_key
+                        .write()
+                        .entry(key.clone())
+                        .or_insert_with(|| Arc::new(RwLock::new(LatestAtCache::new(key.clone())))),
+                )
+            } else {
+                // If the component shouldn't be cached, simply instantiate a new cache for it.
+                // It will be dropped when the user is done with it.
+                Arc::new(RwLock::new(LatestAtCache::new(key.clone())))
+            };
 
             let mut cache = cache.write();
             cache.handle_pending_invalidation();

crates/re_query/src/lib.rs

@@ -117,3 +117,34 @@ impl From<(RangeQuery, RangeResults)> for Results {
         Self::Range(query, results)
     }
 }
+
+// ---
+
+/// Returns `true` if the specified `component_name` can be cached.
+///
+/// Used internally to avoid unnecessarily caching components that are already cached in other
+/// places, for historical reasons.
+pub fn cacheable(component_name: re_types::ComponentName) -> bool {
+    use std::sync::OnceLock;
+    static NOT_CACHEABLE: OnceLock<re_types::ComponentNameSet> = OnceLock::new();
+
+    use re_types_core::Loggable as _;
+    let not_cacheable = NOT_CACHEABLE.get_or_init(|| {
+        [
+            // TODO(#5303): instance keys are on their way out anyhow.
+            re_types::components::InstanceKey::name(),
+            // TODO(#5974): tensors might already be cached in the ad-hoc JPEG cache, we don't
+            // want yet another copy.
+            re_types::components::TensorData::name(),
+            // TODO(#5974): meshes are already cached in the ad-hoc mesh cache, we don't
+            // want yet another copy.
+            re_types::components::MeshProperties::name(),
+            // TODO(#5974): blobs are used for assets, which are themselves already cached in
+            // the ad-hoc mesh cache -- we don't want yet another copy.
+            re_types::components::Blob::name(),
+        ]
+        .into()
+    });
+
+    !component_name.is_indicator_component() && !not_cacheable.contains(&component_name)
+}

crates/re_query/src/range/query.rs

@@ -33,12 +33,18 @@ impl Caches {
         for component_name in component_names {
             let key = CacheKey::new(entity_path.clone(), query.timeline(), component_name);
 
-            let cache = Arc::clone(
-                self.range_per_cache_key
-                    .write()
-                    .entry(key.clone())
-                    .or_insert_with(|| Arc::new(RwLock::new(RangeCache::new(key.clone())))),
-            );
+            let cache = if crate::cacheable(component_name) {
+                Arc::clone(
+                    self.range_per_cache_key
+                        .write()
+                        .entry(key.clone())
+                        .or_insert_with(|| Arc::new(RwLock::new(RangeCache::new(key.clone())))),
+                )
+            } else {
+                // If the component shouldn't be cached, simply instantiate a new cache for it.
+                // It will be dropped when the user is done with it.
+                Arc::new(RwLock::new(RangeCache::new(key.clone())))
+            };
 
             let mut cache = cache.write();
             cache.handle_pending_invalidation();