Top 40 Hibernate and JPA Interview Questions (2026) with Runnable Answers

EntityManager em = s;
p("Session is an EntityManager      : %s", s instanceof EntityManager);
p("SessionFactory is an EMF         : %s", sf instanceof EntityManagerFactory);
p("em.unwrap(Session.class) == em   : %s", em.unwrap(Session.class) == em);

Session is an EntityManager      : true
SessionFactory is an EMF         : true
em.unwrap(Session.class) == em   : true
Hibernate-only API reachable     : s.getStatistics().isStatisticsEnabled() = true

Employee e = new Employee("Asha", 100, null);
try (Session s = sf.openSession()) {
    Transaction tx = s.beginTransaction();
    p("new Employee()      : managed=%s id=%s", s.contains(e), e.id);
    s.persist(e);
    p("after persist()     : managed=%s id assigned=%s", s.contains(e), e.id != null);
    tx.commit();
    s.detach(e);
    p("after detach()      : managed=%s", s.contains(e));
    Transaction tx2 = s.beginTransaction();
    Employee managed = s.merge(e);
    p("after merge()       : original managed=%s, returned copy managed=%s, same object=%s", s.contains(e), s.contains(managed), e == managed);
    s.remove(managed);
    p("after remove()      : managed=%s", s.contains(managed));
    tx2.commit();

new Employee()      : managed=false id=null
after persist()     : managed=true id assigned=true
after detach()      : managed=false
after merge()       : original managed=false, returned copy managed=true, same object=false
after remove()      : managed=false

Employee e = new Employee("Ben", 100, null);
tx(s -> s.persist(e));
// e is now detached (its session is closed)
try {
    tx(s -> s.persist(e));
} catch (Exception ex) {
    p("persist(detached) -> %s", first(ex));
}
Employee[] copy = new Employee[1];
tx(s -> {
    copy[0] = s.merge(e);
    e.salary = 777; // change the ORIGINAL after merge
    p("merge(detached)   -> returns a different instance: %s", copy[0] != e);
});
int salary = txr(s -> s.find(Employee.class, e.id).salary);
p("salary changed on the original after merge is stored: %s (db has %d)", salary == 777, salary);
assertEquals(100, salary);

persist(detached) -> jakarta.persistence.EntityExistsException: Detached entity passed to persist: lab.hibernate.model.Employee
merge(detached)   -> returns a different instance: true
salary changed on the original after merge is stored: false (db has 100)

Set<String> wanted = Set.of("save", "update", "saveOrUpdate", "delete", "load", "get", "persist", "merge", "remove", "find", "getReference", "refresh");
Set<String> present = new TreeSet<>();
for (Method m : Session.class.getMethods()) {
    if (wanted.contains(m.getName())) {
        present.add(m.getName());
    }
}
Set<String> missing = new TreeSet<>(wanted);
missing.removeAll(present);
p("methods present on org.hibernate.Session : %s", present);
p("methods NOT present                       : %s", missing);

methods present on org.hibernate.Session : [find, get, getReference, load, merge, persist, refresh, remove]
methods NOT present                       : [delete, save, saveOrUpdate, update]

Employee ref = s.getReference(Employee.class, id);
p("getReference(): SQL statements so far = %d, initialized = %s", SqlLog.since(m).size(), Hibernate.isInitialized(ref));
String viaField = ref.name; // a public field is read straight off the proxy object
p("ref.name (field) -> %s; SQL statements now = %d, initialized = %s", viaField, SqlLog.since(m).size(), Hibernate.isInitialized(ref));
String name = ref.getName(); // a method call is intercepted and loads the row
p("ref.getName()    -> %s; SQL statements now = %d, initialized = %s", name, SqlLog.since(m).size(), Hibernate.isInitialized(ref));

getReference(): SQL statements so far = 0, initialized = false
ref.name (field) -> null; SQL statements now = 0, initialized = false
ref.getName()    -> Chen; SQL statements now = 1, initialized = true
SQL> select e1_0.id,e1_0.city,e1_0.zip,e1_0.department_id,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.id=?
find(missing id)       -> null
getReference(missing)  -> proxy returned without error: true
first access           -> org.hibernate.ObjectNotFoundException: No row with the given identifier exists for entity [lab.hibernate.model.Employee with id '99999']

Employee e = s.find(Employee.class, id);
e.salary = 150; // no save(), no update()

s.persist(new Employee("Eli", 90, null));
long n = s.createSelectionQuery("select count(e) from Employee e", Long.class).getSingleResult();

change a managed entity, no save call:
SQL> select e1_0.id,e1_0.city,e1_0.zip,e1_0.department_id,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.id=?
SQL> update Employee set city=?,zip=?,department_id=?,level=?,name=?,salary=? where id=?
count visible inside the transaction (AUTO flush before the query): 2
persist then query:
SQL> select nextval('Employee_SEQ')
SQL> insert into Employee (city,zip,department_id,level,name,salary,id) values (?,?,?,?,?,?,?)
SQL> select count(e1_0.id) from Employee e1_0

managed.salary = 120; // pending change in memory
s.refresh(managed);
p("refresh(): pending in-memory change thrown away, salary = %d", managed.salary);
assertEquals(100, managed.salary);

tx(s -> s.merge(detached));

refresh(): pending in-memory change thrown away, salary = 100
merge(detached with salary 500) -> database now has 500

Employee a = s.find(Employee.class, id);
Employee b = s.find(Employee.class, id);
p("two find() calls, same session: SQL selects = %d, same instance = %s", SqlLog.countSince(m, "select"), a == b);
s.clear();
Employee c = s.find(Employee.class, id);

two find() calls, same session: SQL selects = 1, same instance = true
after clear(): SQL selects = 2, same instance as before = false
SQL> select e1_0.id,e1_0.city,e1_0.zip,e1_0.department_id,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.id=?
SQL> select e1_0.id,e1_0.city,e1_0.zip,e1_0.department_id,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.id=?
a different session: SQL selects = 1 (the first-level cache is per session)

tx(s -> s.persist(new BadEntity(1L)));
p("persist(): ok");
tx(s -> s.find(BadEntity.class, 1L));

SessionFactory started with an entity that has no no-arg constructor: true
persist(): ok
find() -> org.hibernate.InstantiationException: No default constructor for entity 'lab.hibernate.model.BadEntity'
root cause -> org.hibernate.InstantiationException: No default constructor for entity 'lab.hibernate.model.BadEntity'

boot(new String[] {"hibernate.jdbc.batch_size", "10"}, Invoice.class, Receipt.class);
int m = SqlLog.mark();
tx(s -> {
    for (int i = 0; i < 25; i++) {
        s.persist(new Receipt(i));
    }
});
long seqInserts = SqlLog.countSince(m, "insert");
long seqSelects = SqlLog.countSince(m, "select");
p("SEQUENCE: 25 entities -> %d prepared insert statement(s) with jdbc.batch_size=10, %d sequence selects", seqInserts, seqSelects);

SEQUENCE: 25 entities -> 1 prepared insert statement(s) with jdbc.batch_size=10, 2 sequence selects
IDENTITY: 25 entities -> 25 prepared insert statements (one per row)

List<String> cols = s.createNativeQuery("select column_name from information_schema.columns where table_name='employee' order by 1", String.class).getResultList();
p("columns of table employee: %s", cols);

columns of table employee: [city, department_id, id, level, name, salary, zip]

Employee e = new Employee("Hana", 1, null);
e.level = Level.LEAD;
s.persist(e);
RankedEmployee r = new RankedEmployee("Hana");
r.level = Level.LEAD;
s.persist(r);

@Enumerated(STRING)  stores LEAD as: LEAD
@Enumerated (default) stores LEAD as: 2  (its position in the enum: [JUNIOR, SENIOR, LEAD])

boot(Post.class, Comment.class);
p("tables: %s", tables());

tables: [comment, post, post_tags]

boot(Payment.class, CardPayment.class, BankPayment.class, Shape.class, Circle.class, Square.class);
p("tables: %s", tables());
tx(s -> {
    s.persist(new CardPayment(100, "4242"));
    s.persist(new BankPayment(200, "DE00"));
    s.persist(new Circle("c", 3));
    s.persist(new Square("s", 4));
});
int m = SqlLog.mark();
tx(s -> {
    p("JOINED     'from Payment' returned %d rows", s.createSelectionQuery("from Payment", Payment.class).getResultList().size());
    p("SINGLE_TABLE 'from Shape' returned %d rows", s.createSelectionQuery("from Shape", Shape.class).getResultList().size());

tables: [bankpayment, cardpayment, payment, shape]
JOINED     'from Payment' returned 2 rows
SINGLE_TABLE 'from Shape' returned 2 rows
SQL> select p1_0.id,case when p1_2.id is not null then 1 when p1_1.id is not null then 2 end,p1_0.amount,p1_1.iban,p1_2.last4 from Payment p1_0 left join BankPayment p1_1 on p1_0.id=p1_1.id left join CardPayment p1_2 on p1_0.id=p1_2.id
SQL> select s1_0.id,s1_0.kind,s1_0.label,s1_0.radius,s1_0.side from Shape s1_0

tx(s -> s.persist(new Note("hello")));
p("tables: %s", tables());
tx(s -> p("select from the entity Note: %d row(s), created_by column inherited = %s", s.createSelectionQuery("from Note", Note.class).getResultList().size(), s.createSelectionQuery("from Note", Note.class).getSingleResult().createdBy));
try {
    tx(s -> s.createSelectionQuery("from Auditable", Object.class).getResultList());
} catch (RuntimeException ex) {
    p("select from the @MappedSuperclass -> %s", first(ex));

tables: [note]
select from the entity Note: 1 row(s), created_by column inherited = system
select from the @MappedSuperclass -> org.hibernate.query.sqm.UnknownEntityException: Could not resolve root entity 'Auditable'

Set<SetItem> set = new HashSet<>();
SetItem item = new SetItem("x");
set.add(item);
p("before persist: id=%s, set.contains(item)=%s", item.id, set.contains(item));
tx(s -> s.persist(item));
p("after persist : id assigned=%s, hashCode changed, set.contains(item)=%s", item.id != null, set.contains(item));
assertFalse(set.contains(item));

before persist: id=null, set.contains(item)=true
after persist : id assigned=true, hashCode changed, set.contains(item)=false

for (Class<?> a : List.of(Basic.class, ManyToOne.class, OneToOne.class, OneToMany.class, ManyToMany.class, ElementCollection.class)) {
    p("  @%-17s -> %s", a.getSimpleName(), a.getMethod("fetch").getDefaultValue());
}

default of fetch() on each JPA annotation, read from the API jar:
  @Basic             -> EAGER
  @ManyToOne         -> EAGER
  @OneToOne          -> EAGER
  @OneToMany         -> LAZY
  @ManyToMany        -> LAZY
  @ElementCollection -> LAZY

Department d = new Department("Ops");
Employee e = new Employee("Ivy", 1, null);
d.employees.add(e); // only the inverse side is set
s.persist(d);
s.persist(e);

employee.department_id after d.employees.add(e) only: null
after setting employee.department too            : 1

for (Department d : s.createSelectionQuery("from Department", Department.class).getResultList()) {
    d.getEmployees().size();
}

for (Department d : s.createSelectionQuery("select distinct d from Department d join fetch d.employees", Department.class).getResultList()) {
    d.getEmployees().size();
}

naive loop over 3 departments: 4 SQL statements (1 + 3)
SQL> select d1_0.id,d1_0.name from Department d1_0
SQL> select e1_0.department_id,e1_0.id,e1_0.city,e1_0.zip,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.department_id=?
SQL> select e1_0.department_id,e1_0.id,e1_0.city,e1_0.zip,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.department_id=?
SQL> select e1_0.department_id,e1_0.id,e1_0.city,e1_0.zip,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.department_id=?
with join fetch: 1 SQL statement
SQL> select distinct d1_0.id,e1_0.department_id,e1_0.id,e1_0.city,e1_0.zip,e1_0.level,e1_0.name,e1_0.salary,d1_0.name from Department d1_0 join Employee e1_0 on d1_0.id=e1_0.department_id

List<Employee> list = s.createSelectionQuery("select e from Employee e join fetch e.department", Employee.class).getResultList();
p("join fetch   : department initialized = %s", Hibernate.isInitialized(list.get(0).getDepartment()));

EntityGraph<Employee> g = s.createEntityGraph(Employee.class);
g.addAttributeNodes("department");
List<Employee> list = s.createSelectionQuery("from Employee", Employee.class).setEntityGraph(g, GraphSemantic.FETCH).getResultList();
p("entity graph : department initialized = %s", Hibernate.isInitialized(list.get(0).getDepartment()));

join fetch   : department initialized = true
SQL> select e1_0.id,e1_0.city,e1_0.zip,d1_0.id,d1_0.name,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 join Department d1_0 on d1_0.id=e1_0.department_id
entity graph : department initialized = true
SQL> select e1_0.id,e1_0.city,e1_0.zip,d1_0.id,d1_0.name,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 left join Department d1_0 on d1_0.id=e1_0.department_id

boot(new String[] {"hibernate.default_batch_fetch_size", "2"}, HR);
seed();

default_batch_fetch_size=2, 3 departments: 3 SQL statements (1 + ceil(3/2))
SQL> select d1_0.id,d1_0.name from Department d1_0
SQL> select e1_0.department_id,e1_0.id,e1_0.city,e1_0.zip,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.department_id = any (?)
SQL> select e1_0.department_id,e1_0.id,e1_0.city,e1_0.zip,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.department_id=?

Department d = txr(s -> s.createSelectionQuery("from Department order by id", Department.class).getResultList().get(0));
try {
    d.getEmployees().size();

Department fresh = s.createSelectionQuery("select d from Department d join fetch d.employees where d.id = :id", Department.class).setParameter("id", d.getId()).getSingleResult();
return fresh.getEmployees().size();

read a lazy collection after the session closed -> org.hibernate.LazyInitializationException: Cannot lazily initialize collection of role 'lab.hibernate.model.Department.employees' with key '1' (no session)
cure 1: fetch it inside the query -> 3 employees, 1 SQL statement
cure 2: ask for exactly the columns you need -> [E11, E12, E13], 1 SQL statement

tx(s -> s.createSelectionQuery("select p from Post p join fetch p.comments join fetch p.tags", Post.class).getResultList());

Post post = s.createSelectionQuery("select p from Post p join fetch p.comments", Post.class).getSingleResult();
s.createSelectionQuery("select p from Post p join fetch p.tags where p in :p", Post.class).setParameter("p", post).getSingleResult();

two List collections in one join fetch -> java.lang.IllegalArgumentException: org.hibernate.loader.MultipleBagFetchException: cannot simultaneously fetch multiple bags: [lab.hibernate.model.Post.comments, lab.hibernate.model.Post.tags]
fix: one collection per query -> comments=2 tags=2, 2 SQL statements

List<Department> page = s.createSelectionQuery("select d from Department d join fetch d.employees order by d.id", Department.class).setMaxResults(2).getResultList();
p("join fetch of a collection + setMaxResults(2) -> %d departments", page.size());

join fetch of a collection + setMaxResults(2) -> 2 departments
SQL contains a row limit: true
SQL> select d1_0.id,e1_0.department_id,e1_0.id,e1_0.city,e1_0.zip,e1_0.level,e1_0.name,e1_0.salary,d1_0.name from (select d1_0.id,d1_0.name from Department d1_0 where exists(select 1 from Employee e1_0 where d1_0.id=e1_0.department_id) order by d1_0.id offset ? rows fetch first ? rows only) d1_0(id,name) join Employee e1_0 on d1_0.id=e1_0.department_id order by d1_0.id
two-step fix -> 2 departments
SQL> select d1_0.id from Department d1_0 order by d1_0.id fetch first ? rows only
SQL> select distinct d1_0.id,e1_0.department_id,e1_0.id,e1_0.city,e1_0.zip,e1_0.level,e1_0.name,e1_0.salary,d1_0.name from Department d1_0 join Employee e1_0 on d1_0.id=e1_0.department_id where d1_0.id in (?,?) order by d1_0.id

tx(s -> s.persist(new Employee("Jo", 1, new Department("Unsaved"))));

Post post = new Post("with cascade");
post.getComments().add(new Comment("c", post));
s.persist(post); // CascadeType.ALL on Post.comments saves the comment too

persist Employee that points at an unsaved Department -> java.lang.IllegalStateException: org.hibernate.TransientPropertyValueException: Persistent instance of 'lab.hibernate.model.Employee' references an unsaved transient instance of 'lab.hibernate.model.Department' (persist the transient instance before flushing) [lab.hibernate.model.Employee.department -> lab.hibernate.model.Department]
Post -> comments has CascadeType.ALL: comments stored = 1

o.getLines().remove(0); // no remove() call on the OrderLine

tx(s -> s.remove(s.find(PurchaseOrder.class, id)));

removed a line from the collection only:
SQL> select po1_0.id,po1_0.customer from PurchaseOrder po1_0 where po1_0.id=?
SQL> select l1_0.order_id,l1_0.id,l1_0.sku from OrderLine l1_0 where l1_0.order_id=?
SQL> delete from OrderLine where id=?
removed the order (cascade ALL):
SQL> select po1_0.id,po1_0.customer from PurchaseOrder po1_0 where po1_0.id=?
SQL> select l1_0.order_id,l1_0.id,l1_0.sku from OrderLine l1_0 where l1_0.order_id=?
SQL> delete from OrderLine where id=?
SQL> delete from PurchaseOrder where id=?

tx(s -> s.createSelectionQuery("from EagerEmployee", EagerEmployee.class).getResultList());

'from EagerEmployee' with the default @ManyToOne: 4 SQL statements for 9 employees in 3 departments
SQL> select ee1_0.id,ee1_0.department_id,ee1_0.name from EagerEmployee ee1_0
SQL> select d1_0.id,d1_0.name from Department d1_0 where d1_0.id=?
SQL> select d1_0.id,d1_0.name from Department d1_0 where d1_0.id=?
SQL> select d1_0.id,d1_0.name from Department d1_0 where d1_0.id=?
'from Employee' with @ManyToOne(fetch = LAZY): 1 SQL statement

private static final String[] L2 = {
    "hibernate.cache.use_second_level_cache", "true",
    "hibernate.cache.use_query_cache", "true",
    "hibernate.cache.region.factory_class", "jcache",
    "hibernate.javax.cache.provider", "org.ehcache.jsr107.EhcacheCachingProvider",
    "hibernate.javax.cache.missing_cache_strategy", "create"
};

sf.getCache().evictAllRegions();
st.clear();
int m = SqlLog.mark();
tx(s -> s.find(Product.class, id));
tx(s -> s.find(Product.class, id));
tx(s -> s.find(Product.class, id));
p("after evictAllRegions(), three find() calls, three different sessions:");

right after persist() the row is already in L2 (READ_WRITE caches on insert): SQL selects = 0, hits = 1
after evictAllRegions(), three find() calls, three different sessions:
  SQL selects         : 1
  L2 cache hits       : 2
  L2 cache misses     : 1
  L2 cache puts       : 1

Runnable run = () -> tx(s -> s.createSelectionQuery("from Product p where p.price > 5", Product.class).setCacheable(true).getResultList());
int m = SqlLog.mark();
run.run();
p("run 1: query cache hits=%d misses=%d puts=%d", st.getQueryCacheHitCount(), st.getQueryCacheMissCount(), st.getQueryCachePutCount());
run.run();
p("run 2: query cache hits=%d misses=%d puts=%d", st.getQueryCacheHitCount(), st.getQueryCacheMissCount(), st.getQueryCachePutCount());
p("SQL selects for Product after 2 runs: %d", SqlLog.countSince(m, "select"));
tx(s -> s.persist(new Product("Ink", 20))); // any write to the table invalidates cached results
run.run();
p("run 3 after inserting a Product: query cache hits=%d misses=%d", st.getQueryCacheHitCount(), st.getQueryCacheMissCount());

run 1: query cache hits=0 misses=1 puts=1
run 2: query cache hits=1 misses=1 puts=1
SQL selects for Product after 2 runs: 1
run 3 after inserting a Product: query cache hits=1 misses=2
SQL selects for Product after 3 runs: 3

tx(s -> s.createMutationQuery("update Product set price = 11").executeUpdate());
st.clear();
int priceAfterHql = txr(s -> s.find(Product.class, id).getPrice());
p("after an HQL bulk update to 11   : find() sees %d (L2 hits=%d misses=%d)", priceAfterHql, st.getSecondLevelCacheHitCount(), st.getSecondLevelCacheMissCount());

tx(s -> s.createNativeMutationQuery("update product set price = 12").executeUpdate());
st.clear();
int priceAfterNative = txr(s -> s.find(Product.class, id).getPrice());
p("after a native bulk update to 12 : find() sees %d (L2 hits=%d misses=%d)", priceAfterNative, st.getSecondLevelCacheHitCount(), st.getSecondLevelCacheMissCount());
assertEquals(11, priceAfterHql);

tx(s -> s.doWork(c -> {
    try (var stmt = c.createStatement()) {
        stmt.executeUpdate("update product set price = 13");
    }
}));
st.clear();
int priceAfterJdbc = txr(s -> s.find(Product.class, id).getPrice());
p("after raw JDBC update to 13      : find() sees %d (L2 hits=%d misses=%d)  <- stale: Hibernate was not told", priceAfterJdbc, st.getSecondLevelCacheHitCount(), st.getSecondLevelCacheMissCount());
assertEquals(12, priceAfterJdbc);

after an HQL bulk update to 11   : find() sees 11 (L2 hits=0 misses=1)
after a native bulk update to 12 : find() sees 12 (L2 hits=0 misses=1)
after raw JDBC update to 13      : find() sees 12 (L2 hits=1 misses=0)  <- stale: Hibernate was not told

PlainAccount fromA = a.find(PlainAccount.class, id);
PlainAccount fromB = b.find(PlainAccount.class, id);
fromA.balance += 50; // deposit 50
ta.commit();
fromB.balance += 25; // deposit 25, computed from the stale 100
int m = SqlLog.mark();
tb.commit();

SQL> update PlainAccount set balance=?,owner=? where id=?
two deposits (+50, +25) on 100 -> final balance 125, expected 175: A's deposit silently lost

Account fromA = a.find(Account.class, id);
Account fromB = b.find(Account.class, id);
p("both sessions read balance=%d version=%d", fromA.getBalance(), fromA.getVersion());
fromA.balance += 50;
ta.commit();
p("session A commits +50 -> version is now %d", fromA.getVersion());
fromB.balance += 25;
int m = SqlLog.mark();
try {
    tb.commit();
} catch (RuntimeException ex) {
    p("session B commits +25 -> %s", first(ex));
    Throwable c = ex.getCause();
    if (c != null) {
        p("  cause: %s", first(c));
    }
    tb.rollback();

both sessions read balance=100 version=0
session A commits +50 -> version is now 1
session B commits +25 -> jakarta.persistence.OptimisticLockException: Unexpected row count (expected row count 1 but was 0) [update Account set balance=?,owner=?,version=? where id=? and version=?] for entity [lab.hibernate.model.Account with id '1']
  cause: org.hibernate.StaleObjectStateException: Unexpected row count (expected row count 1 but was 0) [update Account set balance=?,owner=?,version=? where id=? and version=?] for entity [lab.hibernate.model.Account with id '1']
SQL> update Account set balance=?,owner=?,version=? where id=? and version=?
final balance: 150 (B's stale write was rejected, A's +50 kept)

s.find(Account.class, id, LockModeType.PESSIMISTIC_WRITE);
holderSql.set(SqlLog.since(m).get(0).replaceAll("\\s+", " "));

s.find(Account.class, id, LockModeType.PESSIMISTIC_WRITE, java.util.Map.of("jakarta.persistence.lock.timeout", 0));
p("session 2: got the lock (unexpected)");

session 1: find(..., PESSIMISTIC_WRITE) ran: select a1_0.id,a1_0.balance,a1_0.owner,a1_0.version from Account a1_0 where a1_0.id=? for no key update of a1_0
session 2 with lock.timeout=0 -> jakarta.persistence.PessimisticLockException: JDBC exception executing SQL [ERROR: could not obtain lock on row in relation "account"] [select a1_0.id,a1_0.balance,a1_0.owner,a1_0.version from Account a1_0 where a1_0.id=? for no key update of a1_0 nowait]
  cause: org.hibernate.exception.LockTimeoutException: JDBC exception executing SQL [ERROR: could not obtain lock on row in relation "account"] [select a1_0.id,a1_0.balance,a1_0.owner,a1_0.version from Account a1_0 where a1_0.id=? for no key update of a1_0 nowait]

for (String level : new String[] {"read committed", "repeatable read"}) {
    tx(s -> s.createNativeMutationQuery("update plainaccount set balance = 100").executeUpdate());
    try (Session reader = sf.openSession()) {
        Transaction t = reader.beginTransaction();
        reader.createNativeMutationQuery("set transaction isolation level " + level).executeUpdate();
        long first = reader.createNativeQuery("select balance from plainaccount where id = :id", Long.class).setParameter("id", id).getSingleResult();
        tx(s -> s.createNativeMutationQuery("update plainaccount set balance = 150").executeUpdate());
        long second = reader.createNativeQuery("select balance from plainaccount where id = :id", Long.class).setParameter("id", id).getSingleResult();
        p("%-16s: first read %d, another transaction commits 150, second read %d -> %s", level, first, second, first == second ? "repeatable" : "non-repeatable read");

PostgreSQL default isolation level: read committed
read committed  : first read 100, another transaction commits 150, second read 150 -> non-repeatable read
repeatable read : first read 100, another transaction commits 150, second read 100 -> repeatable

tx(s -> s.find(Wallet.class, wid).getCoins().add(new Coin(25)));

Folder f = s.find(Folder.class, fid);
Doc d = new Doc("a.txt", f);
f.getDocs().add(d);

Wallet (owns a unidirectional @OneToMany): add a Coin -> version 0 -> 1
Folder (inverse, mappedBy @OneToMany)   : add a Doc  -> version 0 -> 0

tx(s -> s.find(Plain.class, pid).a = "two");

tx(s -> s.find(Wide.class, wid).a = "two");

default entity, change one column:
SQL> select p1_0.id,p1_0.a,p1_0.b,p1_0.c from Plain p1_0 where p1_0.id=?
SQL> update Plain set a=?,b=?,c=? where id=?
@DynamicUpdate entity, change one column:
SQL> select w1_0.id,w1_0.a,w1_0.b,w1_0.c from Wide w1_0 where w1_0.id=?
SQL> update Wide set a=? where id=?

List<Employee> hql = s.createSelectionQuery("from Employee e where e.salary > :min order by e.salary", Employee.class).setParameter("min", 150).getResultList();
p("HQL      -> %s", hql.stream().map(Employee::getName).toList());

CriteriaBuilder cb = sf.getCriteriaBuilder();
CriteriaQuery<Employee> cq = cb.createQuery(Employee.class);
Root<Employee> root = cq.from(Employee.class);
cq.select(root).where(cb.gt(root.get("salary"), 150)).orderBy(cb.asc(root.get("salary")));
List<Employee> crit = s.createSelectionQuery(cq).getResultList();
p("Criteria -> %s", crit.stream().map(Employee::getName).toList());

List<Employee> nat = s.createNativeQuery("select * from employee where salary > 150 order by salary", Employee.class).getResultList();
p("Native   -> %s", nat.stream().map(Employee::getName).toList());

HQL      -> [Cy, Ana]
Criteria -> [Cy, Ana]
Native   -> [Cy, Ana]
SQL> select e1_0.id,e1_0.city,e1_0.zip,e1_0.department_id,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.salary>? order by e1_0.salary
SQL> select e1_0.id,e1_0.city,e1_0.zip,e1_0.department_id,e1_0.level,e1_0.name,e1_0.salary from Employee e1_0 where e1_0.salary>? order by e1_0.salary
SQL> select * from employee where salary > 150 order by salary

List<EmployeeRow> rows = s.createSelectionQuery("select e.name, e.salary from Employee e order by e.salary", EmployeeRow.class).getResultList();
p("record projection -> %s", rows);

record projection -> [EmployeeRow[name=Bo, salary=100], EmployeeRow[name=Cy, salary=200], EmployeeRow[name=Ana, salary=300]]
entities loaded: 0
SQL> select e1_0.name,e1_0.salary from Employee e1_0 order by e1_0.salary
full entity query loads 3 entities

Employee e = s.createSelectionQuery("from Employee where name = 'Bo'", Employee.class).getSingleResult();
int n = s.createMutationQuery("update Employee set salary = 999").executeUpdate();
p("HQL bulk update touched %d rows", n);
p("the entity already loaded still says salary = %d", e.salary);
s.refresh(e);
p("after refresh() it says salary = %d", e.salary);
assertEquals(999, e.salary);

HQL bulk update touched 3 rows
the entity already loaded still says salary = 100
after refresh() it says salary = 999

@NamedQuery(name = "BrokenQuery.byTitle", query = "select b from BrokenQuery b where b.titel = :t")
public class BrokenQuery {

boot(BrokenQuery.class);

buildSessionFactory() failed with org.hibernate.query.NamedQueryValidationException:
  Errors in named queries:
    [1] Error in query named 'BrokenQuery.byTitle': Could not resolve attribute 'titel' of 'lab.hibernate.model.BrokenQuery' [select b from BrokenQuery b where b.titel = :t]