What causes "Not supported yet upstream" in quarkusio/quarkus?

Do not use Hibernate filters with reactive stateless sessions; encode the filter conditions in the HQL/JPQL query itself (e.g. extra WHERE clause).

quarkusio/quarkus · error · UnsupportedOperationException

Not supported yet upstream

Error message

Not supported yet upstream

What it means

CommonStatelessPanacheQueryImpl.enableFilter for Hibernate Reactive stateless sessions is an unimplemented stub marked FIXME; it throws UnsupportedOperationException("Not supported yet upstream"). The upstream Hibernate Reactive Mutiny.StatelessSession API does not provide the enableFilter capability needed, so the Panache feature is disabled. Any call fails unconditionally.

Solutions

Do not use Hibernate filters with reactive stateless sessions; encode the filter conditions in the HQL/JPQL query itself (e.g. extra WHERE clause).
Use a repository/DAO method parameter for the condition instead of a session-wide filter.
If managed (non-stateless) reactive sessions are acceptable, use the stateful Panache API path where filters may be supported.
Track upstream Hibernate Reactive StatelessSession filter support and re-enable after upgrade.

Example fix

// before
query.enableFilter("tenantFilter"); // UnsupportedOperationException

// after
List<Entity> list = Entity.find("tenantId = ?1", tenantId).list();

Defensive patterns

Strategy: validation

Validate before calling

// guard feature availability at startup
if (session instanceof Mutiny.StatelessSession) { throw new IllegalStateException("Filters unsupported on reactive stateless sessions"); }

Try / catch

try { query.enableFilter("tenantFilter"); } catch (UnsupportedOperationException e) { fallbackToQueryParamFilter(); }

Prevention

Encode filter conditions directly in HQL/JPQL where clauses on reactive stateless sessions
Do not port Hibernate @Filter usage to reactive stateless code paths
Use repository-level parameters for multi-tenant filtering

When it happens

Trigger: Calling enableFilter(...) (directly or via Panache filter APIs) on a stateless-session-backed Hibernate Reactive Panache query.

Common situations: Porting code that uses @FilterDef/@Filter or Filter.compile(...).enableFilter(...) from blocking Panache to reactive stateless sessions; tenant-filtering patterns built on Hibernate filters.

Related errors

AI-assisted analysis of quarkusio/quarkus@e1c734241f (2026-09-05). Data as JSON: /api/errors/0ae5e14dec18362f. Report an issue: GitHub.

Appendix: source

Thrown at extensions/panache/hibernate-reactive-panache-common/runtime/src/main/java/io/quarkus/hibernate/reactive/panache/common/runtime/CommonStatelessPanacheQueryImpl.java:38

            String customCountQueryForSpring, Class<?> projectionType) {
        super(previousQuery, newQueryString, customCountQueryForSpring, projectionType);
    }

    @Override
    public <NewEntity> CommonStatelessPanacheQueryImpl<NewEntity> project(Class<NewEntity> type) {
        return (CommonStatelessPanacheQueryImpl<NewEntity>) super.project(type);
    }

    @Override
    protected <T> CommonAbstractPanacheQueryImpl<T, Mutiny.StatelessSession> newQuery(String query,
            String customCountQueryForSpring, Class<T> type) {
        return new CommonStatelessPanacheQueryImpl<>(this, query, customCountQueryForSpring, type);
    }

    @Override
    protected Filter enableFilter(Mutiny.StatelessSession session, String filter) {
        // FIXME
        throw new UnsupportedOperationException("Not supported yet upstream");
        //        return session.enableFilter(filter);
    }

    @Override
    protected void disableFilter(Mutiny.StatelessSession session, String filter) {
        // FIXME
        throw new UnsupportedOperationException("Not supported yet upstream");
        //        session.disableFilter(filter);
    }
}

View on GitHub (pinned to e1c734241f)