asOf() bean caching

[dragkes]

Hello. I have encountered what appears to be an issue with query caching behavior when using asOf() in combination with lazy loading.

When lazily loading associations of beans fetched via asOf(), the lazy loading queries appear to consult the bean cache. As a result, the returned beans may reflect the current state rather than the historical state defined by asOf(). This leads to incorrect results, since the bean cache only contains the latest versions of entities and not their historical snapshots. This behavior seems unintended for temporal queries.

It also appears that lazy loading queries do not propagate cache-related settings from the original query. Even when the original query explicitly disables bean caching using:

query.setBeanCacheMode(CacheMode.OFF);

the corresponding lazy loading queries still execute with CacheMode.AUTO (the default).

Conceptually, it seems safer to completely disable the bean cache for asOf() queries and ignore related cache configuration options, as caching and temporal consistency are fundamentally at odds in this case.

Additionally, there currently seems to be no way to explicitly configure caching behavior for lazy loading queries. Would it make sense to propagate cache-related options from the parent query to all lazy loading queries?

[rbygrave]

propagate cache-related options from the parent query to all lazy loading queries?

Are you sure that isn't happening? Can you show some evidence via logging? What version of ebean are you using?

[dragkes]

Sure, here is an example. Version is 17.2.0

@Cache(nearCache = true)
@Entity
public class TestOne extends Model {

    @Id
    private UUID id;
    private String field;

    @OneToOne(mappedBy = "testOne", cascade = CascadeType.ALL)
    private TestTwo testTwo;

    public TestOne(String field) {this.field = field;}
    public TestTwo getTestTwo() {return testTwo;}
    public void setTestTwo(TestTwo testTwo) {this.testTwo = testTwo;}
    public String getField() {return field;}
    public void setField(String field) {this.field = field;}
    public UUID getId() {return id;}
    public void setId(UUID id) {this.id = id;}
}

@Cache(nearCache = true)
@Entity
public class TestTwo extends Model {

    @Id
    private UUID id;
    private String field;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn
    private TestOne testOne;

    public TestTwo(String field) {this.field = field;}
    public TestOne getTestOne() {return testOne;}
    public void setTestOne(TestOne testOne) {this.testOne = testOne;}
    public String getField() {return field;}
    public void setField(String field) {this.field = field;}
    public UUID getId() {return id;}
    public void setId(UUID id) {this.id = id;}
}

    @Test
    void testLazyLoadingCacheBehavior() {

        TestOne testOne = new TestOne("b0");
        TestTwo testTwo = new TestTwo("b1");
        testOne.setTestTwo(testTwo);
        testTwo.setTestOne(testOne);
        testTwo.save();

        new QTestOne()
            .id.eq(testOne.getId())
            .findOne(); // triggers bean cache save

        System.out.println("Expecting cache hit for lazy-loaded association");
        TestTwo loadedTestTwo = new QTestTwo()
            .id.eq(testTwo.getId())
            .findOne();
        assertNotNull(loadedTestTwo, "Loaded TestTwo should not be null");

        TestOne associatedOne = loadedTestTwo.getTestOne();
        assertNotNull(associatedOne, "Lazy-loaded TestOne should not be null");

        String fieldValue = associatedOne.getField(); // trigger lazy load
        EntityBeanIntercept interceptCached = ((EntityBean) associatedOne)._ebean_intercept();
        assertTrue(interceptCached.isLoadedFromCache(),
            "Lazy-loaded TestOne should have been loaded from cache");

        System.out.println("Expecting no cache hit for lazy-loaded association with CacheMode.OFF");
        loadedTestTwo = new QTestTwo()
            .setBeanCacheMode(CacheMode.OFF)
            .id.eq(testTwo.getId())
            .findOne();
        assertNotNull(loadedTestTwo, "Loaded TestTwo should not be null even with cache disabled");

        associatedOne = loadedTestTwo.getTestOne();
        assertNotNull(associatedOne, "Lazy-loaded TestOne should not be null");

        fieldValue = associatedOne.getField(); // trigger lazy load
        EntityBeanIntercept interceptNoCache = ((EntityBean) associatedOne)._ebean_intercept();
        assertFalse(interceptNoCache.isLoadedFromCache(),
            "Lazy-loaded TestOne should NOT have been loaded from cache");
    }

Output:

23:45:00.742 [main] DEBUG io.ebean.SUM - txn[1001] BatchControl flush [TestOne:0 i:1]
23:45:00.748 [main] DEBUG io.ebean.SQL - txn[1001] insert into test_one (id, field) values (?,?)
23:45:00.748 [main] DEBUG io.ebean.SQL - txn[1001]  -- bind(4bd45e22-04ea-44af-a814-cf194e8cc7e3,b0)
23:45:00.752 [main] DEBUG io.ebean.SQL - txn[1001]  -- executeBatch() size:1 sql:insert into test_one (id, field) values (?,?)
23:45:00.752 [main] DEBUG io.ebean.SUM - txn[1001] Inserted [TestOne] [4bd45e22-04ea-44af-a814-cf194e8cc7e3]
23:45:00.752 [main] DEBUG io.ebean.SQL - txn[1001] insert into test_two (id, field, test_one_id) values (?,?,?); -- bind(103e643e-f9f7-4a08-a587-d0c9b45442ee,b1,4bd45e22-04ea-44af-a814-cf194e8cc7e3)
23:45:00.754 [main] DEBUG io.ebean.SUM - txn[1001] Inserted [TestTwo] [103e643e-f9f7-4a08-a587-d0c9b45442ee]
23:45:00.755 [main] DEBUG io.ebean.TXN - txn[1001] Commit
23:45:00.755 [ebean-db1] DEBUG io.ebean.cache.TABLEMOD - TableModState updated - touched:[test_one, test_two] modTime:2025-12-16T20:45:00.755085800Z
23:45:00.756 [ebean-db1] DEBUG io.ebean.cache.TABLEMOD - ServerCacheNotification:tables:[test_one, test_two]
23:45:00.756 [ebean-db1] DEBUG io.ebean.cache.TABLEMOD - TableModState updated - touched:[test_one, test_two] modTime:2025-12-16T20:45:00.756092900Z
23:45:00.768 [main] TRACE io.ebean.cache.BEAN -    GET TestOne(4bd45e22-04ea-44af-a814-cf194e8cc7e3) - cache miss
23:45:00.781 [main] DEBUG io.ebean.SQL - select /* LazyTest.testLazyLoadingCacheBehavior */ t0.id, t0.field, t1.id from test_one t0 left join test_two t1 on t1.test_one_id = t0.id where t0.id = ?; --bind(4bd45e22-04ea-44af-a814-cf194e8cc7e3, ) --micros(1а115)
23:45:00.783 [main] DEBUG io.ebean.SUM - FindBean type[TestOne] origin[xj36t.A.A] exeMicros[2575] rows[1] bind[4bd45e22-04ea-44af-a814-cf194e8cc7e3, ]
23:45:00.783 [main] DEBUG io.ebean.cache.BEAN -    PUT TestOne(4bd45e22-04ea-44af-a814-cf194e8cc7e3) data:{id=4bd45e22-04ea-44af-a814-cf194e8cc7e3, field=b0, testTwo=103e643e-f9f7-4a08-a587-d0c9b45442ee}
Expecting cache hit for lazy-loaded association
23:45:00.793 [main] TRACE io.ebean.cache.BEAN -    GET TestTwo(103e643e-f9f7-4a08-a587-d0c9b45442ee) - cache miss
23:45:00.794 [main] DEBUG io.ebean.SQL - select /* LazyTest.testLazyLoadingCacheBehavior */ t0.id, t0.field, t0.test_one_id from test_two t0 where t0.id = ?; --bind(103e643e-f9f7-4a08-a587-d0c9b45442ee, ) --micros(296)
23:45:00.794 [main] DEBUG io.ebean.SUM - FindBean type[TestTwo] origin[BNvk-L.A.A] exeMicros[486] rows[1] bind[103e643e-f9f7-4a08-a587-d0c9b45442ee, ]
23:45:00.794 [main] DEBUG io.ebean.cache.BEAN -    PUT TestTwo(103e643e-f9f7-4a08-a587-d0c9b45442ee) data:{id=103e643e-f9f7-4a08-a587-d0c9b45442ee, field=b1, testOne=4bd45e22-04ea-44af-a814-cf194e8cc7e3}
23:45:00.797 [main] TRACE io.ebean.cache.BEAN -    MLOAD TestOne([4bd45e22-04ea-44af-a814-cf194e8cc7e3]) - got hits (1)
23:45:00.798 [main] DEBUG io.ebean.cache.BEAN -    load TestOne(4bd45e22-04ea-44af-a814-cf194e8cc7e3) - hit
Expecting no cache hit for lazy-loaded association with CacheMode.OFF
23:45:00.798 [main] DEBUG io.ebean.SQL - select /* LazyTest.testLazyLoadingCacheBehavior */ t0.id, t0.field, t0.test_one_id from test_two t0 where t0.id = ?; --bind(103e643e-f9f7-4a08-a587-d0c9b45442ee, ) --micros(122)
23:45:00.798 [main] DEBUG io.ebean.SUM - FindBean type[TestTwo] origin[BNvk-L.A.A] exeMicros[274] rows[1] bind[103e643e-f9f7-4a08-a587-d0c9b45442ee, ]
23:45:00.800 [main] TRACE io.ebean.cache.BEAN -    MGET TestOne([4bd45e22-04ea-44af-a814-cf194e8cc7e3]) - hits:[4bd45e22-04ea-44af-a814-cf194e8cc7e3]
[ERROR] Tests run: 1, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 1.467 s <<< FAILURE! -- in org.example.integration.LazyTest
[ERROR] org.example.integration.LazyTest.testLazyLoadingCacheBehavior -- Time elapsed: 1.451 s <<< FAILURE!
org.opentest4j.AssertionFailedError: Lazy-loaded TestOne should NOT have been loaded from cache ==> expected: <false> but was: <true>

[dragkes]

It also appears that setIncludeSoftDeletes() does not work as expected with asOf() queries. Soft-deleted rows seem to be always included in the result set when using asOf(), regardless of the includeSoftDeletes setting.

The behavior seems to come from the following code in CQueryBuilder (around line 325):

if (query.isAsOfQuery()) {
      sqlTree.addAsOfTableAlias(query);
} else if (SpiQuery.TemporalMode.CURRENT == query.temporalMode()) {
      sqlTree.addSoftDeletePredicate(query);
}

Because the soft-delete predicate is only applied when TemporalMode.CURRENT is used, it is skipped entirely for TemporalMode.AS_OF.

Is there a specific reason why TemporalMode.AS_OF and soft-delete handling are treated as mutually exclusive? Conceptually, asOf() queries represent the state of the table at a specific point in time, and it seems reasonable to expect that soft-delete filtering could still be applied on top of that temporal snapshot - either including or excluding soft-deleted rows depending on setIncludeSoftDeletes().