Native SQL queries in Spring Boot - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a native SQL query in Spring Boot?

A native SQL query is a SQL statement written directly in the database's SQL language, executed through Spring Boot without translation to JPQL or HQL. It allows direct control over the SQL sent to the database.

beginner

How do you define a native SQL query in a Spring Data JPA repository?

Use the @Query annotation with the attribute nativeQuery = true. For example: @Query(value = "SELECT * FROM users", nativeQuery = true) List<User> findAllUsers();

intermediate

Why might you choose a native SQL query over JPQL in Spring Boot?

You might choose native SQL for complex queries not supported by JPQL, to use database-specific features, or for performance optimizations.

intermediate

What is a key risk when using native SQL queries?

Native SQL queries can be database-specific, reducing portability. They also increase risk of SQL injection if parameters are not handled safely.

beginner

How do you safely pass parameters to a native SQL query in Spring Boot?

Use named or positional parameters with @Param annotation and let Spring handle binding. Avoid string concatenation to prevent SQL injection.

Which annotation attribute enables native SQL in Spring Data JPA?

A sqlNative = true

B nativeQuery = true

C native = true

D queryType = native

The @Query annotation uses nativeQuery = true to specify a native SQL query.

What is a benefit of using native SQL queries?

A They automatically prevent SQL injection

B They are always database independent

C They allow use of database-specific features

D They replace the need for repositories

Native SQL queries allow you to use features specific to your database.

How should parameters be passed to native SQL queries to avoid SQL injection?

A Use @Param annotation with named parameters

B Concatenate strings manually

C Use raw string interpolation

D Pass parameters as plain text in the query

Using @Param with named parameters lets Spring safely bind values and prevents injection.

What happens if you omit nativeQuery = true in @Query with SQL syntax?

A The query runs as native SQL anyway

B The query runs twice

C Spring ignores the query

D Spring treats it as JPQL and may cause errors

Without nativeQuery = true, Spring treats the query as JPQL, which may not support SQL syntax.

Which of these is a risk of using native SQL queries?

A They reduce database portability

B They cannot return entity objects

C They automatically sanitize inputs

D They always run slower than JPQL

Native SQL queries may use database-specific syntax, reducing portability.

Explain how to create and use a native SQL query in a Spring Boot repository.

Think about the annotation and parameter binding.

Describe the advantages and risks of using native SQL queries in Spring Boot.

Consider both benefits and security concerns.

Practice

1. What annotation is used in Spring Boot to define a native SQL query inside a repository interface?

easy

A. @SqlQuery

B. @NativeQuery

C. @Query with nativeQuery = true

D. @SQLNative

Solution

1. Step 1: Recognize the annotation for queries in Spring Data JPA

   The @Query annotation is used to define custom queries in repository interfaces.

2. Step 2: Identify how to specify native SQL

   Setting nativeQuery = true inside @Query tells Spring Boot to treat the query as native SQL.

3. Final Answer:

   @Query with nativeQuery = true -> Option C

4. Quick Check:

   Native SQL queries use @Query(nativeQuery = true) [OK]

Hint: Look for @Query with nativeQuery true flag [OK]

Common Mistakes:

• Using a non-existent annotation like @NativeQuery
• Forgetting to set nativeQuery = true
• Confusing @Query with @SqlQuery
• Using @SQLNative which is invalid

2. Which of the following is the correct syntax to write a native SQL query in a Spring Boot repository method?

easy

A. @Query(value = "SELECT * FROM users", nativeQuery = true)

B. @Query(native = true, value = "SELECT * FROM users")

C. @NativeQuery("SELECT * FROM users")

D. @Query(sql = "SELECT * FROM users")

Solution

1. Step 1: Recall the correct attribute names in @Query

   The attribute for the query string is value, and to mark it native SQL, use nativeQuery = true.

2. Step 2: Check each option's syntax

   @Query(value = "SELECT * FROM users", nativeQuery = true) correctly uses @Query(value = "...", nativeQuery = true). Options B, C, and D use invalid attribute names or annotations.

3. Final Answer:

   @Query(value = "SELECT * FROM users", nativeQuery = true) -> Option A

4. Quick Check:

   @Query(value=..., nativeQuery=true) is correct syntax [OK]

Hint: Use value= for query and nativeQuery=true [OK]

Common Mistakes:

• Using native=true instead of nativeQuery=true
• Using @NativeQuery annotation which doesn't exist
• Using sql= instead of value= for query string
• Swapping attribute order incorrectly

3. Given this repository method:

@Query(value = "SELECT * FROM products WHERE price > ?1", nativeQuery = true)
List<Product> findExpensiveProducts(double minPrice);

What will be the result of calling findExpensiveProducts(100.0)?

medium

A. List of products with price less than 100.0

B. Empty list always

C. Syntax error due to ?1 placeholder

D. List of products with price greater than 100.0

Solution

1. Step 1: Understand the native SQL query with parameter

   The query selects all products where price is greater than the first parameter (?1), which is passed as 100.0.

2. Step 2: Predict the method output

   Calling findExpensiveProducts(100.0) returns products priced above 100.0, so the list contains those products.

3. Final Answer:

   List of products with price greater than 100.0 -> Option D

4. Quick Check:

   Native query with ?1 uses method parameter [OK]

Hint: ?1 matches first method parameter in native query [OK]

Common Mistakes:

• Thinking ?1 is invalid in native queries
• Confusing greater than with less than
• Assuming empty list without data
• Believing syntax error due to placeholder

4. Identify the error in this native query method:

@Query(value = "SELECT * FROM orders WHERE status = :status", nativeQuery = true)
List<Order> findByStatus(String status);

medium

A. Named parameter :status is not supported in native queries

B. Query string should use ?1 instead of :status

C. Missing nativeQuery = true flag

D. Method return type should be Optional<Order>

Solution

1. Step 1: Check parameter usage in native queries

   Native SQL queries in Spring Boot do not support named parameters like :status by default; they require positional parameters like ?1.

2. Step 2: Identify correct parameter syntax

   The query should use ?1 to refer to the first method parameter instead of :status.

3. Final Answer:

   Query string should use ?1 instead of :status -> Option B

4. Quick Check:

   Native queries use positional parameters like ?1 [OK]

Hint: Use ?1 for parameters in native queries, not :name [OK]

Common Mistakes:

• Using named parameters in native queries
• Forgetting nativeQuery = true
• Assuming return type must be Optional
• Confusing JPQL and native SQL syntax

5. You want to write a native SQL query in Spring Boot to update the price of all products in a category. Which method signature and annotation is correct?

hard

A. @Modifying
@Query(value = "UPDATE products SET price = price * 1.1 WHERE category = ?1", nativeQuery = true)
int increasePriceByCategory(String category);

B. @Query(value = "UPDATE products SET price = price * 1.1 WHERE category = ?1", nativeQuery = true)
void increasePriceByCategory(String category);

C. @Modifying
@Query(value = "UPDATE products SET price = price * 1.1 WHERE category = :category", nativeQuery = true)
int increasePriceByCategory(String category);

D. @Modifying
@Query(value = "UPDATE products SET price = price * 1.1 WHERE category = ?1")
int increasePriceByCategory(String category);

Solution

1. Step 1: Recognize update queries need @Modifying

   In Spring Boot, native update queries require the @Modifying annotation to indicate a modifying operation.

2. Step 2: Check parameter syntax and nativeQuery flag

   @Modifying @Query(value = "UPDATE products SET price = price * 1.1 WHERE category = ?1", nativeQuery = true) int increasePriceByCategory(String category); correctly uses positional parameter ?1 and sets nativeQuery = true. @Modifying @Query(value = "UPDATE products SET price = price * 1.1 WHERE category = :category", nativeQuery = true) int increasePriceByCategory(String category); uses named parameter which is invalid in native queries. @Modifying @Query(value = "UPDATE products SET price = price * 1.1 WHERE category = ?1") int increasePriceByCategory(String category); misses nativeQuery flag. @Query(value = "UPDATE products SET price = price * 1.1 WHERE category = ?1", nativeQuery = true) void increasePriceByCategory(String category); misses @Modifying.

3. Final Answer:

   @Modifying @Query(value = "UPDATE products SET price = price * 1.1 WHERE category = ?1", nativeQuery = true) int increasePriceByCategory(String category); -> Option A

4. Quick Check:

   Update native queries need @Modifying and nativeQuery=true [OK]

Hint: Use @Modifying and nativeQuery=true for update queries [OK]

Common Mistakes:

• Omitting @Modifying on update queries
• Using named parameters in native queries
• Forgetting nativeQuery=true flag
• Returning void instead of int for update count