Concise by design.
Fast by default.

// No ORM model. Rows are hand-mapped into plain records:
record City(long id, String name) {}

record Owner(long id, String firstName, String lastName,
               String address, String telephone, City city) {}

record Pet(long id, String name, LocalDate birthDate,
             long typeId, Owner owner) {}

// Private fields, field access. Getters/setters added only where the app calls them.
@Entity @Table(name = "city")
class City {
    @Id @GeneratedValue(strategy = IDENTITY) Long id;
    @Column(name = "name") String name;
}

@Entity @Table(name = "owner") @DynamicUpdate
class Owner {
    @Id @GeneratedValue(strategy = IDENTITY) Long id;
    @Column(name = "first_name") String firstName;
    @Column(name = "last_name") String lastName;
    @Column(name = "address") String address;
    @Column(name = "telephone") String telephone;
    @ManyToOne(fetch = LAZY) @JoinColumn(name = "city_id") City city;
    @OneToMany(mappedBy = "owner") List<Pet> pets;
}

@Entity @Table(name = "pet")
class Pet {
    @Id @GeneratedValue(strategy = IDENTITY) Long id;
    @Column(name = "name") String name;
    @Column(name = "birth_date") LocalDate birthDate;
    @ManyToOne(fetch = LAZY) @JoinColumn(name = "type_id") PetType type;
    @ManyToOne(fetch = LAZY) @JoinColumn(name = "owner_id") Owner owner;
}

// jOOQ generates the table classes from the schema; there is no entity model.
// You still write the result records it maps into, shared here with JDBC:
record City(long id, String name) {}

record Owner(long id, String firstName, String lastName,
               String address, String telephone, City city) {}

record Pet(long id, String name, LocalDate birthDate,
             long typeId, Owner owner) {}

object Cities : Table("city") {
    val id = long("id").autoIncrement()
    val name = varchar("name", 100)
    override val primaryKey = PrimaryKey(id)
}

object Owners : Table("owner") {
    val id = long("id").autoIncrement()
    val firstName = varchar("first_name", 50)
    val lastName = varchar("last_name", 50)
    val address = varchar("address", 120)
    val telephone = varchar("telephone", 20)
    val cityId = long("city_id").references(Cities.id)
    override val primaryKey = PrimaryKey(id)
}

object Pets : Table("pet") {
    val id = long("id").autoIncrement()
    val name = varchar("name", 50)
    val birthDate = date("birth_date")
    val typeId = long("type_id").references(PetTypes.id)
    val ownerId = long("owner_id").references(Owners.id)
    override val primaryKey = PrimaryKey(id)
}

object Cities : LongIdTable("city") { val name = varchar("name", 100) }

object Owners : LongIdTable("owner") {
    val firstName = varchar("first_name", 50)
    val lastName = varchar("last_name", 50)
    val address = varchar("address", 120)
    val telephone = varchar("telephone", 20)
    val cityId = reference("city_id", Cities)
}

object Pets : LongIdTable("pet") {
    val name = varchar("name", 50)
    val birthDate = date("birth_date")
    val typeId = reference("type_id", PetTypes)
    val ownerId = reference("owner_id", Owners)
}

class CityDao(id: EntityID<Long>) : LongEntity(id) {
    companion object : LongEntityClass<CityDao>(Cities)
    var name by Cities.name
}

class OwnerDao(id: EntityID<Long>) : LongEntity(id) {
    companion object : LongEntityClass<OwnerDao>(Owners)
    var firstName by Owners.firstName
    var lastName by Owners.lastName
    var address by Owners.address
    var telephone by Owners.telephone
    var city by CityDao referencedOn Owners.cityId
    val pets by PetDao referrersOn Pets.ownerId
}

class PetDao(id: EntityID<Long>) : LongEntity(id) {
    companion object : LongEntityClass<PetDao>(Pets)
    var name by Pets.name
    var birthDate by Pets.birthDate
    var typeId by Pets.typeId
    var owner by OwnerDao referencedOn Pets.ownerId
}

interface Owner : Entity<Owner> {
    companion object : Entity.Factory<Owner>()
    val id: Long
    var firstName: String
    var lastName: String
    var address: String
    var telephone: String
    var city: City
}

object Owners : Table<Owner>("owner") {
    val id = long("id").primaryKey().bindTo { it.id }
    val firstName = varchar("first_name").bindTo { it.firstName }
    // … lastName, address and telephone bindings …
    val cityId = long("city_id").references(Cities) { it.city }
}

@Entity @Table(name = "city")
interface City {
    @Id long id();
    String name();
}

@Entity @Table(name = "owner")
interface Owner {
    @Id long id();
    String firstName();
    String lastName();
    String address();
    String telephone();
    @ManyToOne @JoinColumn(name = "city_id") City city();
    @OneToMany(mappedBy = "owner") List<Pet> pets();
}

@Entity @Table(name = "pet")
interface Pet {
    @Id long id();
    String name();
    LocalDate birthDate();
    @ManyToOne @JoinColumn(name = "type_id") PetType type();
    @ManyToOne @JoinColumn(name = "owner_id") Owner owner();
}

try (var ps = connection.prepareStatement(
        "SELECT id, pet_id, visit_date, description FROM visit WHERE id = ?")) {
    ps.setLong(1, id);
    try (var rs = ps.executeQuery()) {
        rs.next();
        return new Visit(rs.getLong(1), rs.getLong(2),
                rs.getObject(3, LocalDate.class), rs.getString(4));
    }
}

return sessionFactory.fromSession(session -> session.find(Visit.class, id));

return ctx.select(VISIT.ID, VISIT.PET_ID, VISIT.VISIT_DATE, VISIT.DESCRIPTION)
        .from(VISIT)
        .where(VISIT.ID.eq(id))
        .fetchOne(Records.mapping(Visit::new));

transaction(database) {
    Visits.selectAll().where { Visits.id eq id }.single().toVisit()
}

transaction(database) {
    VisitDao.findById(id)!!.toVisit()
}

database.sequenceOf(Visits).find { it.id eq id }!!

return sqlClient.getEntities().findById(Visit.class, id);

try (var ps = connection.prepareStatement(
        "SELECT p.name, o.last_name, c.name FROM pet p"
        + " JOIN owner o ON p.owner_id = o.id JOIN city c ON o.city_id = c.id"
        + " WHERE o.city_id = ?")) {
    ps.setLong(1, cityId);
    try (var rs = ps.executeQuery()) {
        List<PetRow> rows = new ArrayList<>();
        while (rs.next()) rows.add(new PetRow(rs.getString(1), rs.getString(2), rs.getString(3)));
        return rows;
    }
}

return sessionFactory.fromSession(session -> session
    .createSelectionQuery(
        "select p.name, o.lastName, c.name from Pet p join p.owner o join o.city c where c.id = :cityId",
        PetRow.class)
    .setParameter("cityId", cityId)
    .getResultList());

return ctx.select(PET.NAME, OWNER.LAST_NAME, CITY.NAME)
    .from(PET)
    .join(OWNER).on(PET.OWNER_ID.eq(OWNER.ID))
    .join(CITY).on(OWNER.CITY_ID.eq(CITY.ID))
    .where(OWNER.CITY_ID.eq(cityId))
    .fetch(Records.mapping(PetRow::new));

transaction(database) {
    (Pets innerJoin Owners innerJoin Cities)
        .select(Pets.name, Owners.lastName, Cities.name)
        .where { Owners.cityId eq cityId }
        .map { PetRow(it[Pets.name], it[Owners.lastName], it[Cities.name]) }
}

// Exposed DAO drops to the same DSL query for projections
transaction(database) {
    (Pets innerJoin Owners innerJoin Cities)
        .select(Pets.name, Owners.lastName, Cities.name)
        .where { Owners.cityId eq EntityID(cityId, Cities) }
        .map { PetRow(it[Pets.name], it[Owners.lastName], it[Cities.name]) }
}

database.from(Pets)
    .innerJoin(Owners, on = Pets.ownerId eq Owners.id)
    .innerJoin(Cities, on = Owners.cityId eq Cities.id)
    .select(Pets.name, Owners.lastName, Cities.name)
    .where { Owners.cityId eq cityId }
    .map { PetRow(it[Pets.name]!!, it[Owners.lastName]!!, it[Cities.name]!!) }

PetTable table = PetTable.$;
return sqlClient.createQuery(table)
    .where(table.owner().city().id().eq(cityId))
    .select(table.name(), table.owner().lastName(), table.owner().city().name())
    .execute();

try (var insert = connection.prepareStatement(
        "INSERT INTO visit (pet_id, visit_date, description) VALUES (?, ?, ?)",
        Statement.RETURN_GENERATED_KEYS)) {
    // bind, executeUpdate, read the key from getGeneratedKeys()
}
try (var update = connection.prepareStatement("UPDATE visit SET description = ? WHERE id = ?")) {
    // bind the amended description and the key, executeUpdate, commit
}

return sessionFactory.fromTransaction(session -> {
    Visit visit = new Visit(session.getReference(Pet.class, petId), date, text);
    session.persist(visit);
    session.flush();
    // the persisted instance is managed; amend it and let dirty checking flush
    visit.setDescription(visit.getDescription() + " (rechecked)");
    return visit.getId();
});

Long id = c.insertInto(VISIT, VISIT.PET_ID, VISIT.VISIT_DATE, VISIT.DESCRIPTION)
        .values(petId, date, text)
        .returning(VISIT.ID).fetchOne().getId();
c.update(VISIT)
        .set(VISIT.DESCRIPTION, text + " (rechecked)")
        .where(VISIT.ID.eq(id))
        .execute();

val inserted = Visits.insert {
    it[Visits.petId] = petId; it[Visits.visitDate] = date; it[Visits.description] = text
}
val id = inserted[Visits.id]  // the insert result carries the generated id
Visits.update({ Visits.id eq id }) { it[Visits.description] = "$text (rechecked)" }

val dao = VisitDao.new { petId = …; visitDate = date; description = text }
val id = dao.id.value  // reading the id forces the pending insert to flush
dao.description = dao.description + " (rechecked)"

val visit = Visit { petId = pid; visitDate = date; description = text }
database.sequenceOf(Visits).add(visit)  // populates the generated id
visit.description = "${visit.description} (rechecked)"
visit.flushChanges()

Visit saved = sqlClient.getEntities().saveCommand(visit)
        .setMode(SaveMode.INSERT_ONLY).execute(connection).getModifiedEntity();
Visit updated = VisitDraft.$.produce(saved,
        draft -> draft.setDescription(saved.description() + " (rechecked)"));
sqlClient.getEntities().saveCommand(updated).setMode(SaveMode.UPDATE_ONLY).execute(connection);

connection.setAutoCommit(false);
String phone;
try (var ps = connection.prepareStatement(
        "SELECT id, first_name, last_name, address, telephone FROM owner WHERE id = ?")) {
    ps.setLong(1, id);
    var rs = ps.executeQuery(); rs.next();
    phone = Params.toggleTelephone(rs.getString(5));
    owner = new Owner(rs.getLong(1), ..., phone, null);
}
try (var ps = connection.prepareStatement("UPDATE owner SET telephone = ? WHERE id = ?")) {
    ps.setString(1, phone); ps.setLong(2, id); ps.executeUpdate();
}
connection.commit();

@Entity @Table(name = "owner") @DynamicUpdate  // write only the changed columns
class Owner {
    @Id @GeneratedValue(strategy = IDENTITY) private Long id;
    @Column(name = "first_name") private String firstName;
    @Column(name = "last_name") private String lastName;
    @Column(name = "address") private String address;
    @Column(name = "telephone") private String telephone;
    @ManyToOne(fetch = LAZY) @JoinColumn(name = "city_id") private City city;  // lazy: city not read
    @OneToMany(mappedBy = "owner") private List<Pet> pets;

    public String getTelephone() { return telephone; }
    public void setTelephone(String telephone) { this.telephone = telephone; }
    // Hibernate maps via field access; getId()/getPets() added where the app needs them
}

sessionFactory.fromTransaction(session -> {
    Owner owner = session.find(Owner.class, id);
    owner.setTelephone(Params.toggleTelephone(owner.getTelephone()));
    return owner;  // dirty-checking flushes only telephone
});

return ctx.transactionResult(tx -> {
    var record = DSL.using(tx).fetchOne(OWNER, OWNER.ID.eq(id));
    record.setTelephone(Params.toggleTelephone(record.getTelephone()));
    record.store();  // UpdatableRecord.store() updates only the changed field
    return record.getId();
});

transaction(database) {
    val row = Owners.selectAll().where { Owners.id eq id }.single()
    val phone = Params.toggleTelephone(row[Owners.telephone])
    Owners.update({ Owners.id eq id }) { it[Owners.telephone] = phone }
}

transaction(database) {
    val dao = OwnerDao.findById(id) ?: error("owner not found")
    dao.telephone = Params.toggleTelephone(dao.telephone)  // dirty tracking flushes only telephone
}

database.useTransaction {
    // withReferences = false keeps the read lazy: owner columns only, no city join
    val owner = database.sequenceOf(Owners, withReferences = false).find { it.id eq id }!!
    owner.telephone = Params.toggleTelephone(owner.telephone)
    owner.flushChanges()  // dirty tracking writes only the changed column
}

Owner owner = sqlClient.createQuery(OwnerTable.$)
    .where(OwnerTable.$.id().eq(id)).select(OwnerTable.$).execute(connection).getFirst();
Owner updated = OwnerDraft.$.produce(owner, d -> d.setTelephone(Params.toggleTelephone(owner.telephone())));
sqlClient.getEntities().saveCommand(updated)
    .setMode(SaveMode.UPDATE_ONLY)  // writes every loaded column of the draft
    .execute(connection);

var sql = new StringBuilder("SELECT p.name, o.last_name, c.name FROM pet p JOIN … WHERE o.city_id = ?");
if (filter.byDate()) sql.append(" AND p.birth_date >= ?");
if (filter.byType()) sql.append(" AND p.type_id = ?");
// bind the parameters in the same order the string grew, then map each row

var hql = new StringBuilder("select p.name, o.lastName, c.name from Pet p join p.owner o join o.city c where o.city.id = :cityId");
if (filter.byDate()) hql.append(" and p.birthDate >= :minDate");
if (filter.byType()) hql.append(" and p.type.id = :typeId");
// create the query, set the parameters that are present, getResultList()

Condition condition = OWNER.CITY_ID.eq(filter.cityId());
if (filter.byDate()) condition = condition.and(PET.BIRTH_DATE.ge(filter.minBirthDate()));
if (filter.byType()) condition = condition.and(PET.TYPE_ID.eq(filter.typeId()));
return ctx.select(PET.NAME, OWNER.LAST_NAME, CITY.NAME)
        .from(PET).join(OWNER).on(…).join(CITY).on(…)
        .where(condition)
        .fetch(Records.mapping(PetRow::new));

(Pets innerJoin Owners innerJoin Cities)
    .select(Pets.name, Owners.lastName, Cities.name)
    .where {
        var condition: Op<Boolean> = Owners.cityId eq filter.cityId
        if (filter.byDate) condition = condition and (Pets.birthDate greaterEq filter.minBirthDate)
        if (filter.byType) condition = condition and (Pets.typeId eq filter.typeId)
        condition
    }
    .map { PetRow(it[Pets.name], it[Owners.lastName], it[Cities.name]) }

// The DAO layer drops to the DSL for flat projections, as DAO applications do;
// the implementation matches Exposed with EntityID-wrapped key comparisons.

val conditions = ArrayList<ColumnDeclaring<Boolean>>()
conditions += Owners.cityId eq filter.cityId
if (filter.byDate) conditions += Pets.birthDate greaterEq filter.minBirthDate
if (filter.byType) conditions += Pets.typeId eq filter.typeId
database.from(Pets).innerJoin(Owners, on = …).innerJoin(Cities, on = …)
    .select(Pets.name, Owners.lastName, Cities.name)
    .where { conditions.reduce { a, b -> a and b } }
    .map { PetRow(it[Pets.name]!!, it[Owners.lastName]!!, it[Cities.name]!!) }

// Jimmer ignores null predicates, its idiom for dynamic queries.
return sqlClient.createQuery(table)
        .where(table.owner().city().id().eq(filter.cityId()))
        .where(filter.byDate() ? table.birthDate().ge(filter.minBirthDate()) : null)
        .where(filter.byType() ? table.type().id().eq(filter.typeId()) : null)
        .select(table.name(), table.owner().lastName(), table.owner().city().name())
        .execute();

List<Long> ownerIds = multiRowInsertReturningKeys(connection, "owner", …);
List<Long> petIds   = multiRowInsertReturningKeys(connection, "pet", …);   // threads ownerIds
List<Long> visitIds = multiRowInsertReturningKeys(connection, "visit", …); // threads petIds
// each level is one INSERT … VALUES (…),(…) RETURNING id; the caller orders the levels

for (var g : graphs) {
    Owner owner = new Owner(…, session.getReference(City.class, g.cityId()));
    Pet pet = new Pet(…, owner); owner.getPets().add(pet);
    Visit visit = new Visit(pet, …); pet.getVisits().add(visit);
    // cascade persist walks owner -> pets -> visits, ordering and batching the inserts
    session.persist(owner);
}
session.flush();

var ownerInsert = c.insertInto(OWNER, OWNER.FIRST_NAME, …);
for (var g : graphs) ownerInsert = ownerInsert.values(…);
List<Long> ownerIds = ownerInsert.returning(OWNER.ID).fetch().map(r -> r.get(OWNER.ID));
// same shape for pets (threading ownerIds) and visits (threading petIds):
// three multi-row INSERT … RETURNING statements, ordered by the caller

val ownerIds = Owners.batchInsert(graphs, shouldReturnGeneratedValues = true) { g ->
    this[Owners.firstName] = …; this[Owners.cityId] = g.cityId
}.map { it[Owners.id] }
// same shape for pets (threading ownerIds) and visits (threading petIds)

// Identical to Exposed: three batchInsert calls with generated values returned,
// with EntityID-wrapped keys threaded between the levels.

// bulkInsertReturning (ktorm-support-postgresql): one multi-row INSERT … RETURNING per level.
val ownerIds = database.bulkInsertReturning(Owners, Owners.id) {
    for (g in graphs) { item { set(it.firstName, …); set(it.cityId, g.cityId) } }
}
// same shape for pets (threading ownerIds) and visits (threading petIds)

List<Long> ownerIds = saveEntitiesReturningIds(connection, ownerDrafts, Owner::id);
List<Long> petIds   = saveEntitiesReturningIds(connection, petDrafts, Pet::id);  // threads ownerIds
List<Long> visitIds = saveEntitiesReturningIds(connection, visitDrafts, Visit::id);
// three saveEntities commands, each level threading the previous ids

Map<Long, Owner> owners = new LinkedHashMap<>();
Map<Long, List<Pet>> pets = new LinkedHashMap<>();
while (rs.next()) {
    long ownerId = rs.getLong(1);
    Owner owner = owners.get(ownerId);
    if (owner == null) {
        owner = new Owner(ownerId, ..., new City(rs.getLong(6), rs.getString(7)));
        owners.put(ownerId, owner); pets.put(ownerId, new ArrayList<>());
    }
    pets.get(ownerId).add(new Pet(rs.getLong(8), ..., owner));
}
// then zip owners + pets into List<OwnerWithPets>

List<Owner> owners = sessionFactory.fromSession(session -> session
    .createSelectionQuery(
        "select distinct o from Owner o join fetch o.pets join fetch o.city where o.city.id = :cityId",
        Owner.class)
    .setParameter("cityId", cityId)
    .getResultList());

List<OwnerWithPets> result = ctx.select(
            OWNER.ID, OWNER.FIRST_NAME, OWNER.LAST_NAME, OWNER.ADDRESS, OWNER.TELEPHONE,
            CITY.ID, CITY.NAME,
            multiset(
                    select(PET.ID, PET.NAME, PET.BIRTH_DATE, PET.TYPE_ID)
                            .from(PET)
                            .where(PET.OWNER_ID.eq(OWNER.ID))))
    .from(OWNER)
    .join(CITY).on(OWNER.CITY_ID.eq(CITY.ID))
    .where(OWNER.CITY_ID.eq(cityId))
    .orderBy(OWNER.ID)
    .fetch(record -> {
        Owner owner = new Owner(record.value1(), record.value2(), record.value3(),
                record.value4(), record.value5(), new City(record.value6(), record.value7()));
        List<Pet> pets = record.value8()
                .map(pet -> new Pet(pet.value1(), pet.value2(), pet.value3(), pet.value4(), owner));
        return new OwnerWithPets(owner, pets);
    });

transaction(database) {
    (Owners innerJoin Cities innerJoin Pets)
        .selectAll()
        .where { Owners.cityId eq cityId }
        .orderBy(Owners.id)
        .groupIntoOwners()  // in-memory LinkedHashMap grouping
}

transaction(database) {
    OwnerDao.find { Owners.cityId eq EntityID(cityId, Cities) }
        .orderBy(Owners.id to SortOrder.ASC)
        .with(OwnerDao::city, OwnerDao::pets)  // pets = batched SELECT ... WHERE owner_id IN (...)
        .map { OwnerWithPets(it.toOwner(), it.pets.map { p -> p.toPet() }) }
}

database.from(Owners)
    .innerJoin(Cities, on = Owners.cityId eq Cities.id)
    .innerJoin(Pets, on = Pets.ownerId eq Owners.id)
    .select()
    .where { Owners.cityId eq cityId }
    .orderBy(Owners.id.asc())
    .map { Pets.createEntity(it) }
    .groupIntoOwners()  // in-memory LinkedHashMap grouping

OwnerTable table = OwnerTable.$;
return sqlClient.createQuery(table)
    .where(table.city().id().eq(cityId))
    .orderBy(table.id().asc())
    .select(table.fetch(
        OwnerFetcher.$.allScalarFields()
            .city(CityFetcher.$.allScalarFields())
            .pets(PetFetcher.$.allScalarFields())))  // pets = batched WHERE owner_id IN (...)
    .execute();

List<Long> ids = multiRowInsertReturningKeys(connection, "visit",
        "pet_id, visit_date, description", 3, BATCH_SIZE, (ps, base, i) -> {
    ps.setLong(base + 1, ...); ps.setObject(base + 2, ...); ps.setString(base + 3, ...);
});
// one INSERT ... VALUES (...),(...) RETURNING id: the driver disables batch rewriting
// when generated keys are requested, so executeBatch cannot express this technique

sessionFactory.fromTransaction(session -> {
    for (int i = 0; i < BATCH_SIZE; i++) {
        Pet pet = session.getReference(Pet.class, ...);  // proxy, no SELECT
        session.persist(new Visit(pet, ..., ...));
    }
    session.flush();  // ids pre-fetched from visit_seq
    return visits.stream().map(Visit::getId).toList();
});

var insert = ctx.insertInto(VISIT, VISIT.PET_ID, VISIT.VISIT_DATE, VISIT.DESCRIPTION);
for (int i = 0; i < BATCH_SIZE; i++) {
    insert = insert.values(..., ..., ...);  // one VALUES tuple appended per row
}
return insert.returning(VISIT.ID).fetch().map(r -> r.get(VISIT.ID));

Visits.batchInsert(0 until BATCH_SIZE, shouldReturnGeneratedValues = true) { i ->
    this[Visits.petId] = ...
    this[Visits.visitDate] = ...
    this[Visits.description] = ...
}.map { it[Visits.id] }  // Exposed batchInsert = JDBC addBatch, not multi-row VALUES

val daos = (0 until BATCH_SIZE).map {
    VisitDao.new { petId = ...; visitDate = ...; description = ... }
}
daos.map { it.id.value }  // reading ids flushes the pending inserts as a batch

database.useTransaction {
    // bulkInsertReturning (ktorm-support-postgresql): one multi-row INSERT … RETURNING
    database.bulkInsertReturning(Visits, Visits.id) {
        for (i in 0 until BATCH_SIZE) {
            item { set(it.petId, …); set(it.visitDate, …); set(it.description, …) }
        }
    }
}

List<Visit> drafts = ...;  // 100x VisitDraft.$.produce(d -> { d.setPet(makeIdOnly(..)); .. })
sqlClient.getEntities()
    .saveEntitiesCommand(drafts)
    .setMode(SaveMode.INSERT_ONLY)
    .execute(connection);  // JDBC batch, keys from RETURNING

try (var ps = connection.prepareStatement("""
        SELECT p.id, p.name, … , c.id, c.name FROM pet p
        JOIN owner o ON p.owner_id = o.id JOIN city c ON o.city_id = c.id
        WHERE p.id > ? ORDER BY p.id
        LIMIT %d""".formatted(PAGE_SIZE))) {  // literal LIMIT: PostgreSQL settles on a cached plan
    ps.setLong(1, cursor);
    // execute and map each row into Pet, Owner and City by hand
}

// The HQL limit clause inlines the constant page size, so PostgreSQL caches the generic plan;
// setMaxResults would bind it and force a fresh planning pass on every call.
return sessionFactory.fromSession(session -> session
        .createSelectionQuery(
                "from Pet p join fetch p.owner o join fetch o.city where p.id > :cursor order by p.id limit 20",
                Pet.class)
        .setParameter("cursor", cursor)
        .getResultList());

return ctx.select(PET.ID, PET.NAME, PET.BIRTH_DATE, PET.TYPE_ID,
                row(OWNER.ID, … , row(CITY.ID, CITY.NAME).mapping(City::new)).mapping(Owner::new))
        .from(PET).join(OWNER).on(…).join(CITY).on(…)
        .orderBy(PET.ID).seek(cursor)
        .limit(inline(PAGE_SIZE))  // inlined constant: PostgreSQL caches the generic plan
        .fetch(Records.mapping(Pet::new));

transaction(database) {
    (Pets innerJoin Owners innerJoin Cities)
        .selectAll()
        .where { Pets.id greater cursor }
        .orderBy(Pets.id)
        .limit(PAGE_SIZE)
        .map { it.toPet() }
}

transaction(database) {
    PetDao.wrapRows(Pets.selectAll()
            .where { Pets.id greater cursor }
            .orderBy(Pets.id to SortOrder.ASC).limit(PAGE_SIZE))
        .with(PetDao::owner, OwnerDao::city)  // eager-loads in batched queries
        .map { it.toPet() }
}

database.sequenceOf(Pets)
    .filter { Pets.id greater cursor }
    .sortedBy { Pets.id }
    .take(PAGE_SIZE)
    .toList()  // reference bindings join owner and city

return sqlClient.createQuery(table)
        .where(table.id().gt(cursor))
        .orderBy(table.id().asc())
        .select(table.fetch(PetFetcher.$.allScalarFields()
                .owner(OwnerFetcher.$.allScalarFields()
                        .city(CityFetcher.$.allScalarFields()))))
        .limit(PAGE_SIZE)
        .execute();

try (var ps = connection.prepareStatement(
        "SELECT p.id, p.name, ..., c.id, c.name FROM pet p"
        + " JOIN owner o ON p.owner_id = o.id JOIN city c ON o.city_id = c.id"
        + " WHERE p.id > ? AND p.id <= ?")) {
    ps.setLong(1, base); ps.setLong(2, base + rows);
    try (var rs = ps.executeQuery()) {
        List<Pet> pets = new ArrayList<>();
        while (rs.next()) pets.add(mapPet(rs));  // hand-map each row -> Pet, Owner, City
        return pets;
    }
}

return sessionFactory.fromSession(session -> session
    .createSelectionQuery(
        "from Pet p join fetch p.owner o join fetch o.city where p.id > :base and p.id <= :top",
        Pet.class)
    .setParameter("base", base)
    .setParameter("top", base + rows)
    .getResultList());

return ctx.select(
        PET.ID, PET.NAME, PET.BIRTH_DATE, PET.TYPE_ID,
        row(OWNER.ID, OWNER.FIRST_NAME, OWNER.LAST_NAME, OWNER.ADDRESS, OWNER.TELEPHONE,
                row(CITY.ID, CITY.NAME).mapping(City::new)).mapping(Owner::new))
    .from(PET)
    .join(OWNER).on(PET.OWNER_ID.eq(OWNER.ID))
    .join(CITY).on(OWNER.CITY_ID.eq(CITY.ID))
    .where(PET.ID.gt(base).and(PET.ID.le(base + rows)))
    .fetch(Records.mapping(Pet::new));

transaction(database) {
    (Pets innerJoin Owners innerJoin Cities)
        .selectAll()
        .where { (Pets.id greater base) and (Pets.id lessEq base + rows) }
        .map { it.toPet() }
}

transaction(database) {
    PetDao.wrapRows(
        Pets.selectAll()
            .where { (Pets.id greater base) and (Pets.id lessEq base + rows) })
        .with(PetDao::owner, OwnerDao::city)  // 2 extra batched SELECT ... IN queries
        .map { it.toPet() }
}

database.sequenceOf(Pets)
    .filter { (Pets.id greater base) and (Pets.id lessEq base + rows) }
    .toList()  // reference bindings join owner and city

PetTable table = PetTable.$;
return sqlClient.createQuery(table)
    .where(table.id().gt(base)).where(table.id().le(base + rows))
    .select(table.fetch(
        PetFetcher.$.allScalarFields()
            .owner(OwnerFetcher.$.allScalarFields()
                .city(CityFetcher.$.allScalarFields()))))  // fetchers -> 2 batched loads
    .execute();