Menu

JPQL and its uses in JPA

JPQL and its uses in JPA

JPQL is a query language used for making queries against entities stored in a relational database. It is similar to SQL but operates on the entity objects and their relationships rather than directly on database tables and columns. JPQL is part of the Java Persistence API (JPA) and is used to perform operations like querying, updating, and deleting entity objects.

JPQL and its uses in JPA

Key Features of JPQL:

  • 1.  Object-Oriented : JPQL queries operate on entity objects and their relationships.
  • 2.  Database-Agnostic : JPQL is independent of the underlying database and relies on entity mappings.
  • 3.  Integration with JPA : JPQL is fully integrated with JPA, allowing for seamless persistence and retrieval of entity data.

How is JPQL Used in JPA?

  • 1.  Defining a JPQL Query :
    • JPQL queries are defined as strings and can be either static (defined in annotations or XML) or dynamic (created at runtime).
  • 2.  Executing a JPQL Query :
    • JPQL queries are executed using the EntityManager interface in JPA. The EntityManager provides methods to create and execute JPQL queries.
  • 3.  Query Parameters :
    • JPQL supports both positional and named parameters for dynamic query building.

Example in Java

Let’s create an example to demonstrate how JPQL is used in JPA.

1. Entity Class
java
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

2. Defining a Named JPQL Query
java
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;

@Entity
@NamedQuery(name = "User.findByEmail", query = "SELECT u FROM User u WHERE u.email = :email")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

In this example, a named JPQL query User.findByEmail is defined to find a user by their email.

3. Using JPQL in Application Code
java
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.TypedQuery;
import java.util.List;

public class UserService {
    
    private EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-persistence-unit");
    private EntityManager em = emf.createEntityManager();

    public User findUserByEmail(String email) {
        TypedQuery<User> query = em.createNamedQuery("User.findByEmail", User.class);
        query.setParameter("email", email);
        return query.getSingleResult();
    }

    public List<User> findAllUsers() {
        TypedQuery<User> query = em.createQuery("SELECT u FROM User u", User.class);
        return query.getResultList();
    }

    public void addUser(String name, String email) {
        em.getTransaction().begin();
        User user = new User();
        user.setName(name);
        user.setEmail(email);
        em.persist(user);
        em.getTransaction().commit();
    }

    public void close() {
        em.close();
        emf.close();
    }

    public static void main(String[] args) {
        UserService userService = new UserService();
        
        // Adding users
        userService.addUser("John Doe", "john.doe@example.com");
        userService.addUser("Jane Smith", "jane.smith@example.com");

        // Finding a user by email
        User user = userService.findUserByEmail("john.doe@example.com");
        System.out.println("Found User: " + user.getName() + ", Email: " + user.getEmail());

        // Finding all users
        List<User> users = userService.findAllUsers();
        users.forEach(u -> System.out.println("User: " + u.getName() + ", Email: " + u.getEmail()));

        userService.close();
    }
}

In this example, the UserService class demonstrates how to use JPQL to perform CRUD operations. The findUserByEmail method uses a named JPQL query, while the findAllUsers method uses a dynamic JPQL query to retrieve all users.

Homepage

Readmore