roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Answer interview questions on jOOQ, the JVM library for teams that write SQL instead of mapping objects. Covers code generation from the schema, the typed DSL, records and Spring transactions.
153 of 153 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 153 new. 0 cut, outside your plan.
jOOQ comes up where a team has said it does not use Hibernate, usually in the technical conversation of a Java or Kotlin backend loop once your code sample shows a DSLContext. The first questions test whether you see the DSL as SQL with a compiler in front of it: where the generated classes come from when the build server has no database, what SQL a query renders for the dialect you configured, and whether a value reached the database as a bind parameter or was inlined into the statement text.
From there the conversation moves to the places where jOOQ stops looking like plain SQL. An UpdatableRecord writes itself back with store(), and interviewers ask how it chooses between an insert and an update, which columns it sends, and what the optimistic-locking setting adds to the statement. In a Spring application they ask whether a query run inside a @Transactional method joins that transaction or takes a connection of its own. Senior candidates are expected to argue the choice itself: what a team gives up by leaving a tracking mapper, which of those things it rebuilds by hand, and when a nested MULTISET collection beats a second query.
The plan opens below jOOQ because its DSL renders SQL nearly clause for clause. Joins and subqueries and common table expressions are the clauses most jOOQ answers lean on, nested collections included, since jOOQ usually renders a MULTISET as a correlated subquery that aggregates rows into JSON or XML. JDBC closes that stretch as the API every jOOQ query finally runs on, with its connections, prepared statements and batches.
The next module asks why a team would choose this at all. Layers that track nothing set out what a SQL-first team rebuilds by hand, and typed DSLs explain what compiling queries against generated classes catches and what it still leaves to runtime. Code generation follows as the mechanism behind that promise: deriving source from a schema in general, then jOOQ's generator and where its schema comes from in a build.
With classes in hand the plan writes queries. SQL injection and composing predicates at runtime come before the DSL itself, because plain SQL templates and inlined values are where a type-safe API can still be made unsafe, and optional filters are the first dynamic query most services need. Results come next: projections and batched writes as general ideas, then jOOQ's records as one library's answer to both. The last module puts a query inside an application, with Spring's JDBC transaction manager before jOOQ's own wiring, since whether the two share a connection is the question that module exists to answer.
Most first-round jOOQ questions sit in the generator and DSL modules, because where generated code comes from and how values are bound open almost every jOOQ conversation; a short preparation starts there with importance set to must know, and study order can stay where the page opens it. Arriving from Hibernate, read the SQL-first module slowly: the habits that break are the ones that assume an entity remembers its changes, and a jOOQ record remembers only the fields you touched. Kotlin developers will find the generated classes and the DSL unchanged; what differs is mapping into data classes and running queries from coroutines, which the records and DSL modules cover. This plan treats SQL as a prerequisite rather than teaching it end to end. Window functions, aggregation and indexing are in the [SQL roadmap](/roadmaps/sql), and the rest of a JVM backend interview, from Spring to system design, is in the [Java Developer roadmap](/roadmaps/java-developer).
Most first-round jOOQ questions sit in the generator and DSL modules, because where generated code comes from and how values are bound open almost every jOOQ conversation; a short preparation starts there with importance set to must know, and study order can stay where the page opens it. Arriving from Hibernate, read the SQL-first module slowly: the habits that break are the ones that assume an entity remembers its changes, and a jOOQ record remembers only the fields you touched. Kotlin developers will find the generated classes and the DSL unchanged; what differs is mapping into data classes and running queries from coroutines, which the records and DSL modules cover.
This plan treats SQL as a prerequisite rather than teaching it end to end. Window functions, aggregation and indexing are in the SQL roadmap, and the rest of a JVM backend interview, from Spring to system design, is in the Java Developer roadmap.