Hibernate / Hibernate 7 Basics Interview Questions

// Raw JDBC (boilerplate):
try (Connection c = ds.getConnection();
     PreparedStatement ps = c.prepareStatement("SELECT * FROM products WHERE id=?")) {
    ps.setLong(1, id);
    ResultSet rs = ps.executeQuery();
    // manually map columns to fields...
}

// Hibernate 7 (clean):
try (Session s = sf.openSession()) {
    return s.find(Product.class, id);
}

<!-- Standalone -->
<dependency>
    <groupId>org.hibernate.orm</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>7.4.0.Final</version>
</dependency>

<!-- Spring Boot 4 (managed version) -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <!-- Includes hibernate-core 7.x transitively -->
</dependency>

<!-- Annotation processor for static metamodel -->
<dependency>
    <groupId>org.hibernate.orm</groupId>
    <artifactId>hibernate-processor</artifactId>
    <version>7.4.0.Final</version>
    <scope>provided</scope>
</dependency>

import jakarta.persistence.*;

@Entity
@Table(name = "products")
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "product_name", nullable = false, length = 200)
    private String name;

    @Column(precision = 10, scale = 2)
    private BigDecimal price;

    @Enumerated(EnumType.STRING)  // store as 'ACTIVE' not 0/1
    private ProductStatus status;

    protected Product() {}  // JPA proxy constructor
    public Product(String name, BigDecimal price) {
        this.name = name;
        this.price = price;
        this.status = ProductStatus.ACTIVE;
    }
}

// TRANSIENT
Product p = new Product("Laptop", new BigDecimal("999"));

// TRANSIENT -> PERSISTENT
session.persist(p);  // INSERT scheduled

// Auto dirty checking: change field -> UPDATE at flush
p.setPrice(new BigDecimal("899"));
session.getTransaction().commit();  // flush: UPDATE sent

// PERSISTENT -> DETACHED (session closes)
// p is detached: changes NOT tracked

// Hibernate 7: ONLY merge() re-integrates detached entities
Product managed = session2.merge(p);  // copies detached state
managed.setPrice(new BigDecimal("799"));

// Hibernate 6 (worked but deprecated):
session.update(detachedProduct);  // REMOVED in Hibernate 7!

// Hibernate 7 - use merge():
Product managed = session.merge(detachedProduct);
managed.setPrice(new BigDecimal("50"));  // modify managed copy
session.getTransaction().commit();

// Adding detached child to managed parent:
// WRONG in Hibernate 7:
parent.addChild(detachedChild);  // throws EntityExistsException at flush!

// CORRECT:
Child managedChild = session.merge(detachedChild);
parent.addChild(managedChild);

session.beginTransaction();

// CREATE
Product p = new Product("Book", new BigDecimal("19.99"));
session.persist(p);  // replaces save()

// READ: returns null if not found
Product found = session.find(Product.class, 1L);  // replaces get()

// READ lazy proxy
Product ref = session.getReference(Product.class, 1L);

// UPDATE: automatic dirty checking - no explicit call needed
found.setPrice(new BigDecimal("24.99"));

// DELETE
session.remove(found);  // replaces delete()

// MERGE: integrate detached state
Product copy = session.merge(detached);

session.getTransaction().commit();

Configuration config = new Configuration();
config.setProperty("hibernate.connection.url", "jdbc:postgresql://localhost:5432/mydb");
config.setProperty("hibernate.connection.username", "user");
config.setProperty("hibernate.connection.password", "secret");
config.setProperty("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
config.setProperty("hibernate.hbm2ddl.auto", "validate");
config.setProperty("hibernate.show_sql", "true");

config.addAnnotatedClass(Product.class);
config.addAnnotatedClass(Order.class);

// Build once, reuse everywhere:
SessionFactory sf = config.buildSessionFactory();

// Usage:
try (Session session = sf.openSession()) {
    session.beginTransaction();
    // operations
    session.getTransaction().commit();
}

// Basic HQL - uses entity class name, not table name:
List<Product> all = session
    .createQuery("FROM Product", Product.class)
    .getResultList();

// WHERE with named parameter:
List<Product> active = session
    .createQuery("FROM Product WHERE status = :status", Product.class)
    .setParameter("status", ProductStatus.ACTIVE)
    .getResultList();

// Constructor expression (DTO projection):
List<ProductSummary> s = session
    .createQuery(
        "SELECT new com.example.ProductSummary(p.id, p.name, p.price) "
        + "FROM Product p WHERE p.price < :max",
        ProductSummary.class)
    .setParameter("max", new BigDecimal("100"))
    .getResultList();

// JOIN on association fields:
List<Order> orders = session
    .createQuery("FROM Order o JOIN o.customer c WHERE c.email = :email", Order.class)
    .setParameter("email", "alice@example.com")
    .getResultList();

// Pagination:
List<Product> page = session
    .createQuery("FROM Product ORDER BY createdAt DESC", Product.class)
    .setFirstResult(0).setMaxResults(20).getResultList();

// Hibernate 7 new: regexp operator
List<Product> matched = session
    .createQuery("FROM Product WHERE name regexp :pattern", Product.class)
    .setParameter("pattern", "^(Laptop|Phone)")
    .getResultList();

// JPQL (standard):
EntityManager em = emf.createEntityManager();
List<Product> p = em
    .createQuery("SELECT p FROM Product p WHERE p.price < :max", Product.class)
    .setParameter("max", new BigDecimal("100"))
    .getResultList();

// HQL shorthand (Hibernate-specific):
List<Product> p2 = session
    .createQuery("FROM Product WHERE price < :max", Product.class)
    .setParameter("max", new BigDecimal("100"))
    .getResultList();

// HQL-only: regexp
List<Product> re = session
    .createQuery("FROM Product WHERE name regexp :pat", Product.class)
    .setParameter("pat", "^(Laptop|Phone)").getResultList();

// UNION (supported in both JPQL 3.2 and HQL):
List<Object[]> combined = session.createQuery(
    "SELECT p.id, p.name FROM Product p WHERE p.category = :cat "
    + "UNION "
    + "SELECT s.id, s.name FROM Service s WHERE s.category = :cat",
    Object[].class).setParameter("cat", "tech").getResultList();

// IDENTITY:
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

// SEQUENCE (recommended for batch inserts):
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "product_seq")
@SequenceGenerator(name="product_seq", sequenceName="product_id_seq", allocationSize=50)
private Long id;

// UUID (first-class in Hibernate 7):
@Id @GeneratedValue(strategy = GenerationType.UUID)
private UUID id;

// Time-based UUID v7:
@Id @UuidGenerator(style = UuidGenerator.Style.TIME)
private UUID id;

Session session = sf.openSession();
session.beginTransaction();

Product p1 = session.find(Product.class, 1L);  // DB hit
Product p2 = session.find(Product.class, 1L);  // CACHE HIT - no SQL!
Product p3 = session.find(Product.class, 1L);  // CACHE HIT

System.out.println(p1 == p2);  // true! Same object reference

// Evict specific entity:
session.detach(p1);  // p1 is now DETACHED
Product p4 = session.find(Product.class, 1L);  // DB hit again

// Clear entire cache:
session.clear();  // all entities become DETACHED

// Bulk processing pattern (prevent OutOfMemoryError):
for (int i = 0; i < 100_000; i++) {
    session.persist(products.get(i));
    if (i % 50 == 0) {
        session.flush();   // write to DB
        session.clear();   // free cache memory
    }
}

// Enable L2 cache on an entity:
@Entity
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Country {
    @Id private Long id;
    private String name;
}

// Spring Boot 4 configuration:
// spring.jpa.properties.hibernate.cache.use_second_level_cache=true

// HIBERNATE 7: StatelessSession now uses L2 cache by default!
// To bypass (for bulk processing):
StatelessSession ss = sf.openStatelessSession();
ss.setCacheMode(CacheMode.IGNORE);  // bypass L2 cache

// LAZY (default for @OneToMany):
@OneToMany(mappedBy="customer", fetch=FetchType.LAZY)
private List<Order> orders;

// N+1 PROBLEM:
// 1 query: SELECT * FROM customers
// N queries: SELECT * FROM orders WHERE customer_id=1 ... customer_id=N
List<Customer> customers = session.createQuery("FROM Customer", Customer.class).getResultList();
for (Customer c : customers) {
    c.getOrders().size();  // triggers N extra queries!
}

// SOLUTION 1: JOIN FETCH
List<Customer> customers = session
    .createQuery("FROM Customer c JOIN FETCH c.orders", Customer.class)
    .getResultList();  // 1 query with JOIN

// SOLUTION 2: @BatchSize
@OneToMany(mappedBy="customer")
@BatchSize(size=25)  // loads 25 collections in one IN query
private List<Order> orders;

// SOLUTION 3: EntityGraph
EntityGraph<Customer> graph = session.createEntityGraph(Customer.class);
graph.addAttributeNode("orders");
List<Customer> list = session.createSelectionQuery("FROM Customer", Customer.class)
    .applyFetchGraph(graph).getResultList();

@Entity
public class Customer {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(
        mappedBy="customer",
        cascade=CascadeType.ALL,
        orphanRemoval=true,
        fetch=FetchType.LAZY
    )
    private List<Order> orders = new ArrayList<>();

    public void addOrder(Order o) {
        orders.add(o);
        o.setCustomer(this);  // keep both sides in sync!
    }
}

@Entity @Table(name="orders")
public class Order {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;
    private BigDecimal total;

    @ManyToOne(fetch=FetchType.LAZY)  // explicit LAZY recommended
    @JoinColumn(name="customer_id", nullable=false)
    private Customer customer;  // owning side: holds FK
}

// Usage:
Customer c = new Customer("Alice");
c.addOrder(new Order(new BigDecimal("50")));
session.persist(c);  // cascades to orders

try (StatelessSession ss = sf.openStatelessSession()) {
    ss.beginTransaction();

    // Hibernate 7: must set batch size explicitly on StatelessSession!
    ss.setJdbcBatchSize(50);  // hibernate.jdbc.batch_size has NO effect here

    // New batch operations in Hibernate 7:
    ss.insertMultiple(products);   // batch inserts
    ss.updateMultiple(toUpdate);   // batch updates

    // Bypass L2 cache for bulk operations (new default is to use it):
    ss.setCacheMode(CacheMode.IGNORE);

    // Scrollable results for very large datasets:
    ScrollableResults<Product> scroll = ss
        .createQuery("FROM Product", Product.class)
        .scroll(ScrollMode.FORWARD_ONLY);
    while (scroll.next()) {
        Product p = scroll.get();
        p.setPrice(p.getPrice().multiply(new BigDecimal("0.9")));
        ss.update(p);  // explicit - no dirty checking
    }
    ss.getTransaction().commit();
}

// Static metamodel auto-generated by hibernate-processor:
// public abstract class Product_ {
//     public static volatile SingularAttribute<Product, Long> id;
//     public static volatile SingularAttribute<Product, String> name;
//     public static volatile SingularAttribute<Product, BigDecimal> price;
// }

// Hibernate 7: NEW SelectionSpecification API
var results = SelectionSpecification
    .create(Product.class)
    .restrict(Restriction.equal(Product_.status, ProductStatus.ACTIVE))
    .restrict(Restriction.contains(Product_.name, "book", false))
    .restrict(Restriction.greaterThan(Product_.price, new BigDecimal("10")))
    .sort(Order.desc(Product_.price))
    .createQuery(session)
    .setMaxResults(20)
    .getResultList();

// RestrictionSpecification: add restrictions to an EXISTING query
var priceFilter = RestrictionSpecification
    .of(Product.class)
    .where(Restriction.between(Product_.price, new BigDecimal("10"), new BigDecimal("100")));

var update = session.createMutationQuery("UPDATE Product SET discount = :disc");
priceFilter.applyTo(update);
update.setParameter("disc", new BigDecimal("5")).executeUpdate();

// Traditional JPA Criteria still works:
CriteriaBuilder cb = session.getCriteriaBuilder();
CriteriaQuery<Product> cq = cb.createQuery(Product.class);
Root<Product> root = cq.from(Product.class);
cq.where(cb.equal(root.get(Product_.status), ProductStatus.ACTIVE));
List<Product> r = session.createQuery(cq).getResultList();

@Embeddable
public class Address {
    @Column(name="street") private String street;
    @Column(name="city")   private String city;
    @Column(name="postcode", length=10) private String postcode;
}

@Entity
public class Customer {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;
    private String name;

    @Embedded
    private Address shippingAddress;  // columns: street, city, postcode

    // Hibernate 6 approach (verbose - one @AttributeOverride per field):
    @Embedded
    @AttributeOverrides({
        @AttributeOverride(name="street",   column=@Column(name="billing_street")),
        @AttributeOverride(name="city",     column=@Column(name="billing_city")),
        @AttributeOverride(name="postcode", column=@Column(name="billing_postcode"))
    })
    private Address billingAddress;

    // Hibernate 7 NEW (incubating): much simpler!
    // @Embedded
    // @EmbeddedColumnNaming("billing_{column_name}")
    // private Address billingAddress;
    // Generates: billing_street, billing_city, billing_postcode
}

// Before JP 3.2: separate methods for different behaviours
// After: varargs options on find()
import jakarta.persistence.Timeouts;

// Find with pessimistic lock and no-wait timeout:
Book book = session.find(
    Book.class,
    isbn,
    LockModeType.PESSIMISTIC_WRITE,
    Timeouts.NO_WAIT  // fail immediately if locked
);

// Find bypassing second-level cache:
Book book2 = session.find(
    Book.class, isbn,
    CacheRetrieveMode.BYPASS
);

// session.findMultiple(): batch load multiple entities
List<Book> books = session.findMultiple(
    Book.class,
    List.of(isbn1, isbn2, isbn3)
);
// Loads all 3 in a single SELECT ... WHERE id IN (?,?,?)

// RefreshOption:
session.refresh(managedBook, LockModeType.PESSIMISTIC_READ);

// LockOption:
session.lock(managedBook, LockModeType.PESSIMISTIC_WRITE,
    Timeouts.of(5, TimeUnit.SECONDS));

@Entity
public class Product {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;
    private String name;
    private BigDecimal price;

    @Version  // Hibernate manages automatically
    private Long version;
}

// How it works:
// Load:   SELECT id, name, price, version FROM products WHERE id=1
//         version=5
// Modify: product.setPrice(new BigDecimal("99"))
// Flush:  UPDATE products SET price=99, version=6 WHERE id=1 AND version=5
//         If another TX updated it: version!=5 -> OptimisticLockException!

// Handling conflicts:
for (int attempt = 0; attempt < 3; attempt++) {
    try (Session session = sf.openSession()) {
        session.beginTransaction();
        Product p = session.find(Product.class, productId);
        p.setPrice(p.getPrice().multiply(new BigDecimal("0.9")));
        session.getTransaction().commit();
        break;  // success
    } catch (OptimisticLockException e) {
        if (attempt == 2) throw e;
        Thread.sleep(50 * (attempt + 1));
    }
}

// PESSIMISTIC_WRITE: SELECT ... FOR UPDATE
Product p = session.find(Product.class, id, LockModeType.PESSIMISTIC_WRITE);

// Hibernate 7: Timeouts API
import jakarta.persistence.Timeouts;

// Fail immediately if lock unavailable:
Product p2 = session.find(Product.class, id,
    LockModeType.PESSIMISTIC_WRITE, Timeouts.NO_WAIT);

// Wait up to 5 seconds:
Product p3 = session.find(Product.class, id,
    LockModeType.PESSIMISTIC_WRITE, Timeouts.of(5, TimeUnit.SECONDS));

// Lock an already-managed entity:
session.lock(managed, LockModeType.PESSIMISTIC_WRITE, Timeouts.NO_WAIT);

// Lock modes:
// PESSIMISTIC_READ  -> SELECT FOR SHARE
// PESSIMISTIC_WRITE -> SELECT FOR UPDATE

@Entity
public class Student {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id;
    private String name;

    @ManyToMany(fetch=FetchType.LAZY)
    @JoinTable(
        name="student_course",
        joinColumns=@JoinColumn(name="student_id"),
        inverseJoinColumns=@JoinColumn(name="course_id")
    )
    private Set<Course> courses = new HashSet<>();

    public void enrollIn(Course c) {
        courses.add(c);
        c.getStudents().add(this);  // keep both sides in sync!
    }
}

@Entity
public class Course {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id;
    private String title;

    @ManyToMany(mappedBy="courses")  // inverse side
    private Set<Student> students = new HashSet<>();
}

// When you need extra columns on the join: use an explicit join entity!
@Entity public class Enrollment {
    @Id @GeneratedValue private Long id;
    @ManyToOne @JoinColumn(name="student_id") private Student student;
    @ManyToOne @JoinColumn(name="course_id")  private Course course;
    private LocalDate enrolledAt;  // impossible with @ManyToMany
    private String grade;
}

// AUTO flush mode (default):
Product p = new Product("Laptop", new BigDecimal("999"));
session.persist(p);  // INSERT scheduled, NOT sent yet

// Query triggers flush in AUTO mode:
Long count = session.createQuery("SELECT COUNT(p) FROM Product p", Long.class)
    .getSingleResult();  // INSERT flushed first so count is accurate

// Explicit flush:
session.flush();  // sends SQL but does NOT commit

// Check for pending changes:
session.isDirty();  // true if unflushed changes exist

// SQL ordering at flush: INSERT -> UPDATE -> DELETE
// Prevents FK constraint violations

@Entity
@NamedQuery(
    name="Product.findByCategory",
    query="FROM Product p WHERE p.category = :category ORDER BY p.price ASC"
)
public class Product {
    @Id private Long id;
    private String name;
    private String category;
}

// Traditional way (error-prone string reference):
List<Product> p = session
    .createNamedQuery("Product.findByCategory", Product.class)
    .setParameter("category", "electronics")
    .getResultList();
// Typo in "Product.findByCategory" = runtime exception!

// Jakarta Persistence 3.2 / Hibernate 7:
// TypedQueryReference in static metamodel:
// Product_: public static final TypedQueryReference<Product> QUERY_FIND_BY_CATEGORY;

List<Product> p2 = session
    .createQuery(Product_.QUERY_FIND_BY_CATEGORY)  // compile-time safe!
    .setParameter("category", "electronics")
    .getResultList();
// Renaming the named query = compile error, not runtime exception!

// SINGLE_TABLE (most common):
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="payment_type", discriminatorType=DiscriminatorType.STRING)
public abstract class Payment {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id;
    private BigDecimal amount;
}

@Entity @DiscriminatorValue("CREDIT_CARD")
public class CreditCardPayment extends Payment {
    private String cardNumber;
}

@Entity @DiscriminatorValue("BANK_TRANSFER")
public class BankTransferPayment extends Payment {
    private String iban;
}

// JOINED:
@Entity @Inheritance(strategy=InheritanceType.JOINED)
public abstract class Vehicle {
    @Id @GeneratedValue private Long id;
    private String registration;
}
@Entity @Table(name="cars") public class Car extends Vehicle { private int doors; }

@FilterDef(
    name="activeFilter",
    parameters=@ParamDef(name="isActive", type=Boolean.class)
)
@Filter(name="activeFilter", condition="is_active = :isActive")
@Entity
public class Product {
    @Id private Long id;
    private String name;
    private boolean isActive;
}

// Enable for this session:
session.enableFilter("activeFilter").setParameter("isActive", true);
// All Product queries now silently include: AND is_active = true
List<Product> active = session.createQuery("FROM Product", Product.class).getResultList();
session.disableFilter("activeFilter");

// HIBERNATE 7: auto-enabled filter for multi-tenancy
@FilterDef(
    name="tenantFilter",
    parameters=@ParamDef(name="tenantId", type=Long.class),
    autoEnabled=true  // no session.enableFilter() needed!
)
@Filter(name="tenantFilter", condition="tenant_id = :tenantId")
@Entity public class Order { ... }
// FilterDefContributor SPI resolves tenantId from ThreadLocal automatically

// OFFSET PAGINATION (gets slower at depth):
List<Product> page1000 = session
    .createQuery("FROM Product ORDER BY id ASC", Product.class)
    .setFirstResult(19_980)  // DB must scan and skip 19,980 rows!
    .setMaxResults(20)
    .getResultList();

// HIBERNATE 7: Key-based pagination (O(1) at any depth)
import org.hibernate.query.KeyedPage;
import org.hibernate.query.KeyedResultList;

// First page:
KeyedResultList<Product> page = session
    .createQuery("FROM Product", Product.class)
    .getKeyedResultList(
        KeyedPage.firstPage(20, Order.asc(Product_.id))
    );
List<Product> products = page.getResultList();

// Next page (use key from previous result):
if (page.getNextPage() != null) {
    KeyedResultList<Product> next = session
        .createQuery("FROM Product", Product.class)
        .getKeyedResultList(page.getNextPage());
}
// Generated SQL: WHERE id > :lastId ORDER BY id ASC LIMIT 20

import jakarta.data.repository.*;

@Repository
public interface ProductRepository extends CrudRepository<Product, Long> {

    // Method name derivation:
    List<Product> findByStatus(ProductStatus status);
    List<Product> findByPriceLessThan(BigDecimal maxPrice);
    long countByStatus(ProductStatus status);

    // @Find: type-safe field query
    @Find
    List<Product> findByCategory(
        @By(Product_.CATEGORY) String category,
        @OrderBy(Product_.PRICE) Sort.Direction dir
    );

    // @Query: JPQL
    @Query("FROM Product WHERE status = :status AND price < :maxPrice")
    List<Product> findCheapActive(
        @Param("status") ProductStatus status,
        @Param("maxPrice") BigDecimal maxPrice
    );

    // Key-based pagination:
    Page<Product> findByCategory(String category, PageRequest page);
}

// Usage - inject like any Spring bean:
@Autowired ProductRepository repo;
List<Product> active = repo.findByStatus(ProductStatus.ACTIVE);

@Entity
public class Book {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;         // surrogate PK (internal)

    @NaturalId               // business identifier (external)
    @Column(unique=true, nullable=false)
    private String isbn;

    private String title;
}

// Optimised lookup (uses L2 cache):
Book book = session.byNaturalId(Book.class)
    .using("isbn", "978-0-13-468599-1").load();

// @NaturalIdClass: COMPOSITE natural IDs (NEW in Hibernate 7)
public class EmployeeNaturalId {
    String companyCode;
    String employeeNumber;
    // equals() and hashCode() required
}

@Entity
@NaturalIdClass(EmployeeNaturalId.class)  // NEW in Hibernate 7
public class Employee {
    @Id @GeneratedValue private Long id;
    @NaturalId String companyCode;
    @NaturalId String employeeNumber;
    private String name;
}

// Lookup by composite natural ID:
Employee emp = session.byNaturalId(Employee.class)
    .using("companyCode", "ACME")
    .using("employeeNumber", "EMP-001").load();

import org.hibernate.annotations.Array;
import org.hibernate.type.SqlTypes;

@Entity
public class Document {
    @Id @GeneratedValue private Long id;
    private String content;

    // Float32 vector (e.g. OpenAI text-embedding-3 embeddings):
    @JdbcTypeCode(SqlTypes.VECTOR)
    @Array(length=1536)  // number of dimensions
    private float[] embedding;

    // Binary vector (Hibernate 7.2+):
    @JdbcTypeCode(SqlTypes.VECTOR_BINARY)
    @Array(length=24)
    private byte[] binaryVector;

    // Half-precision float16 (Hibernate 7.2+):
    @JdbcTypeCode(SqlTypes.VECTOR_FLOAT16)
    @Array(length=1536)
    private float[] halfPrecisionEmbedding;
}

// Vector similarity search (pgvector required):
List<Object[]> similar = session
    .createNativeQuery(
        "SELECT d.id, d.content, d.embedding <=> :queryVec AS distance "
        + "FROM document d ORDER BY distance ASC LIMIT 10", Object[].class)
    .setParameter("queryVec", queryEmbedding)
    .getResultList();

// HQL distance functions (Hibernate 7.1+):
List<Document> results = session
    .createQuery("FROM Document d ORDER BY cosine_distance(d.embedding, :vec) ASC", Document.class)
    .setParameter("vec", queryEmbedding).setMaxResults(10).getResultList();

// Automated migration:
// mvn rewrite:run -Drewrite.activeRecipes=org.openrewrite.hibernate.MigrateToHibernate70

// Manual: detached entity handling
// BEFORE:
session.update(detachedOrder);       // REMOVED!
detachedOrder.setStatus("DONE");
// AFTER:
Order managed = session.merge(detachedOrder);
managed.setStatus("DONE");

import org.hibernate.annotations.SQLRestriction;

// Soft-delete: only ever load non-deleted records
@Entity
@SQLRestriction("deleted_at IS NULL")  // applied to ALL queries
public class Product {
    @Id private Long id;
    private String name;
    private LocalDateTime deletedAt;

    public void softDelete() { this.deletedAt = LocalDateTime.now(); }
}
// session.find(Product.class, id) -> only finds non-deleted products
// 'FROM Product' HQL -> only returns non-deleted products

// On a collection:
@OneToMany(mappedBy="category")
@SQLRestriction("deleted_at IS NULL")  // only active products in collection
private List<Product> activeProducts;

// @SQLJoinTableRestriction: restrict on join table for @ManyToMany
@ManyToMany
@JoinTable(name="student_course")
@SQLJoinTableRestriction("enrolled_at > CURRENT_DATE - INTERVAL '1 year'")
private List<Course> recentCourses;

// NOTE: @Where (old annotation) was REMOVED in Hibernate 7
// @Where(clause="deleted_at IS NULL")  <- REMOVED
// @SQLRestriction("deleted_at IS NULL") <- USE THIS

# Recommended production setup:
spring:
  jpa:
    hibernate:
      ddl-auto: none       # Hibernate does NOT touch schema
  flyway:
    enabled: true          # Flyway manages schema with versioned migrations
    locations: classpath:db/migration

# Development:
spring:
  jpa:
    hibernate:
      ddl-auto: create-drop  # fresh schema each run

# Flyway migration files:
# db/migration/V1__create_products_table.sql
# db/migration/V2__add_category_to_products.sql

// DISCRIMINATOR (most common in Hibernate 7)
@FilterDef(
    name="tenantFilter",
    parameters=@ParamDef(name="tenantId", type=String.class),
    autoEnabled=true  // Hibernate 7: auto-enabled!
)
@Filter(name="tenantFilter", condition="tenant_id = :tenantId")
@Entity
public class Order {
    @Id private Long id;
    private String tenantId;  // discriminator column
    private BigDecimal total;
}

// FilterDefContributor SPI: auto-resolves tenantId from ThreadLocal
public class TenantFilterContributor implements FilterDefContributor {
    @Override
    public void contribute(FilterDefTarget target) {
        target.registerFilterDefinition(
            FilterDefinition.of("tenantFilter",
                Map.of("tenantId", TenantContext::getCurrentTenantId))
        );
    }
}

// DATABASE strategy: supply different connections per tenant
public class TenantConnectionProvider implements MultiTenantConnectionProvider<String> {
    @Override
    public Connection getConnection(String tenantId) {
        return dataSourceMap.get(tenantId).getConnection();
    }
}

@Entity
@Check(name="price_positive", constraints="price > 0")  // table-level check
public class Product {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id;
    private String name;

    @Column(nullable=false)
    @Check(name="stock_non_negative", constraints="stock >= 0")  // column-level
    private int stock;

    @Column(precision=10, scale=2)
    private BigDecimal price;

    @ColumnDefault("'ACTIVE'")  // DEFAULT 'ACTIVE' in DDL
    @Column(nullable=false)
    private String status;

    @ColumnDefault("CURRENT_TIMESTAMP")
    @Generated(EventType.INSERT)  // re-read from DB after INSERT
    private LocalDateTime createdAt;
}

// Generated DDL:
// CREATE TABLE product (
//   id BIGINT NOT NULL,
//   stock INTEGER NOT NULL CHECK (stock >= 0),
//   price NUMERIC(10,2),
//   status VARCHAR(255) DEFAULT 'ACTIVE',
//   created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
//   CONSTRAINT price_positive CHECK (price > 0)
// )

@Entity
public class Customer {
    @Id private Long id;
    private String name;

    @OneToMany(mappedBy="customer", fetch=FetchType.LAZY)
    @BatchSize(size=25)  // load 25 collections at once
    private List<Order> orders;
}

// Without @BatchSize:
// 1 query: SELECT * FROM customers LIMIT 100
// 100 queries: SELECT * FROM orders WHERE customer_id=1 ... customer_id=100
// Total: 101 queries

// With @BatchSize(size=25):
// 1 query: SELECT * FROM customers LIMIT 100
// 4 queries: SELECT * FROM orders WHERE customer_id IN (1..25)
//             SELECT * FROM orders WHERE customer_id IN (26..50)
//             SELECT * FROM orders WHERE customer_id IN (51..75)
//             SELECT * FROM orders WHERE customer_id IN (76..100)
// Total: 5 queries!

// Global default:
# spring.jpa.properties.hibernate.default_batch_fetch_size=100

// @BatchSize on entity for proxy loading:
@Entity @BatchSize(size=20)
public class Product { ... }

import org.hibernate.annotations.Struct;

@Embeddable
@Struct(name="address_type")  // maps to the DB composite type
public record AddressType(
    String street,
    String city,
    String postcode,
    String countryCode
) {}

@Entity
public class Customer {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id;
    private String name;

    @Column(name="shipping_address")  // single column of type address_type!
    private AddressType shippingAddress;
}

// PostgreSQL DDL:
// CREATE TYPE address_type AS (
//   street       VARCHAR(255),
//   city         VARCHAR(100),
//   postcode     VARCHAR(10),
//   country_code VARCHAR(2)
// );
// CREATE TABLE customer (
//   id               BIGINT PRIMARY KEY,
//   name             VARCHAR(255),
//   shipping_address address_type  -- single composite column!
// );

// HQL querying the struct:
List<Customer> london = session
    .createQuery("FROM Customer c WHERE c.shippingAddress.city = :city", Customer.class)
    .setParameter("city", "London").getResultList();
// Generated: WHERE (shipping_address).city = 'London'

# Hibernate 7 logging configuration:
logging:
  level:
    # SQL statement logging:
    org.hibernate.SQL: DEBUG            # shows the SQL

    # SQL parameter values (NEW - no P6Spy proxy needed!):
    org.hibernate.orm.jdbc.bind: TRACE  # logs actual parameter values
    # Output example:
    # binding parameter (1:VARCHAR) <- [alice@example.com]
    # binding parameter (2:BIGINT)  <- [42]

    # Result set extraction:
    org.hibernate.orm.jdbc.extract: TRACE

spring:
  jpa:
    show-sql: false   # deprecated - use logging.level.org.hibernate.SQL
    properties:
      hibernate:
        format_sql: true
        generate_statistics: true
        # REMOVED in Hibernate 7:
        # use_sql_comments: true  <- use logging.level instead

// Hibernate statistics:
Statistics stats = sf.getStatistics();
stats.setStatisticsEnabled(true);
System.out.println("Queries: " + stats.getQueryExecutionCount());
System.out.println("L2 hits: " + stats.getSecondLevelCacheHitCount());
stats.logSummary();

<!-- spring-boot-starter-data-jpa includes:
     - hibernate-core 7.x
     - spring-data-jpa
     - HikariCP connection pool
     - jakarta.persistence-api 3.2 -->

# Complete application.yml for Hibernate 7 in Spring Boot 4:
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: ${DB_USER}
    password: ${DB_PASSWORD}
    hikari:
      maximum-pool-size: 20
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false
    open-in-view: false  # CRITICAL: disable OSIV in production!
    properties:
      hibernate:
        format_sql: true
        default_batch_fetch_size: 100
        jdbc:
          batch_size: 50
          order_inserts: true
          order_updates: true

logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.orm.jdbc.bind: TRACE