Master Hibernate and JPA with Spring Boot in 100 Steps - Step 20 - Native Queries-Basics

The video tutorial explores the use of native queries in JPA, contrasting them with JPQL. It covers the basics of executing native queries, including how to use parameters for more advanced operations. The tutorial also discusses scenarios where native queries are preferable, such as when using database-specific features or performing mass updates. The importance of transactions and persistence context in executing updates is highlighted.

What is a native query in JPA?

• A query that updates multiple tables at once

• A direct SQL query executed from JPA

• A query written in JPQL

• A query that uses only named parameters

How does a basic native query differ from a JPQL query?

• It cannot be executed in JPA

• It requires a different database connection

• It uses SQL syntax directly

• It uses entity names instead of table names

What is the purpose of mapping the result set to an entity in a native query?

• To automatically update the database

• To ensure the query executes faster

• To convert the result set into a Java object

• To avoid using SQL syntax

What is a named parameter in the context of native queries?

• A parameter that is used only in JPQL

• A parameter identified by a name instead of a position

• A parameter that cannot be changed

• A parameter that is always set to null

In which scenario would you prefer using a native query over JPQL?

• When you need to perform a mass update

• When you want to use only named parameters

• When you are working with a small dataset

• When you need to avoid using SQL syntax

Why might you need to refresh entities in the persistence context after executing a native query?

• To ensure the entities reflect the latest database state

• To improve query performance

• To avoid using named parameters

• To automatically commit the transaction

What is a potential drawback of using native queries for mass updates?

• They cannot update more than one row at a time

• They require a separate database connection

• They do not use the persistence context

• They are slower than JPQL queries