Java Persistence API (JPA) Tutorials

JPA Named Query Examples

2018-06-25T20:10:13-05:00

This tutorial guides you how to use named queries in Java Persistence API (JPA). Basically you execute a query in JPA like this:

String jpql = "SELECT u from User u";

Query query = entityManager.createQuery(jpql);

List<User> result = query.getResultList();

for (User user : result) {
	System.out.println(user);
}

This approach is perfect for simple applications that have only a small number of queries. What if your application becomes larger with tens or hundreds queries scattered in many classes? Then imagine the nightmare of maintaining such a large number of queries in your fat code base. Therefore, JPA provides the concept of named queries to make programmer’s life easier: you can group related queries in one place (usually in model classes) and refer them in your code by their names - hence the term named queries. Below is an example:

String queryName = "User.findAll";
Query query = entityManager.createNamedQuery(queryName);

List<User> listUsers = query.getResultList();

Here, the query name “User.findAll” refers to a query which can be stored in a relevant domain model class like this:

@Entity
@Table(name = "USERS")

@NamedQueries({
	
	@NamedQuery(name = "User.findAll", query = "SELECT u FROM User u ORDER BY u.fullname")
	
})
public class User {
	private Integer id;
	private String fullname;
	private String email;
	private String password;

	...
	...
}

As you can see, there are two annotations are used for named query: @NamedQueries annotation consists of a set of @NameQuery annotations with each define a specific JPQL query:

@NamedQueries({
	
	@NamedQuery(name = "User.findAll", query = "SELECT u FROM User u ORDER BY u.fullname")
	
})

To specify multiple named queries, separate the @NameQuery annotations by commas:

@NamedQueries({
	
	@NamedQuery(name = "User.findAll", query = "SELECT u FROM User u ORDER BY u.fullname"),
	@NamedQuery(name = "User.count", query = "SELECT COUNT(*) FROM User u"),
	@NamedQuery(name = "User.removeAll", query = "DELETE FROM User u")
	
})

The following code illustrates how to execute the named query User.count above:

Query query = entityManager.createNamedQuery("User.count");
long count = (long) query.getSingleResult();

And the following example executes the named query User.removeAll above:

entityManager.getTransaction().begin();

Query query = entityManager.createNamedQuery("User.removeAll");
query.executeUpdate();

entityManager.getTransaction().commit();

Using Named Query with Parameters:

If your query consists of parameters, you can use the setParameter(name, value) or setParameter(position, value) to set values for the parameters dynamically.

For example, consider the following named query that contains one parameter named email:

@NamedQuery(name = "User.findByEmail", query = "SELECT u FROM User u WHERE u.email = :email")

The following code sets parameter for this query and executes it (set values for parameters by their names):

String queryName = "User.findByEmail";
String email = "tom@gmail.com";

Query query = entityManager.createNamedQuery(queryName);
query.setParameter("email", email);

User user = (User) query.getSingleResult();

And this named query has two positional parameters:

@NamedQuery(name = "User.checkLogin", query = "SELECT u FROM User u WHERE u.email = ?1 AND password = ?2")

And the following code sets values for the positional parameters above:

String queryName = "User.checkLogin";
String email = "tom@gmail.com";
String pass = "tomsecret1";

Query query = entityManager.createNamedQuery(queryName);
query.setParameter(1, email);
query.setParameter(2, pass);

User user = (User) query.getSingleResult();

It’s recommended to use name-based parameters for the readability of your code.

Named Queries Stored in XML:

Besides embedding named queries in model classes, you can also store named queries in a separate XML file. For example, create queries.xml file under META-INF directory with the following content:

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings version="2.0" xmlns="http://java.sun.com/xml/ns/persistence/orm"
	 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm 
 		http://java.sun.com/xml/ns/persistence/orm_2_0.xsd "
>
	<named-query name="WhoUsingGmail">
		<query>SELECT u FROM User u WHERE u.email LIKE '%gmail%'</query>
	</named-query>
	
	<named-query name="WhoNotSetPassword">
		<query>SELECT u FROM User u WHERE u.password is null</query>
	</named-query>

</entity-mappings>

And tell JPA to load this XML file in the persistence.xml file like this:

…
<persistence-unit name="UsersDB">
	
	<mapping-file>META-INF/queries.xml</mapping-file>
	
	<properties>
	
		...
	</properties>	
</persistence-unit>
…

Then you can use named queries in your code normally. This configuration is more flexible as we don’t have to re-compile the code when making changes to the queries.

References:

Query Javadocs

EntityManager Javadocs

How to fix error Unknown database in Hibernate/JPA

2019-06-04T01:36:51-05:00

When developing Java applications that use Hibernate/JPA, you may encounter this error:

Unknown database ‘dbname’

This error usually occurs when you import a project to your computer and the database name it uses is different than the database name on your computer. You change the database name but it doesn’t solve the problem.

The exception stack trace would look like this:

javax.persistence.PersistenceException: org.hibernate.exception.SQLGrammarException: could not execute statement
	at org.hibernate.internal.ExceptionConverterImpl.convert(ExceptionConverterImpl.java:149)
	...
Caused by: org.hibernate.exception.SQLGrammarException: could not execute statement
	at org.hibernate.exception.internal.SQLExceptionTypeDelegate.convert(SQLExceptionTypeDelegate.java:63)
	...
Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Unknown database 'bookstore'
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)	
	...

The real cause of the error is Unknown database ‘bookstore’. The database name is configured in the persistence.xml file like this:

<?xml version="1.0" encoding="UTF-8"?>
<persistence...>

	<persistence-unit name="BookStore">
		<properties>
			<property name="javax.persistence.jdbc.url"
				value="jdbc:mysql://localhost:3306/bookstoredb" />
			...
		</properties>
	</persistence-unit>

</persistence>

You check the database name in the JDBC URL and it is absolutely correct – But the error still occurs. It still mentions the old database name. You don’t understand why - spending hours to find what went wrong but you’re totally lost!

I was in such situation and nearly got upset about that problem. Fortunately, I figured out that there’s another location in which the database name is used. It is in the model classes, for example:

@Entity
@Table(name = "category", catalog = "bookstore"...)
public class Category implements java.io.Serializable {
	...
}

Here, you can see the catalog attribute of the @Table annotation refers to the database name. Voila!

This code maybe generated by Hibernate Reverse Engineering tool, so you don’t notice. So to solve the error, you have to either:

Update the database name in the catalog attribute in the model classes, or
Delete all the catalog attribute in the model classes.

Then the error Unknown database error will be solved.

How to fix JPA Problem: This project has JPA facet, but no JPA project could be created

2019-05-11T01:45:04-05:00

When developing Java projects that use Hibernate/JPA, you may encounter this error in Eclipse IDE:

This project has the JPA facet, but no JPA project could be created. See the error log for more details.

This error looks like this in the Markers view in Eclipse:

To solve this problem, right click on your project, click Properties in the context menu. In the Project Properties dialog, click Project Facets on the left tree. Then in the list on the right, uncheck the option JPA:

Click Apply and Close. You see the error is still there. Now right-click on the project and click Validate command in the context menu:

The error JPA problem will be gone. Happy coding!

[Fixed] No Persistence provider for EntityManager named XXX

2021-11-06T08:01:16-05:00

In this post, I’d like to share some solutions that fix the following error in Java development with Hibernate/JPA:

Caused by: javax.persistence.PersistenceException: No Persistence provider for EntityManager named XXX
	at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:61)
	at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:39)

where XXX is the persistence unit name declared in the persistence.xml file of your project, something like this:

<?xml version="1.0" encoding="UTF-8"?>
<persistence ...>
	
	<persistence-unit name="BookstoreWebsite">
		<properties>
			...
		</properties>
	</persistence-unit>
	
</persistence>

Here are 4 different causes of this error, and how to fix in each case:

1. Persistent unit name in code does not match the one in JPA config file

In Java code, the persistence unit name is specified like this:

entityManagerFactory = Persistence.createEntityManagerFactory("BookStoreWebsite");

But in the persistence.xml file, it is declared like this:

the persistence.xml file, it is declared like this:
<?xml version="1.0" encoding="UTF-8"?>
<persistence ...>
	
	<persistence-unit name="BookstoreWebsite">
		<properties>
			...
		</properties>
	</persistence-unit>
	
</persistence>

Do you see the difference? It is the letter s/S in Bookstore. So check persistence name in both code and XML file carefully - ensure that they are the same.

2. Typos in name of JPA config file

The name of JPA config file must be persistence.xml, but somehow you name it slightly different, e.g. peristence.xml - a letter s is missing. So check typos in file name to make sure it is persistence.xml exactly.

3. JPA Config file is not in the right location

By default, the persistence.xml file must be present in the classpath, under src/META-INF folder of the project, as shown below:

So make sure that you put the JPA config file in the right location.

4. Incompatible Hibernate core version

Another cause of the error No Persistence provider for EntityManager named XXX is the version of Hibernate core dependency in your project. For example, hibernate-core-5.0.12 is known to cause this kind of error, whereas hibernate-core-5.2.12 works fine.

So try to use different the version of Hibernate core if you encounter this problem.

5. Wrong Dependency Declaration of Hibernate core

Another reason that causes the error No Persistence provider for Entity Manager is the delcared type and scope of Hibernate core dependency is like this:

<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>6.0.0.Final</version>
  <type>pom</type>
  <scope>compile</scope>
</dependency>

Remove this kind of type (pom) and scope (compile), and the error will be resolved.

Okay, so far I’ve shared with you guys, 4 solutions which you could consider to fix the error No Persistence provider for EntityManager named XXX. Hope you find this post helpful.