Foreign Key and Referential Integrity

Direct Answer

A foreign key is one or more columns that reference a primary key or another UNIQUE candidate key. For each non-NULL foreign-key value, the database checks that a matching referenced row exists. It also blocks or applies the configured action to parent updates and deletes, which prevents broken references.

Code Example

import jakarta.persistence.*;

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)  // Foreign key relationship
    @JoinColumn(name = "customer_id", nullable = false)
    private Customer customer;  // Hibernate maps this to customer_id column
    
    private Double totalAmount;
    private String status;
}

// The database enforces this at the schema level:
// ALTER TABLE orders 
//   ADD CONSTRAINT fk_orders_customer 
//   FOREIGN KEY (customer_id) 
//   REFERENCES customers(id)
//   ON DELETE RESTRICT;  // Prevents deleting customers with orders

Common Mistakes & Pitfalls

• Treating the JPA mapping as the constraint: @ManyToOne and @JoinColumn describe the object-relational mapping. A real database constraint exists only when the schema or migration creates it, so verify the generated DDL or migration.
• Assuming every database handles indexes the same way: InnoDB requires a suitable index on the child columns and may create one automatically. PostgreSQL does not automatically create an index on the referencing columns. Add or keep an index when joins, parent deletes, or updates in the actual workload benefit from it.
• Ignoring referential actions: SQL uses NO ACTION when no action is specified, but databases differ in timing and in how they treat NO ACTION and RESTRICT. Choose CASCADE, SET NULL, or a blocking action deliberately; SET NULL also requires nullable child columns.