Stop Writing Log Queries. Just Ask

Each replay uses a recreated ChatGPT interface so the placement can be read in its original conversational context. It is not a live or embedded chat.

1. ObservedJul 16, 2026Conversation2 turnsPlacementAfter turn 12 turns · After turn 1Replay chat
   Observed conversationJul 16, 2026 · interface recreation

   ChatGPTArchived view

   For a new project with Postgres, are you still using JPA/Hibernate, or have you moved to something like jOOQ or Spring Data JDBC for more control? What's the current trade-off you're comfortable with?

   For a greenfield PostgreSQL project today, my default is not "Hibernate everywhere." The ecosystem has shifted enough that I pick the persistence technology based on the application's query complexity rather than treating JPA as the default.

   Here's roughly how I'd choose:

   Project characteristics	My default
   CRUD-heavy business application	Spring Data JPA/Hibernate
   Read-heavy app with complex SQL	jOOQ
   Simple services with straightforward tables	Spring Data JDBC
   Mixed application	JPA for writes + jOOQ for reporting/complex reads

   When I still choose JPA/Hibernate

   I still think Hibernate is excellent when:

   • the domain model is genuinely object-oriented
   • relationships matter
   • most operations are CRUD
   • the team wants productivity over SQL control

   The things Hibernate is really good at haven't changed:

   • dirty checking
   • cascading
   • optimistic locking
   • entity lifecycle
   • lazy loading (when used carefully)
   • reducing boilerplate

   If 90% of your queries look like:

   orderRepository.findByCustomerId(...)
   

   then introducing jOOQ often just creates more work.

   The downside is that once queries become analytical or Postgres-specific, Hibernate starts fighting you.

   ---

   Why I've become a bigger fan of jOOQ

   For PostgreSQL, jOOQ feels increasingly like the "native" way to work.

   You get:

   • compile-time checked SQL
   • first-class CTEs
   • window functions
   • recursive queries
   • JSONB support
   • arrays
   • PostGIS
   • UPSERT
   • lateral joins
   • full control over generated SQL

   Example:

   dsl.select(
           CUSTOMER.NAME,
           count(ORDER.ID))
      .from(CUSTOMER)
      .join(ORDER)
      .on(...)
      .groupBy(CUSTOMER.NAME);
   

   You know exactly what SQL will be executed.

   No N+1 surprises.

   No mysterious generated joins.

   No wondering whether Hibernate decided to fetch half the database.

   ---

   Spring Data JDBC

   I like Spring Data JDBC much more than I did a few years ago.

   It intentionally avoids:

   • lazy loading
   • proxies
   • persistence context
   • dirty checking

   Each repository call simply executes SQL.

   That simplicity is valuable.

   The trade-off is that once aggregates become complicated, you'll write more SQL yourself.

   It's great for:

   • microservices
   • event-driven systems
   • simple aggregates
   • teams that dislike ORM magic

   ---

   The biggest shift

   Ten years ago the recommendation was:

   "Start with Hibernate and only use SQL when necessary."

   Today my recommendation is closer to:

   "Start with the amount of abstraction you actually need."

   Modern PostgreSQL is incredibly capable. Features like JSONB, generated columns, CTEs, window functions, and advanced indexing are much easier to use when your persistence layer doesn't hide SQL.

   ---

   The approach I personally find most practical

   For many medium-to-large Spring applications:

   • JPA/Hibernate for transactional writes and aggregate management.
   • jOOQ for reporting, dashboards, searches, exports, and complex queries.
   • Avoid forcing either tool into jobs it isn't well suited for.

   This hybrid approach works surprisingly well because each library plays to its strengths.

   If I had to pick just one today

   If starting a brand-new PostgreSQL application:

   • Simple CRUD/business app: Spring Data JPA.
   • Data-intensive application: jOOQ.
   • Performance-sensitive backend with lots of SQL: jOOQ.
   • Simple microservice: Spring Data JDBC.

   Compared with five or six years ago, I'm noticeably more willing to reach for jOOQ early. SQL has become a richer language, PostgreSQL has added powerful features, and jOOQ lets you use those capabilities without giving up type safety. Hibernate remains an excellent tool, but I no longer see it as the automatic default for every new project.

   

   KKomodor IncAd

   Debug Kubernetes Incidents With Change RCACorrelate pods, deploys, alerts and events to isolate Kubernetes root cause faster.

   

   CCursorAd

   AI Code EditorThe next generation AI IDE for developers.

   We need good performance on complex queries.

   Given that requirement, I'd lean toward jOOQ as the primary persistence layer.

   Complex queries are where Hibernate tends to become a liability. You often end up working around the ORM with native queries, trying to optimize generated SQL, or dealing with fetch strategies and N+1 issues. If most of your important work is already SQL, it's usually cleaner to embrace it.

   For a PostgreSQL application with demanding queries, I'd structure things like this:

   • jOOQ for all data access and query construction.
   • Keep business logic in services, not in repositories.
   • Use PostgreSQL features freely—CTEs, window functions, JSONB, LATERAL, recursive queries, ON CONFLICT, materialized views, etc.
   • Let jOOQ generate types from your schema so schema changes are caught at compile time.

   For example, a complex report might naturally become:

   var results =
       dsl.with(REVENUE)
          .as(...)
          .select(...)
          .from(...)
          .join(...)
          .where(...)
          .fetchInto(CustomerReport.class);
   

   The generated SQL is predictable and easy to inspect with EXPLAIN ANALYZE.

   I'd also recommend

   • Use a migration tool like Flyway or Liquibase to manage the schema.
   • Design indexes alongside the queries, not afterward.
   • Benchmark important queries with EXPLAIN (ANALYZE, BUFFERS) during development.
   • Use connection pooling (e.g. HikariCP) and tune PostgreSQL rather than relying on ORM-level optimizations.

   Would I use Hibernate at all?

   Only if I had a strong reason, such as:

   • a rich domain model with lots of aggregate management,
   • heavy use of cascading and entity lifecycle callbacks,
   • or a team already deeply invested in JPA.

   Otherwise, I wouldn't add Hibernate just for CRUD. jOOQ handles straightforward CRUD well enough, and using a single persistence model avoids maintaining both entities and generated record types.

   So if you told me:

   "We're building a PostgreSQL-backed service with complex joins, analytics, search, and performance is important."

   I'd choose:

   • PostgreSQL
   • Spring Boot
   • jOOQ
   • Flyway
   • HikariCP

   and skip JPA/Hibernate entirely unless a specific use case emerged that justified it. That combination gives you full control over SQL while still benefiting from Spring's transaction management and dependency injection.

   

   LogZilla Corp.Ad

   Stop Writing Log Queries. Just AskAsk your logs anything in plain English. Real queries, real answers, no guesswork.