[Extension Proposal] Quarkus Qubit

[ebramirez]

Description

Qubit transforms lambda expressions into JPA Criteria Queries at build time for Panache entities:

• Type-safe: Full IDE support with compile-time verification
• Zero overhead: Queries are pre-compiled, not interpreted at runtime
• Fluent API: JINQ-inspired method chaining for readable queries

This allows you to write queries like this for the Active Record pattern:

@Entity
public class Person extends QubitEntity {
    public String firstName;
    public int age;
    public boolean active;
}

List<Person> adults = Person.where((Person p) -> p.age >= 18).toList();

Or if you prefer, you can use the Repository Pattern:

@ApplicationScoped
public class PersonRepository implements QubitRepository<Person, Long> {
}

@Inject PersonRepository personRepository;

// Filtering
List<Person> adults = personRepository.where(p -> p.age >= 18).toList();

// Projection to DTO
List<PersonDTO> dtos = personRepository
    .where(p -> p.active)
    .select(p -> new PersonDTO(p.firstName, p.lastName))
    .toList();

// Aggregation
Double avgSalary = personRepository.avg(p -> p.salary).getSingleResult();

If interested in this extension, please +1 via the emoji/reaction feature of GitHub (top right).

Repository name

quarkus-qubit

Short description

A Quarkus extension that enables type-safe, lambda-based queries on Panache entities with build-time transformation to JPA Criteria Queries.

Repository Homepage URL

https://docs.quarkiverse.io/quarkus-qubit/dev/

Repository Topics

• quarkus-extension
• database
• lambdas
• queries
• jpa
• panache

Team Members

• Eduardo Ramírez eramirez@redhat.com

Additional context

No response

[quarkus-bot]

/cc @aloubyansky (extension-proposal), @gastaldi (extension-proposal), @gsmet (extension-proposal)

[gastaldi]

Interesting, I wonder why this isn't part of Panache core instead, any thoughts @FroMage ?

[ebramirez]

Interesting, I wonder why this isn't part of Panache core instead, any thoughts @FroMage ?

I would happily contribute the code I have to Panache if necessary, although I would first create it as a separate extension and if everyone likes it, then merge it.

[FroMage]

Sounds interesting. What do you think @gavinking ?

[gavinking]

I've seen a couple of things like this pop up recently (for example ExoQuery but that is Kotlin-specific). Definitely an approach I like and that has potential.

[gavinking]

What is the idea here though, I can't tell from the issue description. Are we talking bytecode processing or something more graalvm-based?

[ebramirez]

What is the idea here though, I can't tell from the issue description. Are we talking bytecode processing or something more graalvm-based?

@gavinking the implementation I have right now processes the lambda's bytecode and outputs JPA queries using Gizmo 2.

[geoand]

I believe that @Ladicek and @dmlloyd will also be interested in how you've used Gizmo2 in this case.

[FroMage]

You've shown examples where the Java operators map to the HQL operators, such as >=, but how do you write joins, fetches, or operators and functions that don't exist in Java?

[ebramirez]

Hi @FroMage,

I've tried to map as many Java to SQL bridges as I could, most of them as methods in the augmented entity/repository.

Here's an example of a join query:

@ApplicationScoped
public class OrderRepository implements QubitRepository<Order, Long> {
}

@Inject
OrderRepository orderRepository;

List<Order> ordersWithDeliveredShipments = orderRepository.join(o -> o.shipments)
               .where((o, s) -> s.status == ShipmentStatus.DELIVERED)
               .distinct()
               .toList();

[ebramirez]

I'm sorry to insist, but what is the status of this request?