What Is a Named Query

Difference between query, native query, named query and typed query

Query

Query refers to JPQL/HQL query with syntax similar to SQL generally used to execute DML statements(CRUD operations).

In JPA, you can create a query using entityManager.createQuery(). You can look into API for more detail.

In Hibernate, you use session.createQuery()"

NativeQuery

Native query refers to actual sql queries (referring to actual database objects). These queries are the sql statements which can be directly executed in database using a database client.

JPA : entityManager.createNativeQuery()
Hibernate (Non-JPA implementation): session.createSQLQuery()

NamedQuery

Similar to how the constant is defined. NamedQuery is the way you define your query by giving it a name. You could define this in mapping file in hibernate or also using annotations at entity level.

TypedQuery

TypedQuery gives you an option to mention the type of entity when you create a query and therefore any operation thereafter does not need an explicit cast to the intended type. Whereas the normal Query API does not return the exact type of Object you expect and you need to cast.

Why do I need to put @NamedQuery on Entity class?

The GuestServlet is not managed by your jpa provider. Hibernate (or whatever) simply isn't aware of the named query.

JPA/Hibernate: Named Query vs Native Query | Which one to use?

It is not a named vs native at all, as you can have named native queries. Native are SQL queries, while non-native, in JPA world, refer to using JPQL - a different query language based off of your java entities. Which you choose depends on your application requirements, as generally more DB specific functionality can only be accessed through DB specific (native) SQL.

I personally don't like having to search through SQL queries to find them all over the application code and figure out problems when changing the model in ways that affects the schema - using JPQL lets JPA validate queries against the model upfront instead of having to execute the SQL queries against a DB. And the developers I have worked with don't always understand or work with the SQL tables, so JPQL is a bit closer to the data in the format (java objects) they work with. It also reduces problems/risks with people using string concat to build SQL queries, and using some customer defined value in that query string - a common vector for SQL injection attacks.

Hibernate named queries and its performance advantage?

Named queries have two small advantages:

their syntax is checked when the session factory is created, making the application fail fast in case of an error (which probably indicates that your application lacks some unit tests)
they can be accessed and used from several places (which probably indicates a design problem anyway)

They also have a drawback: when reading or debugging code using a named query, you can"t immediately see which query is being executed without searching for its definition.

The rest is really unimportant:

the cost of transforming a HQL query to SQL is negligible compared to the cost of actually executing the query
the memory cost of caching the query is really small. Remember that Hibernate needs to have all the entities meta-data in memory anyway.

I tend to prefer defining the query in the code where it's used, and to unit test them. That makes the code more readable, and more robust.

JPA Named query

Use

SELECT x FROM Payment x 
WHERE x.amount > (SELECT AVG(p.amount) from Payment p)

Your subquery is

SELECT AVG(x.amount) from Payment

, and x is not defined.