Java.Hibernate.Medium.Give examples of different types of queries ?

✅ Short Answer

Alternatives to named queries include:

• Dynamic JPQL queries created at runtime with createQuery().
• Criteria API, which builds type-safe queries programmatically.
• Native SQL queries for complex or DB-specific needs.
• Framework-specific solutions (e.g., Spring Data JPA repository methods with query derivation or @Query).

---

🔎 Detailed Explanation

🔹 Dynamic JPQL Queries

• You can write JPQL strings at runtime without defining them upfront as named queries.
• Useful for ad-hoc or flexible queries you don’t reuse frequently.
• Example: javaCopyEdit

String jpql = "SELECT e FROM MyEntity e WHERE e.status = :status";
List<MyEntity> results = session.createQuery(jpql, MyEntity.class)
                                .setParameter("status", "ACTIVE")
                                .getResultList();

🔹 Criteria API

• Lets you build queries programmatically in a type-safe way — great for dynamic or complex queries.
• Reduces risk of syntax errors and eases refactoring because field names are checked at compile time.
• Example:

CriteriaBuilder cb = session.getCriteriaBuilder();
CriteriaQuery<MyEntity> cq = cb.createQuery(MyEntity.class);
Root<MyEntity> root = cq.from(MyEntity.class);
cq.select(root).where(cb.equal(root.get("status"), "ACTIVE"));
List<MyEntity> results = session.createQuery(cq).getResultList();

🔹 Native SQL Queries

• Use createNativeQuery() to write raw SQL when JPQL isn’t expressive enough or you need DB-specific features.
• Example:

String sql = "SELECT * FROM my_entity WHERE status = :status";
List<MyEntity> results = session.createNativeQuery(sql, MyEntity.class)
                                .setParameter("status", "ACTIVE")
                                .getResultList();

🔹 Spring Data JPA Alternatives

• Query derivation: define methods like findByStatus(String status) → Spring auto-generates queries.
• @Query annotation: define ad-hoc JPQL or native queries directly in repository interfaces:

@Query("SELECT e FROM MyEntity e WHERE e.status = :status")
List<MyEntity> findByStatus(@Param("status") String status);

📌 Key Differences Between Named Queries and Dynamic JPQL

Feature	Named Queries	Dynamic JPQL
Definition	Defined upfront via annotations/XML	Built on the fly in code
Validation	Validated at startup	Validated when executed at runtime
Reuse	Easy to reuse across app	Typically ad-hoc use
Flexibility	Fixed query string	Fully dynamic

📌 Key Takeaways

✅ Named queries are great for static, frequently used queries.
✅ Dynamic JPQL is better for flexible or parameterized queries you don’t reuse much.
✅ Criteria API is ideal for type-safe dynamic queries.
✅ Native SQL covers complex DB-specific queries.
✅ Frameworks like Spring Data JPA offer powerful alternatives like derived queries or @Query.