Pick a focused question that fits your time, stack, and interview goal.
How much time do you have?
Show one-drill sessions you can finish now.
24 results across 1 active filter
Page 1 of 1
Explains Spring's transactional proxy boundary and why an internal method call does not normally start independent advice.
Explains how managed changes become SQL at flush and why flush is not the same as a durable commit.
Connects identity, sequence, table, UUID, and assigned identifiers to database support, round trips, ordering, and batch inserts.
Explains mapping fetch semantics while separating them from the query-specific data shape an endpoint actually needs.
Compares joining an existing transaction, suspending it for an independent transaction, and using a savepoint-backed nested scope.
Uses generated repository behavior for simple cases and explicit query or implementation boundaries when the use case becomes complex.
Finds repeated association queries with SQL evidence and chooses a bounded fetch or projection without creating a cartesian result.
Combines JDBC batching, compatible identifiers, periodic flush and clear, bounded transactions, and explicit bulk-operation semantics.
Uses versioned migrations and staged compatibility instead of letting Hibernate mutate a production schema automatically.
Chooses stable entity equality across transient, managed, detached, and proxied instances without breaking hash collections.
Carries an original version through an API update and turns an optimistic-lock failure into an explicit conflict workflow.
Connects transient, managed, detached, and removed states to persist, merge, dirty checking, and safe update workflows.
Fixes lazy access outside the persistence context with explicit fetch and DTO mapping while explaining the tradeoff of Open Session in View.
Explains which side writes a foreign key or join table and why both sides of an in-memory bidirectional relationship must remain consistent.
Treats isolation as concurrency behavior and read-only and timeout as resource hints whose enforcement depends on the transaction stack.
Explains the persistence context as an identity map and unit of work that tracks managed entities through EntityManager.
Separates mandatory persistence-context identity from optional shared entity caching and its consistency tradeoffs.
Separates propagation of entity operations from deletion of dependent children removed from an owning relationship.
Separates the persistence specification, its ORM implementation, and Spring's repository abstraction while keeping generated SQL visible.
Explains default rollback behavior, checked exceptions, rollback rules, swallowed failures, and commit-time exceptions.
Chooses among explicit joins, reusable fetch graphs, and bounded secondary selects based on query shape and cardinality.
Chooses a query representation from static versus dynamic shape, portability, database features, readability, and performance evidence.
Chooses version-based conflict detection or database locks from contention, transaction duration, and invariant needs.
Places a short transaction around one application use case while keeping remote calls, user interaction, and bulk work outside.