Comparion of JDBC Builders

Author: sathishk

content/docs/why/sql-builders.md

@@ -4,54 +4,50 @@ weight: 2
 toc: true
 ---
 
-**SQL Builders** are tools designed to simplify database interaction by abstracting away complex SQL queries and connection management. They help developers focus on writing business logic rather than managing database connections and handling raw SQL queries. Popular SQL Builders like **Spring JDBC** and **QueryDSL** allow developers to construct SQL queries programmatically, making code more readable and maintainable.
+**SQL Builders** are tools designed to simplify database interaction by abstracting away complex SQL queries and connection management. They help developers focus on writing business logic rather than handling raw SQL queries manually. Modern tools like **Spring Boot 3 JdbcClient** allow developers to construct and execute SQL queries programmatically with a fluent, readable API.
 
 Out of the three main responsibilities—connection management, model/DTO creation, and DAO implementation—SQL Builders primarily remove the burden of **connection management** from developers.
 
-For example, when using **Spring JDBC Client**, developers still need to create:
+When using the **Spring Boot 3 JdbcClient**, developers are still responsible for creating:
 
 - **Model classes**
-- **Data Access Objects (DAO)** using JDBC Clients
-- **RowMappers** to map database results to Java objects
+- **Data Access Objects (DAO)** using the fluent Client API
+- **Row Mapping logic** (though `JdbcClient` simplifies this with `query().row(...)`)
 
-Here’s a sample of how this works with **Spring JDBC Client**:
+Here is a sample of how this works using the **Spring Boot 3 JdbcClient**:
 
 ```java
 // Model class
-public class Movie {
-    private Long id;
-    private String title;
-    private String directedBy;
-    // Getters and Setters
-}
+public record Movie(Long id, String title, String directedBy) {}
 
-// DAO using Spring JDBC
+// DAO using Spring Boot 3 JdbcClient
+@Repository
 public class MovieRepository {
 
-    private JdbcTemplate jdbcTemplate;
+    private final JdbcClient jdbcClient;
 
-    public MovieRepository(JdbcTemplate jdbcTemplate) {
-        this.jdbcTemplate = jdbcTemplate;
+    public MovieRepository(JdbcClient jdbcClient) {
+        this.jdbcClient = jdbcClient;
     }
 
     public List<Movie> findMoviesByDirector(String director) {
-        String sql = "SELECT * FROM movie WHERE directed_by = ?";
-        return jdbcTemplate.query(sql, new Object[]{director}, new RowMapper<Movie>() {
-            public Movie mapRow(ResultSet rs, int rowNum) throws SQLException {
-                Movie movie = new Movie();
-                movie.setId(rs.getLong("id"));
-                movie.setTitle(rs.getString("title"));
-                movie.setDirectedBy(rs.getString("directed_by"));
-                return movie;
-            }
-        });
+        return jdbcClient.sql("SELECT id, title, directed_by FROM movie WHERE directed_by = :director")
+                .param("director", director)
+                .query((rs, rowNum) -> new Movie(
+                    rs.getLong("id"),
+                    rs.getString("title"),
+                    rs.getString("directed_by")
+                ))
+                .list();
     }
 }
 ```
 
 ### SQL Components: A Type-Safe Alternative
 
-While SQL Builders abstract connection management, **SQL Components** offers additional benefits by providing a **type-safe API** and eliminating the need for manual code related to models, DAOs, and RowMappers. Here's how you can achieve the same functionality using SQL Components:
+While `JdbcClient` offers a much cleaner fluent API than the older `JdbcTemplate`, **SQL Components** goes further by providing a **fully type-safe API** and eliminating the need to write any manual code for models, DAOs, or RowMappers.
+
+Here is how you achieve the same functionality using SQL Components:
 
 ```java
 List<Movie> movies = DataManager.getManager().getMovieStore()
@@ -62,6 +58,6 @@ List<Movie> movies = DataManager.getManager().getMovieStore()
 
 **Key Differences**:
 
-1. **Automatic Code Generation**: Models, DAOs, and RowMappers are generated automatically.
-2. **Type-Safe API**: Compile-time error checking ensures safety and reduces runtime issues.
-3. **Framework Independence**: No need for external frameworks like Spring; it’s pure Java code that can be easily integrated into any Java application.
+1. **Zero Boilerplate**: Models, Store classes, and mapping logic are generated automatically from your schema.
+2. **True Type-Safety**: Queries are constructed using generated metadata, ensuring that column names and types are checked at compile-time.
+3. **Framework Independence**: Operates as pure Java code. While it works perfectly with Spring, it doesn't require it, making your persistence layer portable across any Java environment.