diff --git a/docs/guides/README.md b/docs/guides/README.md
index 9835899cf4..44659a5be0 100644
--- a/docs/guides/README.md
+++ b/docs/guides/README.md
@@ -28,6 +28,7 @@ existing Maven project. Complete the steps in order.
 | Guide | Description |
 |-------|-------------|
 | [Write Ebean queries with query beans](writing-ebean-query-beans.md) | Step-by-step guidance for AI agents to write type-safe Ebean queries; choose the right terminal method; tune `select()` / `fetch()` / `fetchQuery()`; and project to DTOs when entity beans are not the right output |
+| [Immutable bean cache for read-only references](immutable-bean-cache.md) | Use `ImmutableBeanCache` and `ImmutableBeanCaches.loading(...)` to resolve assoc-one references in read-only/unmodifiable queries, including secondary `fetchQuery`/`fetchLazy` loads |
 
 ## Persisting & transactions
 
@@ -106,6 +107,7 @@ Key guides (fetch and follow these when performing the relevant task):
 - Maven POM setup: https://raw.githubusercontent.com/ebean-orm/ebean/HEAD/docs/guides/add-ebean-postgres-maven-pom.md
 - Database configuration: https://raw.githubusercontent.com/ebean-orm/ebean/HEAD/docs/guides/add-ebean-postgres-database-config.md
 - Write queries with query beans: https://raw.githubusercontent.com/ebean-orm/ebean/HEAD/docs/guides/writing-ebean-query-beans.md
+- Immutable bean cache for read-only references: https://raw.githubusercontent.com/ebean-orm/ebean/HEAD/docs/guides/immutable-bean-cache.md
 - Persisting and transactions: https://raw.githubusercontent.com/ebean-orm/ebean/HEAD/docs/guides/persisting-and-transactions-with-ebean.md
 - Test container setup: https://raw.githubusercontent.com/ebean-orm/ebean/HEAD/docs/guides/add-ebean-postgres-test-container.md
 - DB migration generation: https://raw.githubusercontent.com/ebean-orm/ebean/HEAD/docs/guides/add-ebean-db-migration-generation.md
diff --git a/docs/guides/immutable-bean-cache.md b/docs/guides/immutable-bean-cache.md
new file mode 100644
index 0000000000..c8481945e1
--- /dev/null
+++ b/docs/guides/immutable-bean-cache.md
@@ -0,0 +1,136 @@
+# Immutable bean cache for read-only references
+
+This guide shows how to use `ImmutableBeanCache` for read-mostly assoc-one
+references (for example `Label` references reused across many entities).
+
+Use this when you want:
+
+- fewer lazy-load SQL calls for assoc-one references via caching
+- reusable fetch-group-based loading for cache misses
+
+---
+
+## Step 1 - Build an immutable cache (typical via builder)
+
+```java
+FetchGroup<Label> fetchGroup = FetchGroup.of(Label.class)
+  .select("version")
+  .fetch("labelTexts", "locale, localeText")
+  .build();
+
+ImmutableBeanCache<Label> labelCache = ImmutableBeanCaches.builder(Label.class)
+  .loading(database, fetchGroup)
+  .maxSize(10_000)
+  .maxIdleSeconds(300)
+  .maxSecondsToLive(6_000)
+  .build();
+```
+
+`loading(...)` uses the query shape:
+
+- `select(fetchGroup)`
+- `setUnmodifiable(true)`
+- `where().idIn(ids)`
+- `findMap()`
+
+Alternative domain example:
+
+```java
+FetchGroup<Customer> customerGroup = FetchGroup.of(Customer.class)
+  .select("name,version")
+  .fetch("billingAddress", "line1,city")
+  .fetch("shippingAddress", "line1,city")
+  .build();
+
+ImmutableBeanCache<Customer> customerCache = ImmutableBeanCaches.builder(Customer.class)
+  .loading(database, customerGroup)
+  .build();
+```
+
+---
+
+## Step 2 - Attach cache to the root query
+
+```java
+AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+  .setId(id)
+  .setUnmodifiable(true)
+  .using(labelCache)
+  .findOne();
+```
+
+`using(...)` is on the root query. Ebean will use this cache for matching
+bean types when resolving references.
+
+---
+
+## Use loading helper for simple memoization
+
+If you don't need policy controls, use the shorthand helper:
+
+```java
+ImmutableBeanCache<Label> labelCache =
+  ImmutableBeanCaches.loading(Label.class, database, FetchGroup.of(Label.class, "version"));
+```
+
+With `ebean-core` on the classpath, builder policy settings are backed by core
+cache implementation (including periodic trim / eviction).
+
+---
+
+## Unmodifiable vs mutable query behavior
+
+### Unmodifiable query path
+
+`setUnmodifiable(true)` disables lazy loading. If you need association content
+in cached beans make sure that is included in the fetch group.
+
+```java
+FetchGroup<Label> withTexts = FetchGroup.of(Label.class)
+  .select("version")
+  .fetch("labelTexts", "locale, localeText")
+  .build();
+```
+
+### Mutable query path
+
+On a mutable query (no `setUnmodifiable(true)`), references populated from the
+immutable cache are still mutable beans in that object graph. Additional
+unloaded properties can still lazy load as normal.
+
+Typical pattern:
+
+1. cache serves already-loaded reference properties (for example `version`)
+2. later access to unloaded properties (for example `labelTexts`) triggers
+   normal lazy loading
+
+---
+
+## Understand secondary query behavior (`+query`, `+lazy`)
+
+When root queries execute secondary loads (`fetchQuery(...)` or `fetchLazy(...)`),
+the immutable caches configured on the root query are propagated to those
+secondary queries.
+
+That means assoc-one references resolved in secondary query paths can still hit
+the immutable cache.
+
+---
+
+## Operational note (TTL / max size)
+
+Use `ImmutableBeanCaches.builder(...)` when you need explicit TTL/max-size
+policy. `ImmutableBeanCaches.loading(...)` remains the simple helper for
+loader-based memoization.
+
+
+---
+
+## Testing checklist
+
+1. Hit / partial hit / miss behavior for `getAll(ids)`
+2. Unmodifiable path: no lazy SQL when reading loaded reference properties
+3. Mutable path: additional unloaded properties can still lazy load
+4. Secondary `fetchQuery` and `fetchLazy` paths inherit immutable caches
+5. If needed associations are in fetch group, assert no extra SQL for those
+   accesses
diff --git a/docs/guides/writing-ebean-query-beans.md b/docs/guides/writing-ebean-query-beans.md
index 44200e13c9..71bd55e028 100644
--- a/docs/guides/writing-ebean-query-beans.md
+++ b/docs/guides/writing-ebean-query-beans.md
@@ -283,6 +283,9 @@ If you are returning entity beans for read-only use, `setUnmodifiable(true)`
 should be the default recommendation. If the caller needs a mutable model or a
 serialized summary shape, choose mutable entities or DTO projection instead.
 
+If you need cached assoc-one references for unmodifiable graphs, see
+[Immutable bean cache for read-only references](immutable-bean-cache.md).
+
 ---
 
 ## Step 7 - Use `fetchQuery()` for to-many paths and `FetchGroup` for reusable query shapes
@@ -481,4 +484,5 @@ When asked to add or modify an Ebean query:
 
 - [Add Ebean Postgres Maven POM](add-ebean-postgres-maven-pom.md)
 - [Entity Bean Creation](entity-bean-creation.md)
+- [Immutable bean cache for read-only references](immutable-bean-cache.md)
 - [Ebean query docs](https://ebean.io/docs/query/)
diff --git a/ebean-api/src/main/java/io/ebean/ImmutableBeanCache.java b/ebean-api/src/main/java/io/ebean/ImmutableBeanCache.java
new file mode 100644
index 0000000000..c6cf91e615
--- /dev/null
+++ b/ebean-api/src/main/java/io/ebean/ImmutableBeanCache.java
@@ -0,0 +1,47 @@
+package io.ebean;
+
+import org.jspecify.annotations.NullMarked;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Query-scoped immutable bean cache.
+ *
+ * <p>Typical use is to attach an immutable cache to a query and let Ebean use it when
+ * resolving assoc-one references.
+ *
+ * <pre>{@code
+ * FetchGroup<Customer> customerGroup = FetchGroup.of(Customer.class)
+ *   .select("name,version")
+ *   .fetch("billingAddress", "line1,city")
+ *   .fetch("shippingAddress", "line1,city")
+ *   .build();
+ *
+ * ImmutableBeanCache<Customer> customerCache = ImmutableBeanCaches.builder(Customer.class)
+ *   .loading(database, customerGroup)
+ *   .build();
+ *
+ * Order order = database.find(Order.class)
+ *   .setId(id)
+ *   .setUnmodifiable(true)
+ *   .using(customerCache)
+ *   .findOne();
+ * }</pre>
+ *
+ * @param <T> The bean type.
+ *
+ * @see ImmutableBeanCaches#builder(Class)
+ */
+@NullMarked
+public interface ImmutableBeanCache<T> {
+
+  /**
+   * Return the bean type this cache provides values for.
+   */
+  Class<T> type();
+
+  /**
+   * Return immutable cached beans by id (loading and populating misses as needed).
+   */
+  Map<Object, T> getAll(Set<Object> ids);
+}
diff --git a/ebean-api/src/main/java/io/ebean/ImmutableBeanCaches.java b/ebean-api/src/main/java/io/ebean/ImmutableBeanCaches.java
new file mode 100644
index 0000000000..dff1e2abeb
--- /dev/null
+++ b/ebean-api/src/main/java/io/ebean/ImmutableBeanCaches.java
@@ -0,0 +1,239 @@
+package io.ebean;
+
+import org.jspecify.annotations.NullMarked;
+import io.ebean.service.SpiImmutableCacheFactory;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Utility factory methods for {@link ImmutableBeanCache}.
+ *
+ * <p>Use {@link #builder(Class)} when you want explicit cache policy controls (for example
+ * max size or TTL). Use {@link #loading(Class, Database, FetchGroup)} as a shorthand for
+ * query-loader-backed memoization.
+ *
+ * <pre>{@code
+ * FetchGroup<MyRef> fetchGroup = FetchGroup.of(MyRef.class)
+ *   .select("version")
+ *   .build();
+ *
+ * ImmutableBeanCache<MyRef> cache = ImmutableBeanCaches.builder(MyRef.class)
+ *   .loading(database, fetchGroup)
+ *   .maxSize(10_000)
+ *   .maxIdleSeconds(300)
+ *   .maxSecondsToLive(1_800)
+ *   .build();
+ * }</pre>
+ */
+@NullMarked
+public final class ImmutableBeanCaches {
+
+  private ImmutableBeanCaches() {
+  }
+
+  /**
+   * Return a builder for immutable bean caches.
+   *
+   * <pre>{@code
+   * ImmutableBeanCache<MyRef> cache = ImmutableBeanCaches.builder(MyRef.class)
+   *   .loading(database, FetchGroup.of(MyRef.class, "version"))
+   *   .build();
+   * }</pre>
+   */
+  public static <T> ImmutableCacheBuilder<T> builder(Class<T> type) {
+    SpiImmutableCacheFactory factory = XBootstrapService.immutableCacheFactory();
+    if (factory != null) {
+      return factory.builder(type);
+    }
+    return new LoadingBuilder<>(type);
+  }
+
+  /**
+   * Return a loader-backed immutable bean cache that memoizes both hits and misses.
+   *
+   * <pre>{@code
+   * ImmutableBeanCache<MyRef> cache = ImmutableBeanCaches.loading(MyRef.class, ids ->
+   *   database.find(MyRef.class)
+   *     .setUnmodifiable(true)
+   *     .where().idIn(ids)
+   *     .findMap()
+   * );
+   * }</pre>
+   *
+   * @param type   The bean type.
+   * @param loader Batch loader for unresolved ids.
+   */
+  public static <T> ImmutableBeanCache<T> loading(Class<T> type, Function<Set<Object>, Map<Object, T>> loader) {
+    return builder(type).loader(loader).build();
+  }
+
+  /**
+   * Return a query-loader-backed immutable bean cache.
+   *
+   * <pre>{@code
+   * ImmutableBeanCache<MyRef> cache = ImmutableBeanCaches.loading(
+   *   MyRef.class,
+   *   database,
+   *   FetchGroup.of(MyRef.class, "version")
+   * );
+   * }</pre>
+   */
+  public static <T> ImmutableBeanCache<T> loading(Class<T> type, Database db, FetchGroup<T> fetchGroup) {
+    return builder(type).loading(db, fetchGroup).build();
+  }
+
+  /**
+   * Return a batch loader backed by an unmodifiable query using the given fetch group.
+   */
+  public static <T> Function<Set<Object>, Map<Object, T>> queryLoader(Database db, Class<T> type, FetchGroup<T> fetchGroup) {
+    return new QueryLoader<>(type, db, fetchGroup);
+  }
+
+  private static final class QueryLoader<T> implements Function<Set<Object>, Map<Object, T>> {
+
+    private final Class<T> type;
+    private final Database db;
+    private final FetchGroup<T> fetchGroup;
+
+    QueryLoader(Class<T> type, Database db, FetchGroup<T> fetchGroup) {
+      this.type = requireNonNull(type);
+      this.db = requireNonNull(db);
+      this.fetchGroup = requireNonNull(fetchGroup);
+    }
+
+    @Override
+    public Map<Object, T> apply(Set<Object> ids) {
+      if (ids.isEmpty()) {
+        return Collections.emptyMap();
+      }
+      return db.find(type)
+        .select(fetchGroup)
+        .setUnmodifiable(true)
+        .where().idIn(ids)
+        .findMap();
+    }
+  }
+
+  private static final class LoadingBuilder<T> implements ImmutableCacheBuilder<T> {
+
+    private final Class<T> type;
+    private Function<Set<Object>, Map<Object, T>> loader;
+    private int maxSize;
+    private int maxIdleSeconds;
+    private int maxSecondsToLive;
+
+    private LoadingBuilder(Class<T> type) {
+      this.type = requireNonNull(type);
+    }
+
+    @Override
+    public ImmutableCacheBuilder<T> loader(Function<Set<Object>, Map<Object, T>> loader) {
+      this.loader = requireNonNull(loader);
+      return this;
+    }
+
+    @Override
+    public ImmutableCacheBuilder<T> loading(Database db, FetchGroup<T> fetchGroup) {
+      this.loader = new QueryLoader<>(type, db, fetchGroup);
+      return this;
+    }
+
+    @Override
+    public ImmutableCacheBuilder<T> maxSize(int maxSize) {
+      this.maxSize = maxSize;
+      return this;
+    }
+
+    @Override
+    public ImmutableCacheBuilder<T> maxIdleSeconds(int maxIdleSeconds) {
+      this.maxIdleSeconds = maxIdleSeconds;
+      return this;
+    }
+
+    @Override
+    public ImmutableCacheBuilder<T> maxSecondsToLive(int maxSecondsToLive) {
+      this.maxSecondsToLive = maxSecondsToLive;
+      return this;
+    }
+
+    @Override
+    public ImmutableBeanCache<T> build() {
+      if (loader == null) {
+        throw new IllegalStateException("No loader defined. Call loader(...) or loading(...) before build().");
+      }
+      if (maxSize > 0 || maxIdleSeconds > 0 || maxSecondsToLive > 0) {
+        throw new IllegalStateException("Cache policy options require SpiImmutableCacheFactory (ebean-core).");
+      }
+      return new LoadingCache<>(type, loader);
+    }
+  }
+
+  private static final class LoadingCache<T> implements ImmutableBeanCache<T> {
+
+    private final Class<T> type;
+    private final Function<Set<Object>, Map<Object, T>> loader;
+    private final ConcurrentHashMap<Object, T> cache = new ConcurrentHashMap<>();
+    private final Set<Object> misses = ConcurrentHashMap.newKeySet();
+
+    private LoadingCache(Class<T> type, Function<Set<Object>, Map<Object, T>> loader) {
+      this.type = requireNonNull(type);
+      this.loader = requireNonNull(loader);
+    }
+
+    @Override
+    public Class<T> type() {
+      return type;
+    }
+
+    @Override
+    public Map<Object, T> getAll(Set<Object> ids) {
+      if (ids.isEmpty()) {
+        return Collections.emptyMap();
+      }
+
+      Set<Object> loadIds = null;
+      for (Object id : ids) {
+        if (!cache.containsKey(id) && !misses.contains(id)) {
+          if (loadIds == null) {
+            loadIds = new LinkedHashSet<>();
+          }
+          loadIds.add(id);
+        }
+      }
+
+      if (loadIds != null && !loadIds.isEmpty()) {
+        Map<Object, T> loaded = loader.apply(loadIds);
+        if (loaded == null) {
+          loaded = Collections.emptyMap();
+        }
+        for (Map.Entry<Object, T> entry : loaded.entrySet()) {
+          if (entry.getValue() != null) {
+            cache.put(entry.getKey(), entry.getValue());
+          }
+        }
+        for (Object id : loadIds) {
+          if (!cache.containsKey(id)) {
+            misses.add(id);
+          }
+        }
+      }
+
+      Map<Object, T> result = new LinkedHashMap<>();
+      for (Object id : ids) {
+        T bean = cache.get(id);
+        if (bean != null) {
+          result.put(id, bean);
+        }
+      }
+      return result;
+    }
+  }
+}
diff --git a/ebean-api/src/main/java/io/ebean/ImmutableCacheBuilder.java b/ebean-api/src/main/java/io/ebean/ImmutableCacheBuilder.java
new file mode 100644
index 0000000000..df8d5ae1f9
--- /dev/null
+++ b/ebean-api/src/main/java/io/ebean/ImmutableCacheBuilder.java
@@ -0,0 +1,60 @@
+package io.ebean;
+
+import org.jspecify.annotations.NullMarked;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+
+/**
+ * Builder for creating {@link ImmutableBeanCache} instances.
+ *
+ * <pre>{@code
+ * FetchGroup<MyRef> fetchGroup = FetchGroup.of(MyRef.class)
+ *   .select("version")
+ *   .fetch("names", "locale,text")
+ *   .build();
+ *
+ * ImmutableBeanCache<MyRef> cache = ImmutableBeanCaches.builder(MyRef.class)
+ *   .loading(database, fetchGroup)
+ *   .maxSize(10_000)
+ *   .maxIdleSeconds(300)
+ *   .maxSecondsToLive(1_800)
+ *   .build();
+ * }</pre>
+ *
+ * @see ImmutableBeanCaches#builder(Class)
+ */
+@NullMarked
+public interface ImmutableCacheBuilder<T> {
+
+  /**
+   * Set the batch loader used for unresolved ids.
+   */
+  ImmutableCacheBuilder<T> loader(Function<Set<Object>, Map<Object, T>> loader);
+
+  /**
+   * Configure a query-based loader using the given database and fetch group.
+   */
+  ImmutableCacheBuilder<T> loading(Database db, FetchGroup<T> fetchGroup);
+
+  /**
+   * Configure max cache size (0 means unbounded).
+   */
+  ImmutableCacheBuilder<T> maxSize(int maxSize);
+
+  /**
+   * Configure max idle time in seconds (0 means disabled).
+   */
+  ImmutableCacheBuilder<T> maxIdleSeconds(int maxIdleSeconds);
+
+  /**
+   * Configure max time-to-live in seconds (0 means disabled).
+   */
+  ImmutableCacheBuilder<T> maxSecondsToLive(int maxSecondsToLive);
+
+  /**
+   * Build the immutable bean cache.
+   */
+  ImmutableBeanCache<T> build();
+}
diff --git a/ebean-api/src/main/java/io/ebean/QueryBuilder.java b/ebean-api/src/main/java/io/ebean/QueryBuilder.java
index c50f21e59d..7320a0d2aa 100644
--- a/ebean-api/src/main/java/io/ebean/QueryBuilder.java
+++ b/ebean-api/src/main/java/io/ebean/QueryBuilder.java
@@ -115,6 +115,11 @@ public interface QueryBuilder<SELF extends QueryBuilder<SELF, T>, T> extends Que
    */
   SELF usingTransaction(Transaction transaction);
 
+  /**
+   * Execute this query using immutable bean cache values for matching bean types.
+   */
+  SELF using(ImmutableBeanCache<?> beanCache);
+
   /**
    * Execute the query using the given connection.
    */
diff --git a/ebean-api/src/main/java/io/ebean/XBootstrapService.java b/ebean-api/src/main/java/io/ebean/XBootstrapService.java
index b0d5ad9f9d..9cab9b4a1a 100644
--- a/ebean-api/src/main/java/io/ebean/XBootstrapService.java
+++ b/ebean-api/src/main/java/io/ebean/XBootstrapService.java
@@ -14,6 +14,7 @@ public final class XBootstrapService {
   private static final SpiRawSqlService rawSqlService;
   private static final SpiProfileLocationFactory profileLocationFactory;
   private static final SpiFetchGroupService fetchGroupService;
+  private static final SpiImmutableCacheFactory immutableCacheFactory;
   private static final MetricFactory metricFactory;
   private static final SpiJsonService jsonService;
   static {
@@ -21,6 +22,7 @@ public final class XBootstrapService {
     SpiRawSqlService _raw = null;
     SpiProfileLocationFactory _profile = null;
     SpiFetchGroupService _fetch = null;
+    SpiImmutableCacheFactory _immutable = null;
     MetricFactory _metric = null;
     SpiJsonService _json = null;
     for (BootstrapService extension : ServiceLoader.load(BootstrapService.class)) {
@@ -32,6 +34,8 @@ public final class XBootstrapService {
         _profile = (SpiProfileLocationFactory)extension;
       } else if (extension instanceof SpiFetchGroupService) {
         _fetch = (SpiFetchGroupService)extension;
+      } else if (extension instanceof SpiImmutableCacheFactory) {
+        _immutable = (SpiImmutableCacheFactory) extension;
       } else if (extension instanceof MetricFactory) {
         _metric = (MetricFactory)extension;
       } else if (extension instanceof SpiJsonService) {
@@ -42,6 +46,7 @@ public final class XBootstrapService {
     rawSqlService = _raw;
     profileLocationFactory = _profile;
     fetchGroupService = _fetch;
+    immutableCacheFactory = _immutable;
     metricFactory = _metric;
     jsonService = _json;
   }
@@ -72,6 +77,10 @@ static SpiProfileLocationFactory profileLocationFactory() {
     return profileLocationFactory;
   }
 
+  static SpiImmutableCacheFactory immutableCacheFactory() {
+    return immutableCacheFactory;
+  }
+
   /**
    * Return the FetchGroup with the given select clause.
    */
diff --git a/ebean-api/src/main/java/io/ebean/service/SpiImmutableCacheFactory.java b/ebean-api/src/main/java/io/ebean/service/SpiImmutableCacheFactory.java
new file mode 100644
index 0000000000..dda4955606
--- /dev/null
+++ b/ebean-api/src/main/java/io/ebean/service/SpiImmutableCacheFactory.java
@@ -0,0 +1,14 @@
+package io.ebean.service;
+
+import io.ebean.ImmutableCacheBuilder;
+
+/**
+ * Factory for creating immutable cache builders.
+ */
+public interface SpiImmutableCacheFactory extends BootstrapService {
+
+  /**
+   * Return a new builder for the given immutable bean type.
+   */
+  <T> ImmutableCacheBuilder<T> builder(Class<T> type);
+}
diff --git a/ebean-api/src/test/java/io/ebean/ImmutableBeanCachesTest.java b/ebean-api/src/test/java/io/ebean/ImmutableBeanCachesTest.java
new file mode 100644
index 0000000000..decb6dde91
--- /dev/null
+++ b/ebean-api/src/test/java/io/ebean/ImmutableBeanCachesTest.java
@@ -0,0 +1,181 @@
+package io.ebean;
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Proxy;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class ImmutableBeanCachesTest {
+
+  @Test
+  void loading_cache_memoizes_hits_and_misses() {
+
+    AtomicInteger loadCount = new AtomicInteger();
+    AtomicReference<Set<Object>> lastLoadIds = new AtomicReference<>();
+
+    ImmutableBeanCache<String> cache = ImmutableBeanCaches.loading(String.class, ids -> {
+      loadCount.incrementAndGet();
+      lastLoadIds.set(Set.copyOf(ids));
+      Map<Object, String> map = new LinkedHashMap<>();
+      for (Object id : ids) {
+        if ("A".equals(id) || "C".equals(id)) {
+          map.put(id, "val-" + id);
+        }
+      }
+      return map;
+    });
+
+    Map<Object, String> first = cache.getAll(Set.of("A", "B", "C"));
+    assertThat(first).containsEntry("A", "val-A").containsEntry("C", "val-C");
+    assertThat(first).doesNotContainKey("B");
+    assertThat(loadCount.get()).isEqualTo(1);
+    assertThat(lastLoadIds.get()).containsExactlyInAnyOrder("A", "B", "C");
+
+    Map<Object, String> second = cache.getAll(Set.of("A", "B", "C"));
+    assertThat(second).isEqualTo(first);
+    assertThat(loadCount.get()).isEqualTo(1);
+
+    Map<Object, String> third = cache.getAll(Set.of("B", "D"));
+    assertThat(third).isEmpty();
+    assertThat(loadCount.get()).isEqualTo(2);
+    assertThat(lastLoadIds.get()).containsExactly("D");
+  }
+
+  @Test
+  void loading_withDatabaseAndFetchGroup_usesQueryLoaderFindMap() {
+
+    AtomicReference<Set<Object>> capturedIds = new AtomicReference<>();
+    AtomicBoolean unmodifiable = new AtomicBoolean();
+
+    Map<Object, String> loaded = new LinkedHashMap<>();
+    loaded.put("A", "val-A");
+    loaded.put("B", "val-B");
+
+    Object[] exprProxyRef = new Object[1];
+
+    Object expressionListProxy = Proxy.newProxyInstance(
+      getClass().getClassLoader(),
+      new Class<?>[]{ExpressionList.class},
+      (proxy, method, args) -> {
+        String name = method.getName();
+        if ("idIn".equals(name)) {
+          @SuppressWarnings("unchecked")
+          Set<Object> values = Set.copyOf((java.util.Collection<Object>) args[0]);
+          capturedIds.set(values);
+          return proxy;
+        }
+        if ("findMap".equals(name)) {
+          return loaded;
+        }
+        if ("hashCode".equals(name)) return System.identityHashCode(proxy);
+        if ("equals".equals(name)) return proxy == args[0];
+        if ("toString".equals(name)) return "expressionListProxy";
+        throw new UnsupportedOperationException(name);
+      });
+    exprProxyRef[0] = expressionListProxy;
+
+    Object queryProxy = Proxy.newProxyInstance(
+      getClass().getClassLoader(),
+      new Class<?>[]{Query.class},
+      (proxy, method, args) -> {
+        String name = method.getName();
+        if ("select".equals(name) || "setUnmodifiable".equals(name)) {
+          if ("setUnmodifiable".equals(name)) {
+            unmodifiable.set((Boolean) args[0]);
+          }
+          return proxy;
+        }
+        if ("where".equals(name)) {
+          return exprProxyRef[0];
+        }
+        if ("hashCode".equals(name)) return System.identityHashCode(proxy);
+        if ("equals".equals(name)) return proxy == args[0];
+        if ("toString".equals(name)) return "queryProxy";
+        throw new UnsupportedOperationException(name);
+      });
+
+    Database db = (Database) Proxy.newProxyInstance(
+      getClass().getClassLoader(),
+      new Class<?>[]{Database.class},
+      (proxy, method, args) -> {
+        if ("find".equals(method.getName())) {
+          assertThat(args[0]).isEqualTo(String.class);
+          return queryProxy;
+        }
+        if ("hashCode".equals(method.getName())) return System.identityHashCode(proxy);
+        if ("equals".equals(method.getName())) return proxy == args[0];
+        if ("toString".equals(method.getName())) return "dbProxy";
+        throw new UnsupportedOperationException(method.getName());
+      });
+
+    @SuppressWarnings("unchecked")
+    FetchGroup<String> fetchGroup = (FetchGroup<String>) Proxy.newProxyInstance(
+      getClass().getClassLoader(),
+      new Class<?>[]{FetchGroup.class},
+      (proxy, method, args) -> {
+        if ("hashCode".equals(method.getName())) return System.identityHashCode(proxy);
+        if ("equals".equals(method.getName())) return proxy == args[0];
+        if ("toString".equals(method.getName())) return "fetchGroupProxy";
+        throw new UnsupportedOperationException(method.getName());
+      });
+
+    ImmutableBeanCache<String> cache = ImmutableBeanCaches.loading(String.class, db, fetchGroup);
+    Map<Object, String> result = cache.getAll(Set.of("A", "B"));
+
+    assertThat(result).isEqualTo(loaded);
+    assertThat(unmodifiable).isTrue();
+    assertThat(capturedIds.get()).containsExactlyInAnyOrder("A", "B");
+  }
+
+  @Test
+  void builder_loader_buildsCache() {
+
+    AtomicInteger loadCount = new AtomicInteger();
+
+    ImmutableBeanCache<String> cache = ImmutableBeanCaches.builder(String.class)
+      .loader(ids -> {
+        loadCount.incrementAndGet();
+        Map<Object, String> map = new LinkedHashMap<>();
+        for (Object id : ids) {
+          if ("A".equals(id)) {
+            map.put(id, "val-A");
+          }
+        }
+        return map;
+      })
+      .build();
+
+    assertThat(cache.getAll(Set.of("A", "B"))).containsEntry("A", "val-A").doesNotContainKey("B");
+    assertThat(cache.getAll(Set.of("A", "B"))).containsEntry("A", "val-A").doesNotContainKey("B");
+    assertThat(loadCount.get()).isEqualTo(1);
+  }
+
+  @Test
+  void builder_withPolicy_requiresFactoryWhenUnavailable() {
+
+    if (XBootstrapService.immutableCacheFactory() != null) {
+      ImmutableBeanCache<String> cache = ImmutableBeanCaches.builder(String.class)
+        .maxSize(10)
+        .loader(ids -> Collections.emptyMap())
+        .build();
+      assertThat(cache.getAll(Set.of("A"))).isEmpty();
+      return;
+    }
+
+    assertThatThrownBy(() -> ImmutableBeanCaches.builder(String.class)
+      .maxSize(10)
+      .loader(ids -> Collections.emptyMap())
+      .build()
+    ).isInstanceOf(IllegalStateException.class)
+      .hasMessageContaining("SpiImmutableCacheFactory");
+  }
+}
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/LoadContext.java b/ebean-core/src/main/java/io/ebeaninternal/api/LoadContext.java
index c30251a100..c7194dae75 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/LoadContext.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/LoadContext.java
@@ -51,6 +51,11 @@ public interface LoadContext {
    */
   void register(String path, BeanPropertyAssocMany<?> many, BeanCollection<?> bc);
 
+  /**
+   * Register a bean as a candidate for immutable cache population.
+   */
+  void registerForImmutable(EntityBeanIntercept ebi);
+
   /**
    * Use soft-references for streaming queries, so unreachable entries can be garbage collected.
    */
@@ -60,4 +65,9 @@ public interface LoadContext {
    * Return true to include a many as a secondary query for unmodified.
    */
   boolean includeSecondary(BeanPropertyAssocMany<?> many);
+
+  /**
+   * Populate buffered entity references from immutable bean caches.
+   */
+  void populateFromImmutableCache();
 }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/api/SpiQuery.java b/ebean-core/src/main/java/io/ebeaninternal/api/SpiQuery.java
index 6e32de1541..76cbad6775 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/api/SpiQuery.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/api/SpiQuery.java
@@ -4,6 +4,7 @@
 import io.ebean.CacheMode;
 import io.ebean.CountDistinctOrder;
 import io.ebean.ExpressionList;
+import io.ebean.ImmutableBeanCache;
 import io.ebean.OrderBy;
 import io.ebean.PersistenceContextScope;
 import io.ebean.ProfileLocation;
@@ -27,6 +28,7 @@
 import java.sql.Timestamp;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /**
@@ -759,6 +761,16 @@ public static TemporalMode of(SpiQuery<?> query) {
    */
   boolean isBeanCacheGet();
 
+  /**
+   * Register immutable bean cache to use for this query execution.
+   */
+  void putImmutableBeanCache(ImmutableBeanCache<?> beanCache);
+
+  /**
+   * Return immutable bean caches configured for this query by bean type.
+   */
+  Map<Class<?>, ImmutableBeanCache<?>> immutableBeanCaches();
+
   /**
    * Return true if the query should PUT against the bean cache.
    */
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/cache/DImmutableCacheFactory.java b/ebean-core/src/main/java/io/ebeaninternal/server/cache/DImmutableCacheFactory.java
new file mode 100644
index 0000000000..9eaaf81578
--- /dev/null
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/cache/DImmutableCacheFactory.java
@@ -0,0 +1,174 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.BackgroundExecutor;
+import io.ebean.DB;
+import io.ebean.Database;
+import io.ebean.FetchGroup;
+import io.ebean.ImmutableBeanCache;
+import io.ebean.ImmutableBeanCaches;
+import io.ebean.ImmutableCacheBuilder;
+import io.ebean.cache.ServerCache;
+import io.ebean.cache.ServerCacheConfig;
+import io.ebean.cache.ServerCacheOptions;
+import io.ebean.cache.ServerCacheType;
+import io.ebean.service.SpiImmutableCacheFactory;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Function;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Core implementation of immutable cache builder factory.
+ */
+public final class DImmutableCacheFactory implements SpiImmutableCacheFactory {
+
+  private static final AtomicLong COUNTER = new AtomicLong();
+
+  @Override
+  public <T> ImmutableCacheBuilder<T> builder(Class<T> type) {
+    return new Builder<>(type);
+  }
+
+  private static final class Builder<T> implements ImmutableCacheBuilder<T> {
+
+    private final Class<T> type;
+    private Function<Set<Object>, Map<Object, T>> loader;
+    private int maxSize;
+    private int maxIdleSeconds;
+    private int maxSecondsToLive;
+    private Database database;
+
+    private Builder(Class<T> type) {
+      this.type = requireNonNull(type);
+    }
+
+    @Override
+    public ImmutableCacheBuilder<T> loader(Function<Set<Object>, Map<Object, T>> loader) {
+      this.loader = requireNonNull(loader);
+      this.database = null;
+      return this;
+    }
+
+    @Override
+    public ImmutableCacheBuilder<T> loading(Database db, FetchGroup<T> fetchGroup) {
+      this.database = requireNonNull(db);
+      this.loader = ImmutableBeanCaches.queryLoader(db, type, fetchGroup);
+      return this;
+    }
+
+    @Override
+    public ImmutableCacheBuilder<T> maxSize(int maxSize) {
+      this.maxSize = maxSize;
+      return this;
+    }
+
+    @Override
+    public ImmutableCacheBuilder<T> maxIdleSeconds(int maxIdleSeconds) {
+      this.maxIdleSeconds = maxIdleSeconds;
+      return this;
+    }
+
+    @Override
+    public ImmutableCacheBuilder<T> maxSecondsToLive(int maxSecondsToLive) {
+      this.maxSecondsToLive = maxSecondsToLive;
+      return this;
+    }
+
+    @Override
+    public ImmutableBeanCache<T> build() {
+      if (loader == null) {
+        throw new IllegalStateException("No loader defined. Call loader(...) or loading(...) before build().");
+      }
+      ServerCacheOptions options = new ServerCacheOptions();
+      options.setMaxSize(maxSize);
+      options.setMaxIdleSecs(maxIdleSeconds);
+      options.setMaxSecsToLive(maxSecondsToLive);
+
+      String cacheKey = "immutable." + type.getName() + "." + COUNTER.incrementAndGet();
+      String shortName = "im." + type.getSimpleName() + "." + COUNTER.get();
+      ServerCacheConfig config = new ServerCacheConfig(ServerCacheType.BEAN, cacheKey, shortName, options, null, null);
+      DefaultServerCache serverCache = new DefaultServerCache(new DefaultServerCacheConfig(config));
+      BackgroundExecutor executor = executor();
+      if (executor != null) {
+        serverCache.periodicTrim(executor);
+      }
+      return new ServerLoadingCache<>(type, loader, serverCache);
+    }
+
+    private BackgroundExecutor executor() {
+      try {
+        return database != null ? database.backgroundExecutor() : DB.backgroundExecutor();
+      } catch (Exception e) {
+        return null;
+      }
+    }
+  }
+
+  private static final class ServerLoadingCache<T> implements ImmutableBeanCache<T> {
+
+    private static final Object MISS = new Object();
+
+    private final Class<T> type;
+    private final Function<Set<Object>, Map<Object, T>> loader;
+    private final ServerCache cache;
+
+    private ServerLoadingCache(Class<T> type, Function<Set<Object>, Map<Object, T>> loader, ServerCache cache) {
+      this.type = type;
+      this.loader = loader;
+      this.cache = cache;
+    }
+
+    @Override
+    public Class<T> type() {
+      return type;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Map<Object, T> getAll(Set<Object> ids) {
+      if (ids.isEmpty()) {
+        return Collections.emptyMap();
+      }
+
+      Map<Object, T> result = new LinkedHashMap<>();
+      Set<Object> loadIds = null;
+      for (Object id : ids) {
+        Object value = cache.get(id);
+        if (value == null) {
+          if (loadIds == null) {
+            loadIds = new LinkedHashSet<>();
+          }
+          loadIds.add(id);
+        } else if (value != MISS) {
+          result.put(id, (T) value);
+        }
+      }
+
+      if (loadIds != null && !loadIds.isEmpty()) {
+        Map<Object, T> loaded = loader.apply(loadIds);
+        if (loaded == null) {
+          loaded = Collections.emptyMap();
+        }
+        for (Map.Entry<Object, T> entry : loaded.entrySet()) {
+          T value = entry.getValue();
+          if (value != null) {
+            cache.put(entry.getKey(), value);
+            result.put(entry.getKey(), value);
+          }
+        }
+        for (Object id : loadIds) {
+          if (!loaded.containsKey(id) || loaded.get(id) == null) {
+            cache.put(id, MISS);
+          }
+        }
+      }
+      return result;
+    }
+  }
+}
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/core/OrmQueryRequest.java b/ebean-core/src/main/java/io/ebeaninternal/server/core/OrmQueryRequest.java
index aac02b6643..55cd38f5f1 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/core/OrmQueryRequest.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/core/OrmQueryRequest.java
@@ -122,6 +122,12 @@ public void executeSecondaryQueries(boolean forEach) {
     }
   }
 
+  public void populateFromImmutableCache() {
+    if (loadContext != null) {
+      loadContext.populateFromImmutableCache();
+    }
+  }
+
   /**
    * For use with QueryIterator and secondary queries this returns the minimum
    * batch size that should be loaded before executing the secondary queries.
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelp.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelp.java
index 941dece7f0..7525318678 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelp.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelp.java
@@ -69,6 +69,8 @@ Object read(DbReadContext ctx) throws SQLException {
     Object ref = target.contextRef(pc, id, ctx.unmodifiable(), ctx.isDisableLazyLoading());
     if (!ctx.unmodifiable() && !ctx.isDisableLazyLoading()) {
       ctx.register(path, ((EntityBean) ref)._ebean_getIntercept());
+    } else {
+      ctx.registerForImmutable(((EntityBean) ref)._ebean_getIntercept());
     }
     return ref;
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefInherit.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefInherit.java
index dda19513f4..6b9ff95b82 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefInherit.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefInherit.java
@@ -56,6 +56,8 @@ Object read(DbReadContext ctx) throws SQLException {
     Object ref = desc.contextRef(pc, id, ctx.unmodifiable(), ctx.isDisableLazyLoading());
     if (!ctx.unmodifiable() && !ctx.isDisableLazyLoading()) {
       ctx.registerBeanInherit(property, ((EntityBean) ref)._ebean_getIntercept());
+    } else {
+      ctx.registerForImmutable(((EntityBean) ref)._ebean_getIntercept());
     }
     return ref;
   }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java
index 6b580119ff..693fc2c7f1 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java
@@ -468,10 +468,6 @@ public EntityType entityType() {
     return entityType;
   }
 
-  private String[] properties() {
-    return properties;
-  }
-
   public BeanProperty propertyByIndex(int pos) {
     return propertiesIndex[pos];
   }
@@ -715,14 +711,17 @@ public void metricPersistNoBatch(PersistRequest.Type type, long startNanos) {
   public void merge(EntityBean bean, EntityBean existing) {
     EntityBeanIntercept fromEbi = bean._ebean_getIntercept();
     EntityBeanIntercept toEbi = existing._ebean_getIntercept();
-    int propertyLength = toEbi.propertyLength();
-    String[] names = properties();
+    int propertyLength = Math.min(toEbi.propertyLength(), propertiesIndex.length);
     for (int i = 0; i < propertyLength; i++) {
       if (fromEbi.isLoadedProperty(i)) {
-        BeanProperty property = beanProperty(names[i]);
+        BeanProperty property = propertiesIndex[i];
+        if (property == null) {
+          property = beanProperty(fromEbi.property(i));
+        }
         if (!toEbi.isLoadedProperty(i)) {
           Object val = property.getValue(bean);
           property.setValue(existing, val);
+          toEbi.setLoadedProperty(i);
         } else if (property.isMany()) {
           property.merge(bean, existing);
         }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DbReadContext.java b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DbReadContext.java
index 5751b0793e..beb416ad41 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DbReadContext.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/deploy/DbReadContext.java
@@ -59,6 +59,11 @@ public interface DbReadContext {
    */
   void register(BeanPropertyAssocMany<?> many, BeanCollection<?> bc);
 
+  /**
+   * Register a bean as a candidate for immutable cache population.
+   */
+  void registerForImmutable(EntityBeanIntercept ebi);
+
   /**
    * Set back the bean that has just been loaded with its id.
    */
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBeanContext.java b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBeanContext.java
index 28d38b6641..4a5f429357 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBeanContext.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadBeanContext.java
@@ -79,6 +79,21 @@ void register(EntityBeanIntercept ebi) {
     currentBuffer.add(ebi);
   }
 
+  BeanDescriptor<?> descriptor() {
+    return desc;
+  }
+
+  Set<EntityBeanIntercept> bufferedBeans() {
+    if (bufferList != null) {
+      Set<EntityBeanIntercept> beans = new HashSet<>();
+      for (LoadBuffer loadBuffer : bufferList) {
+        beans.addAll(loadBuffer.batch);
+      }
+      return beans;
+    }
+    return new HashSet<>(currentBuffer.batch);
+  }
+
   private LoadBuffer createBuffer(int size) {
     LoadBuffer buffer = new LoadBuffer(this, size);
     if (bufferList != null) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadContext.java b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadContext.java
index feac1ab558..dbe826a2f5 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadContext.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/loadcontext/DLoadContext.java
@@ -1,6 +1,7 @@
 package io.ebeaninternal.server.loadcontext;
 
 import io.ebean.CacheMode;
+import io.ebean.ImmutableBeanCache;
 import io.ebean.ProfileLocation;
 import io.ebean.bean.*;
 import io.ebeaninternal.api.*;
@@ -20,7 +21,19 @@ public final class DLoadContext implements LoadContext {
 
   private final SpiEbeanServer ebeanServer;
   private final BeanDescriptor<?> rootDescriptor;
+  /**
+   * Path based contexts used for +query secondary query execution.
+   */
   private final Map<String, DLoadBeanContext> beanMap = new HashMap<>();
+  /**
+   * Type based contexts used for assoc-one lazy loading registration.
+   */
+  private final Map<String, DLoadBeanContext> lazyBeanMap = new HashMap<>();
+  /**
+   * Type based sets used when lazy loading is disabled but immutable cache population should still occur.
+   */
+  private final Map<String, Set<EntityBeanIntercept>> immutableRefMap = new HashMap<>();
+  private final Map<Class<?>, ImmutableBeanCache<?>> immutableCaches;
   private final Map<String, DLoadManyContext> manyMap = new HashMap<>();
   private final DLoadBeanContext rootBeanContext;
   private final boolean asDraft;
@@ -69,6 +82,7 @@ public DLoadContext(BeanDescriptor<?> rootDescriptor, PersistenceContext persist
     this.planLabel = null;
     this.profileLocation = null;
     this.profilingListener = null;
+    this.immutableCaches = Collections.emptyMap();
     this.rootBeanContext = new DLoadBeanContext(this, rootDescriptor, null, null);
     this.secondaryProperties = null;
   }
@@ -97,6 +111,7 @@ public DLoadContext(OrmQueryRequest<?> request, SpiQuerySecondary secondaryQueri
     this.profilingListener = query.profilingListener();
     this.planLabel = query.planLabel();
     this.profileLocation = query.profileLocation();
+    this.immutableCaches = query.immutableBeanCaches();
     this.secondaryProperties = query.isUnmodifiable() ? new HashSet<>() : null;
 
     ObjectGraphNode parentNode = query.parentNode();
@@ -246,12 +261,22 @@ public PersistenceContext persistenceContext() {
 
   @Override
   public void register(String path, EntityBeanIntercept ebi) {
-    beanContext(path).register(ebi);
+    DLoadBeanContext context = pathBeanContext(path);
+    if (context != null) {
+      context.register(ebi);
+    } else {
+      lazyBeanContext(descriptor(ebi)).register(ebi);
+    }
   }
 
   @Override
   public void register(String path, EntityBeanIntercept ebi, BeanPropertyAssocOne<?> property) {
-    beanContextWithInherit(path, property).register(ebi);
+    DLoadBeanContext context = pathBeanContext(path);
+    if (context != null) {
+      context.register(ebi);
+    } else {
+      lazyBeanContext(property.targetDescriptor()).register(ebi);
+    }
   }
 
   @Override
@@ -259,6 +284,17 @@ public void register(String path, BeanPropertyAssocMany<?> many, BeanCollection<
     manyContext(path, many).register(bc);
   }
 
+  @Override
+  public void registerForImmutable(EntityBeanIntercept ebi) {
+    if (immutableCaches.isEmpty()) {
+      return;
+    }
+    BeanDescriptor<?> descriptor = descriptor(ebi);
+    if (immutableCaches.containsKey(descriptor.type())) {
+      immutableRefMap.computeIfAbsent(descriptor.fullName(), key -> new LinkedHashSet<>()).add(ebi);
+    }
+  }
+
   int batchSize(OrmQueryProperties props) {
     if (props == null) {
       return defaultBatchSize;
@@ -267,16 +303,60 @@ int batchSize(OrmQueryProperties props) {
     return batchSize == 0 ? defaultBatchSize : batchSize;
   }
 
-  DLoadBeanContext beanContext(String path) {
+  private DLoadBeanContext pathBeanContext(String path) {
     if (path == null) {
       return rootBeanContext;
     }
-    return beanMap.computeIfAbsent(path, p -> createBeanContext(p, null));
+    return beanMap.get(path);
   }
 
-  DLoadBeanContext beanContextWithInherit(String path, BeanPropertyAssocOne<?> property) {
-    String key = path + ":" + property.targetDescriptor().name();
-    return beanMap.computeIfAbsent(key, p -> createBeanContext(property, path));
+  private DLoadBeanContext lazyBeanContext(BeanDescriptor<?> descriptor) {
+    return lazyBeanMap.computeIfAbsent(descriptor.fullName(), p -> new DLoadBeanContext(this, descriptor, descriptor.name(), null));
+  }
+
+  @Override
+  public void populateFromImmutableCache() {
+    if (immutableCaches.isEmpty()) {
+      return;
+    }
+    for (Map.Entry<Class<?>, ImmutableBeanCache<?>> entry : immutableCaches.entrySet()) {
+      BeanDescriptor<?> descriptor = rootDescriptor.descriptor(entry.getKey());
+      if (descriptor == null) {
+        continue;
+      }
+      DLoadBeanContext context = lazyBeanMap.get(descriptor.fullName());
+      Map<Object, EntityBeanIntercept> interceptById = new LinkedHashMap<>();
+      if (context != null) {
+        for (EntityBeanIntercept ebi : context.bufferedBeans()) {
+          Object id = descriptor.id(ebi.owner());
+          if (id != null) {
+            interceptById.put(id, ebi);
+          }
+        }
+      }
+      Set<EntityBeanIntercept> immutableRefs = immutableRefMap.get(descriptor.fullName());
+      if (immutableRefs != null) {
+        for (EntityBeanIntercept ebi : immutableRefs) {
+          Object id = descriptor.id(ebi.owner());
+          if (id != null) {
+            interceptById.putIfAbsent(id, ebi);
+          }
+        }
+      }
+      if (!interceptById.isEmpty()) {
+        Map<Object, ?> hits = entry.getValue().getAll(interceptById.keySet());
+        for (Map.Entry<Object, ?> hit : hits.entrySet()) {
+          EntityBeanIntercept ebi = interceptById.get(hit.getKey());
+          Object bean = hit.getValue();
+          if (ebi != null && bean instanceof EntityBean) {
+            EntityBean cachedBean = (EntityBean) bean;
+            descriptor.merge(cachedBean, ebi.owner());
+            ebi.setLoadedFromCache(true);
+            ebi.setLoadedLazy();
+          }
+        }
+      }
+    }
   }
 
   private void registerSecondaryNode(boolean many, OrmQueryProperties props) {
@@ -306,8 +386,8 @@ private DLoadBeanContext createBeanContext(String path, OrmQueryProperties query
     return new DLoadBeanContext(this, p.targetDescriptor(), path, queryProps);
   }
 
-  private DLoadBeanContext createBeanContext(BeanPropertyAssoc<?> property, String path) {
-    return new DLoadBeanContext(this, property.targetDescriptor(), path, null);
+  private BeanDescriptor<?> descriptor(EntityBeanIntercept ebi) {
+    return rootDescriptor.descriptor(ebi.owner().getClass());
   }
 
   private BeanProperty beanProperty(BeanDescriptor<?> desc, String path) {
@@ -333,6 +413,11 @@ void propagateQueryState(SpiQuery<?> query, boolean docStoreMapped) {
     if (disableReadAudit) {
       query.setDisableReadAuditing();
     }
+    if (!immutableCaches.isEmpty()) {
+      for (ImmutableBeanCache<?> beanCache : immutableCaches.values()) {
+        query.putImmutableBeanCache(beanCache);
+      }
+    }
     if (profilingListener != null) {
       query.setProfilingListener(profilingListener);
     }
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQuery.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQuery.java
index fd83d7c42d..aea217719d 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQuery.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQuery.java
@@ -601,6 +601,11 @@ public void register(BeanPropertyAssocMany<?> many, BeanCollection<?> bc) {
     request.loadContext().register(path(many.name()), many, bc);
   }
 
+  @Override
+  public void registerForImmutable(EntityBeanIntercept ebi) {
+    request.loadContext().registerForImmutable(ebi);
+  }
+
   @Override
   public boolean includeSecondary(BeanPropertyAssocMany<?> many) {
     return request.loadContext().includeSecondary(many);
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryEngine.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryEngine.java
index 02b3d34ded..6ede229ea9 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryEngine.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/CQueryEngine.java
@@ -354,6 +354,7 @@ <T> BeanCollection<T> findMany(OrmQueryRequest<T> request) {
         cquery.auditFindMany();
       }
       request.executeSecondaryQueries(false);
+      request.populateFromImmutableCache();
       if (request.isQueryCachePut()) {
         request.addDependentTables(cquery.dependentTables());
       }
@@ -390,6 +391,7 @@ public <T> T find(OrmQueryRequest<T> request) {
         cquery.auditFind(bean);
       }
       request.executeSecondaryQueries(false);
+      request.populateFromImmutableCache();
       request.unmodifiableFreeze(bean);
       return (T) bean;
     } catch (SQLException e) {
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultFetchGroupQuery.java b/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultFetchGroupQuery.java
index 01c60aabc9..5ad377741e 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultFetchGroupQuery.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/query/DefaultFetchGroupQuery.java
@@ -224,6 +224,11 @@ public Query<T> usingTransaction(Transaction transaction) {
     throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
   }
 
+  @Override
+  public Query<T> using(ImmutableBeanCache<?> beanCache) {
+    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
+  }
+
   @Override
   public Query<T> usingConnection(Connection connection) {
     throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
diff --git a/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java b/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java
index 11601a5c6a..f3d5f100c6 100644
--- a/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java
+++ b/ebean-core/src/main/java/io/ebeaninternal/server/querydefn/DefaultOrmQuery.java
@@ -163,6 +163,7 @@ public class DefaultOrmQuery<T> extends AbstractQuery implements SpiQuery<T> {
   private String nativeSql;
   private boolean orderById;
   private ProfileLocation profileLocation;
+  private Map<Class<?>, ImmutableBeanCache<?>> immutableBeanCaches;
 
   public DefaultOrmQuery(BeanDescriptor<T> desc, SpiEbeanServer server, ExpressionFactory expressionFactory) {
     this.beanDescriptor = desc;
@@ -768,6 +769,9 @@ public SpiQuery<T> copy(SpiEbeanServer server) {
     copy.useBeanCache = useBeanCache;
     copy.useQueryCache = useQueryCache;
     copy.unmodifiable = unmodifiable;
+    if (immutableBeanCaches != null) {
+      copy.immutableBeanCaches = new LinkedHashMap<>(immutableBeanCaches);
+    }
     if (detail != null) {
       copy.detail = detail.copy(null);
     }
@@ -1462,6 +1466,12 @@ public final Query<T> usingTransaction(Transaction transaction) {
     return this;
   }
 
+  @Override
+  public Query<T> using(ImmutableBeanCache<?> beanCache) {
+    putImmutableBeanCache(beanCache);
+    return this;
+  }
+
   @Override
   public final Query<T> usingConnection(Connection connection) {
     this.transaction = new ExternalJdbcTransaction(connection);
@@ -1480,6 +1490,19 @@ public Query<T> usingMaster(boolean useMaster) {
     return this;
   }
 
+  @Override
+  public void putImmutableBeanCache(ImmutableBeanCache<?> beanCache) {
+    if (immutableBeanCaches == null) {
+      immutableBeanCaches = new LinkedHashMap<>();
+    }
+    immutableBeanCaches.put(beanCache.type(), beanCache);
+  }
+
+  @Override
+  public Map<Class<?>, ImmutableBeanCache<?>> immutableBeanCaches() {
+    return immutableBeanCaches == null ? Collections.emptyMap() : Collections.unmodifiableMap(immutableBeanCaches);
+  }
+
   @Override
   public boolean isUseMaster() {
     return useMaster;
diff --git a/ebean-core/src/main/java/module-info.java b/ebean-core/src/main/java/module-info.java
index 572b535e89..795ec32874 100644
--- a/ebean-core/src/main/java/module-info.java
+++ b/ebean-core/src/main/java/module-info.java
@@ -76,6 +76,7 @@
   provides io.ebean.service.BootstrapService with
     io.ebeaninternal.server.DContainerFactory,
     io.ebeaninternal.server.query.DFetchGroupService,
+    io.ebeaninternal.server.cache.DImmutableCacheFactory,
     io.ebeaninternal.server.profile.DProfileLocationFactory,
     io.ebeaninternal.server.rawsql.DRawSqlService,
     io.ebeaninternal.server.profile.DMetricFactory;
diff --git a/ebean-core/src/main/resources/META-INF/services/io.ebean.service.BootstrapService b/ebean-core/src/main/resources/META-INF/services/io.ebean.service.BootstrapService
index 5a674c9122..4fc602dfbd 100644
--- a/ebean-core/src/main/resources/META-INF/services/io.ebean.service.BootstrapService
+++ b/ebean-core/src/main/resources/META-INF/services/io.ebean.service.BootstrapService
@@ -1,5 +1,6 @@
 io.ebeaninternal.server.DContainerFactory
 io.ebeaninternal.server.rawsql.DRawSqlService
 io.ebeaninternal.server.query.DFetchGroupService
+io.ebeaninternal.server.cache.DImmutableCacheFactory
 io.ebeaninternal.server.profile.DProfileLocationFactory
 io.ebeaninternal.server.profile.DMetricFactory
diff --git a/ebean-querybean/src/main/java/io/ebean/typequery/QueryBean.java b/ebean-querybean/src/main/java/io/ebean/typequery/QueryBean.java
index 536979f828..6cfa28e074 100644
--- a/ebean-querybean/src/main/java/io/ebean/typequery/QueryBean.java
+++ b/ebean-querybean/src/main/java/io/ebean/typequery/QueryBean.java
@@ -744,6 +744,12 @@ public R usingMaster(boolean useMaster) {
     return root;
   }
 
+  @Override
+  public R using(ImmutableBeanCache<?> beanCache) {
+    query.using(beanCache);
+    return root;
+  }
+
   @Override
   public final boolean exists() {
     return query.exists();
diff --git a/ebean-test/src/test/java/org/tests/lazyforeignkeys/TestLazyForeignKeys.java b/ebean-test/src/test/java/org/tests/lazyforeignkeys/TestLazyForeignKeys.java
index f88f148297..24ae33647f 100644
--- a/ebean-test/src/test/java/org/tests/lazyforeignkeys/TestLazyForeignKeys.java
+++ b/ebean-test/src/test/java/org/tests/lazyforeignkeys/TestLazyForeignKeys.java
@@ -56,13 +56,12 @@ public void testFindOne() throws Exception {
     assertTrue(rel1.getEntity2().isDeleted());
 
     List<String> sql = LoggedSql.stop();
-    assertThat(sql).hasSize(3);
+    assertThat(sql).hasSize(2);
     assertSql(sql.get(0)).contains("select t0.id, t0.attr1, t0.id1, t0.id2, t1.species, t0.cat_id from main_entity_relation t0 left join animal t1 on t1.id = t0.cat_id");
     if (isSqlServer() || isOracle()) {
       assertSql(sql.get(1)).contains("select t0.id, t0.attr1, t0.attr2, CASE WHEN t0.id is null THEN 1 ELSE 0 END from main_entity t0");
     } else {
       assertSql(sql.get(1)).contains("select t0.id, t0.attr1, t0.attr2, t0.id is null from main_entity t0");
-      assertSql(sql.get(2)).contains("select t0.id, t0.attr1, t0.attr2, t0.id is null from main_entity t0");
     }
   }
 
diff --git a/ebean-test/src/test/java/org/tests/o2m/recurse/TestFetchOneToManySameTypeTwoPaths.java b/ebean-test/src/test/java/org/tests/o2m/recurse/TestFetchOneToManySameTypeTwoPaths.java
index 34df0ac88d..07a6b0cd50 100644
--- a/ebean-test/src/test/java/org/tests/o2m/recurse/TestFetchOneToManySameTypeTwoPaths.java
+++ b/ebean-test/src/test/java/org/tests/o2m/recurse/TestFetchOneToManySameTypeTwoPaths.java
@@ -3,9 +3,14 @@
 import io.ebean.DB;
 import io.ebean.Database;
 import io.ebean.FetchConfig;
+import io.ebean.test.LoggedSql;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class TestFetchOneToManySameTypeTwoPaths {
 
@@ -130,4 +135,32 @@ void testSubItemListFetch_itemBFirst() {
     }
   }
 
+  @Test
+  void testLazyAssocOneSameTypeTwoPaths_singleQuery() {
+    Database server = DB.getDefault();
+
+    RMItem itemA = new RMItem("lazy-a");
+    server.save(itemA);
+    RMItem itemB = new RMItem("lazy-b");
+    server.save(itemB);
+
+    RMItemHolder holder = new RMItemHolder("holder-lazy");
+    holder.setItemA(itemA);
+    holder.setItemB(itemB);
+    server.save(holder);
+
+    RMItemHolder found = server.find(RMItemHolder.class)
+      .select("name,itemA,itemB")
+      .where().idEq(holder.getId())
+      .findOne();
+
+    LoggedSql.start();
+    assertNull(found.getItemA().getItemGroup());
+    assertNull(found.getItemB().getItemGroup());
+    List<String> sql = LoggedSql.stop();
+
+    assertEquals(1, sql.size());
+    assertTrue(sql.get(0).contains(" from rmitem "));
+  }
+
 }
diff --git a/tests/test-java16/src/main/java/org/example/resource/AttributeDescriptor.java b/ebean-test/src/test/java/org/tests/resource/AttributeDescriptor.java
similarity index 89%
rename from tests/test-java16/src/main/java/org/example/resource/AttributeDescriptor.java
rename to ebean-test/src/test/java/org/tests/resource/AttributeDescriptor.java
index 0d09614b54..b6d30921b9 100644
--- a/tests/test-java16/src/main/java/org/example/resource/AttributeDescriptor.java
+++ b/ebean-test/src/test/java/org/tests/resource/AttributeDescriptor.java
@@ -1,9 +1,8 @@
-package org.example.resource;
+package org.tests.resource;
 
 import jakarta.persistence.CascadeType;
 import jakarta.persistence.Entity;
 import jakarta.persistence.ManyToOne;
-import org.example.records.BaseModel;
 
 @Entity
 public class AttributeDescriptor extends BaseModel {
diff --git a/tests/test-java16/src/main/java/org/example/resource/AttributeValue.java b/ebean-test/src/test/java/org/tests/resource/AttributeValue.java
similarity index 93%
rename from tests/test-java16/src/main/java/org/example/resource/AttributeValue.java
rename to ebean-test/src/test/java/org/tests/resource/AttributeValue.java
index d997ffb95b..9b6b366591 100644
--- a/tests/test-java16/src/main/java/org/example/resource/AttributeValue.java
+++ b/ebean-test/src/test/java/org/tests/resource/AttributeValue.java
@@ -1,9 +1,7 @@
-package org.example.resource;
+package org.tests.resource;
 
 import jakarta.persistence.Entity;
-import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;
-import org.example.records.BaseModel;
 
 @Entity
 public class AttributeValue extends BaseModel {
diff --git a/tests/test-java16/src/main/java/org/example/resource/AttributeValueOwner.java b/ebean-test/src/test/java/org/tests/resource/AttributeValueOwner.java
similarity index 90%
rename from tests/test-java16/src/main/java/org/example/resource/AttributeValueOwner.java
rename to ebean-test/src/test/java/org/tests/resource/AttributeValueOwner.java
index ad5036878d..c0ad9402d9 100644
--- a/tests/test-java16/src/main/java/org/example/resource/AttributeValueOwner.java
+++ b/ebean-test/src/test/java/org/tests/resource/AttributeValueOwner.java
@@ -1,9 +1,8 @@
-package org.example.resource;
+package org.tests.resource;
 
 import jakarta.persistence.CascadeType;
 import jakarta.persistence.Entity;
 import jakarta.persistence.OneToMany;
-import org.example.records.BaseModel;
 
 import java.util.List;
 
diff --git a/ebean-test/src/test/java/org/tests/resource/BaseModel.java b/ebean-test/src/test/java/org/tests/resource/BaseModel.java
new file mode 100644
index 0000000000..7258e52f30
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/resource/BaseModel.java
@@ -0,0 +1,34 @@
+package org.tests.resource;
+
+import io.ebean.Model;
+import io.ebean.annotation.Identity;
+import jakarta.persistence.Id;
+import jakarta.persistence.MappedSuperclass;
+import jakarta.persistence.Version;
+
+@Identity(start = 1000, cache = 100)
+@MappedSuperclass
+public class BaseModel extends Model {
+
+  @Id
+  long id;
+
+  @Version
+  long version;
+
+  public long id() {
+    return id;
+  }
+
+  public void id(long id) {
+    this.id = id;
+  }
+
+  public long version() {
+    return version;
+  }
+
+  public void version(long version) {
+    this.version = version;
+  }
+}
diff --git a/ebean-test/src/test/java/org/tests/resource/BeanDescriptorMergeTest.java b/ebean-test/src/test/java/org/tests/resource/BeanDescriptorMergeTest.java
new file mode 100644
index 0000000000..d5667a0c74
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/resource/BeanDescriptorMergeTest.java
@@ -0,0 +1,94 @@
+package org.tests.resource;
+
+import io.ebean.DB;
+import io.ebean.bean.EntityBean;
+import io.ebean.bean.EntityBeanIntercept;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanProperty;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.util.Locale;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class BeanDescriptorMergeTest {
+
+  @Test
+  void merge_copiesUnloadedScalar_andMarksLoaded() {
+
+    long id = createLabel("merge-copy-loaded");
+    BeanDescriptor<Label> descriptor = descriptor();
+
+    Label from = DB.find(Label.class).setId(id).select("version").findOne();
+    Label existing = DB.reference(Label.class, id);
+
+    EntityBeanIntercept fromEbi = ((EntityBean) from)._ebean_getIntercept();
+    EntityBeanIntercept toEbi = ((EntityBean) existing)._ebean_getIntercept();
+    int versionIndex = fromEbi.findProperty("version");
+
+    assertThat(toEbi.isLoadedProperty(versionIndex)).isFalse();
+
+    descriptor.merge((EntityBean) from, (EntityBean) existing);
+
+    assertThat(existing.version()).isEqualTo(from.version());
+    assertThat(toEbi.isLoadedProperty(versionIndex)).isTrue();
+  }
+
+  @Test
+  void merge_doesNotOverwriteAlreadyLoadedScalar() {
+
+    long id = createLabel("merge-no-overwrite");
+    BeanDescriptor<Label> descriptor = descriptor();
+
+    Label from = DB.find(Label.class).setId(id).select("version").findOne();
+    Label existing = DB.find(Label.class).setId(id).findOne();
+    long changedVersion = existing.version() + 100;
+    existing.version(changedVersion);
+
+    descriptor.merge((EntityBean) from, (EntityBean) existing);
+
+    assertThat(existing.version()).isEqualTo(changedVersion);
+  }
+
+  @Test
+  void merge_fallbackWhenPropertiesIndexEntryMissing() throws Exception {
+
+    long id = createLabel("merge-fallback");
+    BeanDescriptor<Label> descriptor = descriptor();
+
+    Label from = DB.find(Label.class).setId(id).select("version").findOne();
+    Label existing = DB.reference(Label.class, id);
+
+    EntityBeanIntercept fromEbi = ((EntityBean) from)._ebean_getIntercept();
+    EntityBeanIntercept toEbi = ((EntityBean) existing)._ebean_getIntercept();
+    int versionIndex = fromEbi.findProperty("version");
+
+    Field field = BeanDescriptor.class.getDeclaredField("propertiesIndex");
+    field.setAccessible(true);
+    BeanProperty[] propertiesIndex = (BeanProperty[]) field.get(descriptor);
+    BeanProperty original = propertiesIndex[versionIndex];
+    propertiesIndex[versionIndex] = null;
+    try {
+      descriptor.merge((EntityBean) from, (EntityBean) existing);
+    } finally {
+      propertiesIndex[versionIndex] = original;
+    }
+
+    assertThat(existing.version()).isEqualTo(from.version());
+    assertThat(toEbi.isLoadedProperty(versionIndex)).isTrue();
+  }
+
+  private BeanDescriptor<Label> descriptor() {
+    return ((SpiEbeanServer) DB.getDefault()).descriptor(Label.class);
+  }
+
+  private long createLabel(String textPrefix) {
+    Label label = new Label();
+    label.addLabelText(Locale.ENGLISH, textPrefix + "-en");
+    label.addLabelText(Locale.GERMAN, textPrefix + "-de");
+    DB.save(label);
+    return label.id();
+  }
+}
diff --git a/tests/test-java16/src/main/java/org/example/resource/Label.java b/ebean-test/src/test/java/org/tests/resource/Label.java
similarity index 90%
rename from tests/test-java16/src/main/java/org/example/resource/Label.java
rename to ebean-test/src/test/java/org/tests/resource/Label.java
index 9f61681c23..9f860a4d15 100644
--- a/tests/test-java16/src/main/java/org/example/resource/Label.java
+++ b/ebean-test/src/test/java/org/tests/resource/Label.java
@@ -1,9 +1,8 @@
-package org.example.resource;
+package org.tests.resource;
 
 import jakarta.persistence.CascadeType;
 import jakarta.persistence.Entity;
 import jakarta.persistence.OneToMany;
-import org.example.records.BaseModel;
 
 import java.util.List;
 import java.util.Locale;
diff --git a/tests/test-java16/src/main/java/org/example/resource/LabelText.java b/ebean-test/src/test/java/org/tests/resource/LabelText.java
similarity index 92%
rename from tests/test-java16/src/main/java/org/example/resource/LabelText.java
rename to ebean-test/src/test/java/org/tests/resource/LabelText.java
index 468f3e2278..7377829c3d 100644
--- a/tests/test-java16/src/main/java/org/example/resource/LabelText.java
+++ b/ebean-test/src/test/java/org/tests/resource/LabelText.java
@@ -1,8 +1,7 @@
-package org.example.resource;
+package org.tests.resource;
 
 import jakarta.persistence.Entity;
 import jakarta.persistence.ManyToOne;
-import org.example.records.BaseModel;
 
 import java.util.Locale;
 
diff --git a/tests/test-java16/src/main/java/org/example/resource/Resource.java b/ebean-test/src/test/java/org/tests/resource/Resource.java
similarity index 93%
rename from tests/test-java16/src/main/java/org/example/resource/Resource.java
rename to ebean-test/src/test/java/org/tests/resource/Resource.java
index f6f8ab7475..844806cd16 100644
--- a/tests/test-java16/src/main/java/org/example/resource/Resource.java
+++ b/ebean-test/src/test/java/org/tests/resource/Resource.java
@@ -1,7 +1,6 @@
-package org.example.resource;
+package org.tests.resource;
 
 import jakarta.persistence.*;
-import org.example.records.BaseModel;
 
 @Entity
 public class Resource extends BaseModel {
diff --git a/ebean-test/src/test/java/org/tests/resource/ResourceEntityTest.java b/ebean-test/src/test/java/org/tests/resource/ResourceEntityTest.java
new file mode 100644
index 0000000000..2251b89bc2
--- /dev/null
+++ b/ebean-test/src/test/java/org/tests/resource/ResourceEntityTest.java
@@ -0,0 +1,454 @@
+package org.tests.resource;
+
+import io.ebean.DB;
+import io.ebean.FetchGroup;
+import io.ebean.ImmutableBeanCache;
+import io.ebean.ImmutableBeanCaches;
+import io.ebean.test.LoggedSql;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ResourceEntityTest {
+
+  static AttributeDescriptor heightDescriptor;
+  static AttributeDescriptor widthDescriptor;
+  static Resource resource;
+
+  @BeforeAll
+  static void setup() {
+    Locale en = Locale.GERMAN;
+    Locale de = Locale.ENGLISH;
+
+    heightDescriptor = new AttributeDescriptor();
+    heightDescriptor.setName(new Label());
+    heightDescriptor.getName().addLabelText(en, "Height");
+    heightDescriptor.getName().addLabelText(de, "Höhe");
+    heightDescriptor.setDescription(new Label());
+    heightDescriptor.getDescription().addLabelText(en, "Height property");
+    heightDescriptor.getDescription().addLabelText(de, "Höhe Eigenschaft");
+
+    DB.save(heightDescriptor);
+
+    widthDescriptor = new AttributeDescriptor();
+    widthDescriptor.setName(new Label());
+    widthDescriptor.getName().addLabelText(en, "Width");
+    widthDescriptor.getName().addLabelText(de, "Breite");
+    widthDescriptor.setDescription(new Label());
+    widthDescriptor.getDescription().addLabelText(en, "Width property");
+    widthDescriptor.getDescription().addLabelText(de, "Breite Eigenschaft");
+
+    DB.save(widthDescriptor);
+
+    resource = new Resource();
+    resource.setResourceId("R1");
+    resource.setName(new Label());
+    resource.getName().addLabelText(en, "R1_en");
+    resource.getName().addLabelText(de, "R1_de");
+
+    resource.setAttributeValueOwner(new AttributeValueOwner());
+    resource.getAttributeValueOwner().addAttributeValue(new AttributeValue(1, heightDescriptor));
+    resource.getAttributeValueOwner().addAttributeValue(new AttributeValue(2, widthDescriptor));
+
+    DB.save(resource);
+  }
+
+  @Test
+  void testSimpleResource() {
+    var resources = DB.find(Resource.class)
+      .where().eq("resourceId", resource.getResourceId())
+      .findList();
+
+    assertThat(resources).isNotEmpty();
+  }
+
+  @Test
+  void find_then_invokeLazyLoading_expect_singleLazyLoadingQueryForSameType() {
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class).setId(heightDescriptor.id())
+      .findOne();
+
+    assertThat(one)
+      .describedAs("setup data exists")
+      .isNotNull();
+
+    LoggedSql.start();
+    assertThat(one.getName().version())
+      .describedAs("lazy loaded name label")
+      .isGreaterThan(0);
+
+    assertThat(one.getDescription().version())
+      .describedAs("lazy loaded description label")
+      .isGreaterThan(0);
+
+    List<String> sql = LoggedSql.stop();
+
+    assertThat(sql).hasSize(1);
+    assertThat(sql.get(0))
+      .describedAs("lazy loading query invoked by getName/getDescription")
+      .contains("select t0.id, t0.version from label t0 where t0.id in ");
+  }
+
+  @Test
+  void find_usingImmutableLabelCache_expect_noLazyLoadingQuery() {
+
+    Map<Object, Label> cachedLabels = new LinkedHashMap<>();
+    cachedLabels.put(heightDescriptor.getName().id(), heightDescriptor.getName());
+    cachedLabels.put(heightDescriptor.getDescription().id(), heightDescriptor.getDescription());
+    Set<Object> cacheLookups = new LinkedHashSet<>();
+
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+      .setId(heightDescriptor.id())
+      .using(labelCache(cachedLabels, cacheLookups))
+      .findOne();
+
+    assertThat(one).isNotNull();
+
+    LoggedSql.start();
+    assertThat(one.getName().version()).isGreaterThan(0);
+    assertThat(one.getDescription().version()).isGreaterThan(0);
+    List<String> sql = LoggedSql.stop();
+
+    assertThat(cacheLookups)
+      .containsExactlyInAnyOrder(heightDescriptor.getName().id(), heightDescriptor.getDescription().id());
+    assertThat(sql).isEmpty();
+  }
+
+  @Test
+  void find_usingImmutableLabelCacheWithPartialHits_expect_singleLazyLoadingQuery() {
+
+    Map<Object, Label> cachedLabels = new LinkedHashMap<>();
+    cachedLabels.put(heightDescriptor.getName().id(), heightDescriptor.getName());
+    Set<Object> cacheLookups = new LinkedHashSet<>();
+
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+      .setId(heightDescriptor.id())
+      .using(labelCache(cachedLabels, cacheLookups))
+      .findOne();
+
+    assertThat(one).isNotNull();
+
+    LoggedSql.start();
+    assertThat(one.getName().version()).isGreaterThan(0);
+    assertThat(one.getDescription().version()).isGreaterThan(0);
+    List<String> sql = LoggedSql.stop();
+
+    assertThat(cacheLookups)
+      .containsExactlyInAnyOrder(heightDescriptor.getName().id(), heightDescriptor.getDescription().id());
+    assertThat(sql).hasSize(1);
+    assertThat(sql.get(0)).contains("from label");
+  }
+
+  @Test
+  void find_usingImmutableLabelCacheWithNoHits_expect_singleLazyLoadingQuery() {
+
+    Set<Object> cacheLookups = new LinkedHashSet<>();
+
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+      .setId(heightDescriptor.id())
+      .using(labelCache(new LinkedHashMap<>(), cacheLookups))
+      .findOne();
+
+    assertThat(one).isNotNull();
+
+    LoggedSql.start();
+    assertThat(one.getName().version()).isGreaterThan(0);
+    assertThat(one.getDescription().version()).isGreaterThan(0);
+    List<String> sql = LoggedSql.stop();
+
+    assertThat(cacheLookups)
+      .containsExactlyInAnyOrder(heightDescriptor.getName().id(), heightDescriptor.getDescription().id());
+    assertThat(sql).hasSize(1);
+    assertThat(sql.get(0)).contains("from label");
+  }
+
+  @Test
+  void find_mutableUsingImmutableBeanCache_expect_additionalLazyLoadingStillWorks() {
+
+    var cache = loadingLabelCache();
+
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+      .setId(heightDescriptor.id())
+      .using(cache)
+      .findOne();
+
+    assertThat(one).isNotNull();
+    assertThat(DB.beanState(one.getName()).isUnmodifiable()).isFalse();
+    assertThat(DB.beanState(one.getDescription()).isUnmodifiable()).isFalse();
+
+    LoggedSql.start();
+    assertThat(one.getName().version()).isGreaterThan(0);
+    assertThat(one.getDescription().version()).isGreaterThan(0);
+    List<String> sqlFromCache = LoggedSql.stop();
+    assertThat(sqlFromCache).isEmpty();
+
+    LoggedSql.start();
+    assertThat(one.getName().getLabelTexts()).hasSize(2);
+    assertThat(one.getDescription().getLabelTexts()).hasSize(2);
+    List<String> lazySql = LoggedSql.stop();
+
+    assertThat(lazySql.stream().anyMatch(sql -> sql.contains("from label_text"))).isTrue();
+  }
+
+  @Test
+  void find_unmodifiableUsingImmutableLabelCache_expect_readableRefsWithNoLazyLoadSql() {
+
+    var cache = loadingLabelCache();
+    cache.getAll(Set.of(heightDescriptor.getName().id(), heightDescriptor.getDescription().id()));
+
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+      .setId(heightDescriptor.id())
+      .setUnmodifiable(true)
+      .using(cache)
+      .findOne();
+
+    assertThat(one).isNotNull();
+    assertThat(DB.beanState(one.getName()).isUnmodifiable()).isTrue();
+    assertThat(DB.beanState(one.getDescription()).isUnmodifiable()).isTrue();
+
+    LoggedSql.start();
+    assertThat(one.getName().version()).isGreaterThan(0);
+    assertThat(one.getDescription().version()).isGreaterThan(0);
+    List<String> sql = LoggedSql.stop();
+
+    assertThat(sql).isEmpty();
+  }
+
+  @Test
+  void find_unmodifiableUsingImmutableLabelCacheWithPartialHits_expect_backfillAndNoLazyLoadSql() {
+
+    var cache = loadingLabelCache();
+    cache.getAll(Set.of(heightDescriptor.getName().id()));
+
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+      .setId(heightDescriptor.id())
+      .setUnmodifiable(true)
+      .using(cache)
+      .findOne();
+
+    assertThat(one).isNotNull();
+    assertThat(DB.beanState(one.getName()).isUnmodifiable()).isTrue();
+    assertThat(DB.beanState(one.getDescription()).isUnmodifiable()).isTrue();
+
+    LoggedSql.start();
+    assertThat(one.getName().version()).isGreaterThan(0);
+    assertThat(one.getDescription().version()).isGreaterThan(0);
+    List<String> sql = LoggedSql.stop();
+
+    assertThat(sql).isEmpty();
+  }
+
+  @Test
+  void find_unmodifiableUsingImmutableLabelCacheWithNoHits_expect_backfillAndNoLazyLoadSql() {
+
+    var cache = loadingLabelCache();
+
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+      .setId(heightDescriptor.id())
+      .setUnmodifiable(true)
+      .using(cache)
+      .findOne();
+
+    assertThat(one).isNotNull();
+    assertThat(DB.beanState(one.getName()).isUnmodifiable()).isTrue();
+    assertThat(DB.beanState(one.getDescription()).isUnmodifiable()).isTrue();
+
+    LoggedSql.start();
+    assertThat(one.getName().version()).isGreaterThan(0);
+    assertThat(one.getDescription().version()).isGreaterThan(0);
+    List<String> sql = LoggedSql.stop();
+
+    assertThat(sql).isEmpty();
+  }
+
+  @Test
+  void find_unmodifiableUsingImmutableBeanCachesLoading_expect_seededLabelsLoadedAndNoLazyLoadSql() {
+
+    var cache = loadingLabelCache();
+
+    LoggedSql.start();
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+      .setId(heightDescriptor.id())
+      .setUnmodifiable(true)
+      .using(cache)
+      .findOne();
+
+    List<String> loadSql = LoggedSql.stop();
+
+    assertThat(one).isNotNull();
+    assertThat(one.getName().id()).isEqualTo(heightDescriptor.getName().id());
+    assertThat(one.getDescription().id()).isEqualTo(heightDescriptor.getDescription().id());
+    assertThat(DB.beanState(one.getName()).isUnmodifiable()).isTrue();
+    assertThat(DB.beanState(one.getDescription()).isUnmodifiable()).isTrue();
+    assertThat(loadSql.stream().filter(sql -> sql.contains(" from label "))).hasSize(1);
+
+    LoggedSql.start();
+    assertThat(one.getName().version()).isGreaterThan(0);
+    assertThat(one.getDescription().version()).isGreaterThan(0);
+    List<String> sql = LoggedSql.stop();
+    assertThat(sql).isEmpty();
+  }
+
+  @Test
+  void find_unmodifiableUsingImmutableBeanCachesLoadingWithLabelTexts_expect_assocLoadedAndNoLazyLoadSql() {
+
+    var cache = loadingLabelWithTextsCache();
+
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+      .setId(heightDescriptor.id())
+      .setUnmodifiable(true)
+      .using(cache)
+      .findOne();
+
+    assertThat(one).isNotNull();
+    assertThat(DB.beanState(one.getName()).isUnmodifiable()).isTrue();
+    assertThat(DB.beanState(one.getDescription()).isUnmodifiable()).isTrue();
+
+    LoggedSql.start();
+    assertThat(one.getName().getLabelTexts())
+      .extracting(LabelText::getLocaleText)
+      .containsExactlyInAnyOrder("Height", "Höhe");
+
+    assertThat(one.getDescription().getLabelTexts())
+      .extracting(LabelText::getLocaleText)
+      .containsExactlyInAnyOrder("Height property", "Höhe Eigenschaft");
+
+    List<String> sql = LoggedSql.stop();
+    assertThat(sql).isEmpty();
+  }
+
+  @Test
+  void find_unmodifiableUsingImmutableBeanCachesBuilderLoadingWithLabelTexts_expect_assocLoadedAndNoLazyLoadSql() {
+
+    FetchGroup<Label> fetchGroup = FetchGroup.of(Label.class)
+      .select("version")
+      .fetch("labelTexts", "locale, localeText")
+      .build();
+
+    ImmutableBeanCache<Label> cache = ImmutableBeanCaches.builder(Label.class)
+      .loading(DB.getDefault(), fetchGroup)
+      .maxSize(10_000)
+      .maxIdleSeconds(300)
+      .maxSecondsToLive(6_000)
+      .build();
+
+    AttributeDescriptor one = DB.find(AttributeDescriptor.class)
+      .setId(heightDescriptor.id())
+      .setUnmodifiable(true)
+      .using(cache)
+      .findOne();
+
+    assertThat(one).isNotNull();
+    assertThat(DB.beanState(one.getName()).isUnmodifiable()).isTrue();
+    assertThat(DB.beanState(one.getDescription()).isUnmodifiable()).isTrue();
+
+    LoggedSql.start();
+    assertThat(one.getName().getLabelTexts())
+      .extracting(LabelText::getLocaleText)
+      .containsExactlyInAnyOrder("Height", "Höhe");
+
+    assertThat(one.getDescription().getLabelTexts())
+      .extracting(LabelText::getLocaleText)
+      .containsExactlyInAnyOrder("Height property", "Höhe Eigenschaft");
+
+    List<String> sql = LoggedSql.stop();
+    assertThat(sql).isEmpty();
+  }
+
+  @Test
+  void find_fetchQuerySecondary_inheritsImmutableCache_expect_noLabelLazyLoadSql() {
+
+    var cache = loadingLabelCache();
+
+    AttributeValueOwner owner = DB.find(AttributeValueOwner.class)
+      .setId(resource.getAttributeValueOwner().id())
+      .fetchQuery("attributeValues", "intValue")
+      .fetch("attributeValues.attributeDescriptor", "name,description")
+      .using(cache)
+      .findOne();
+
+    assertThat(owner).isNotNull();
+    assertThat(owner.getAttributeValues()).hasSize(2);
+
+    LoggedSql.start();
+    accessDescriptorLabels(owner);
+    List<String> sql = LoggedSql.stop();
+
+    assertThat(sql).isEmpty();
+  }
+
+  @Test
+  void find_fetchLazySecondary_inheritsImmutableCache_expect_noLabelLazyLoadSql() {
+
+    var cache = loadingLabelCache();
+
+    AttributeValueOwner owner = DB.find(AttributeValueOwner.class)
+      .setId(resource.getAttributeValueOwner().id())
+      .fetchLazy("attributeValues", "intValue")
+      .fetch("attributeValues.attributeDescriptor", "name,description")
+      .using(cache)
+      .findOne();
+
+    assertThat(owner).isNotNull();
+
+    // Trigger the +lazy secondary query first.
+    assertThat(owner.getAttributeValues()).hasSize(2);
+
+    LoggedSql.start();
+    accessDescriptorLabels(owner);
+    List<String> sql = LoggedSql.stop();
+
+    assertThat(sql).isEmpty();
+  }
+
+  private ImmutableBeanCache<Label> labelCache(Map<Object, Label> cachedLabels, Set<Object> cacheLookups) {
+    return new ImmutableBeanCache<>() {
+      @Override
+      public Class<Label> type() {
+        return Label.class;
+      }
+
+      @Override
+      public Map<Object, Label> getAll(Set<Object> ids) {
+        cacheLookups.addAll(ids);
+        Map<Object, Label> hits = new LinkedHashMap<>();
+        for (Object id : ids) {
+          Label bean = cachedLabels.get(id);
+          if (bean != null) {
+            hits.put(id, bean);
+          }
+        }
+        return hits;
+      }
+    };
+  }
+
+  private ImmutableBeanCache<Label> loadingLabelCache() {
+    return ImmutableBeanCaches.loading(Label.class, DB.getDefault(), FetchGroup.of(Label.class, "version"));
+  }
+
+  private ImmutableBeanCache<Label> loadingLabelWithTextsCache() {
+    FetchGroup<Label> fetchGroup = FetchGroup.of(Label.class)
+      .select("version")
+      .fetch("labelTexts", "locale, localeText")
+      .build();
+    return ImmutableBeanCaches.loading(Label.class, DB.getDefault(), fetchGroup);
+  }
+
+  private void accessDescriptorLabels(AttributeValueOwner owner) {
+    for (AttributeValue attributeValue : owner.getAttributeValues()) {
+      AttributeDescriptor descriptor = attributeValue.getAttributeDescriptor();
+      assertThat(descriptor).isNotNull();
+      assertThat(descriptor.getName().version()).isGreaterThan(0);
+      assertThat(descriptor.getDescription().version()).isGreaterThan(0);
+    }
+  }
+
+}
diff --git a/ebean-test/src/test/resources/logback-test.xml b/ebean-test/src/test/resources/logback-test.xml
index 36c235e0c7..1612755c91 100644
--- a/ebean-test/src/test/resources/logback-test.xml
+++ b/ebean-test/src/test/resources/logback-test.xml
@@ -82,9 +82,9 @@
 
 <!--  <logger name="io.ebean.DDL" level="DEBUG"/>-->
 
-<!--  <logger name="io.ebean.SQL" level="TRACE"/>-->
-<!--  <logger name="io.ebean.TXN" level="TRACE"/>-->
-<!--  <logger name="io.ebean.SUM" level="TRACE"/>-->
+  <logger name="io.ebean.SQL" level="TRACE"/>
+  <logger name="io.ebean.TXN" level="TRACE"/>
+  <logger name="io.ebean.SUM" level="TRACE"/>
 
 <!--  <logger name="io.ebean.cache" level="TRACE"/>-->
 <!--  <logger name="io.ebean.cache.REGION" level="TRACE"/>-->
diff --git a/tests/test-java16/src/test/java/org/example/resource/ResourceEntityTest.java b/tests/test-java16/src/test/java/org/example/resource/ResourceEntityTest.java
deleted file mode 100644
index de42686df2..0000000000
--- a/tests/test-java16/src/test/java/org/example/resource/ResourceEntityTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package org.example.resource;
-
-import io.ebean.DB;
-import org.example.records.CourseRecordEntity;
-import org.example.records.query.QCourseRecordEntity;
-import org.example.resource.query.QResource;
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-import java.util.Locale;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class ResourceEntityTest {
-
-  @Test
-  void testSimpleResource() {
-    Locale en = Locale.GERMAN;
-    Locale de = Locale.ENGLISH;
-
-    AttributeDescriptor heightDescriptor = new AttributeDescriptor();
-    heightDescriptor.setName(new Label());
-    heightDescriptor.getName().addLabelText(en,"Height");
-    heightDescriptor.getName().addLabelText(de,"Höhe");
-    heightDescriptor.setDescription(new Label());
-    heightDescriptor.getDescription().addLabelText(en, "Height property");
-    heightDescriptor.getDescription().addLabelText(de, "Höhe Eigenschaft");
-
-    DB.save(heightDescriptor);
-
-    AttributeDescriptor widthDescriptor = new AttributeDescriptor();
-    widthDescriptor.setName(new Label());
-    widthDescriptor.getName().addLabelText(en,"Width");
-    widthDescriptor.getName().addLabelText(de,"Breite");
-    widthDescriptor.setDescription(new Label());
-    widthDescriptor.getDescription().addLabelText(en, "Width property");
-    widthDescriptor.getDescription().addLabelText(de, "Breite Eigenschaft");
-
-    DB.save(widthDescriptor);
-
-    Resource resource = new Resource();
-    resource.setResourceId("R1");
-    resource.setName(new Label());
-    resource.getName().addLabelText(en, "R1_en");
-    resource.getName().addLabelText(de, "R1_de");
-
-    resource.setAttributeValueOwner(new AttributeValueOwner());
-    resource.getAttributeValueOwner().addAttributeValue(new AttributeValue(1, heightDescriptor));
-    resource.getAttributeValueOwner().addAttributeValue(new AttributeValue(2, widthDescriptor));
-
-    DB.save(resource);
-
-    QResource qresource = new QResource().resourceId.eq(resource.getResourceId());
-
-    List<Resource> resources = qresource.findList();
-
-    assertThat(resources).isNotEmpty();
-  }
-
-
-}