View Categories

What are constraints in SQL?

Parthiban Kannan
Updated on December 2, 2025

2 min read

Constraints in SQL are rules applied to table columns to maintain data accuracy, integrity, and consistency in the database. They ensure that only valid data gets inserted or updated, which helps prevent logical and data-entry errors at the database level — rather than relying only on application logic.

Some of the most common constraints include:

  • PRIMARY KEY → Ensures each record is unique and not null.
    Example:
🗃️
filename.sql 
CREATE TABLE Employees (
    EmpID INT PRIMARY KEY,
    Name VARCHAR(50),
    Department VARCHAR(30)
);

Here, EmpID uniquely identifies each employee.

FOREIGN KEY → Maintains referential integrity between two tables.

🗃️
filename.sql 
CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    EmpID INT,
    FOREIGN KEY (EmpID) REFERENCES Employees(EmpID)
);

This ensures an order can’t exist for an employee who isn’t present in the Employees table.

UNIQUE → Ensures all values in a column are distinct.
For instance, I’ve used a UNIQUE constraint on Email in a Customers table to avoid duplicate registrations.

CHECK → Restricts the values allowed in a column.

🗃️
filename.sql 
CHECK (Salary > 0)

I’ve used this to validate that numeric fields like salary or quantity are positive.

DEFAULT → Assigns a default value when no value is provided.

🗃️
filename.sql 
DEFAULT 'Active'
  • This ensures consistency when users omit optional fields.
  • NOT NULL → Ensures a column cannot store null values.
    I apply this for essential fields like Name or DateOfBirth.

In practice, I used constraints heavily in a payroll system to prevent invalid data entry — for example, ensuring that every salary record was linked to a valid employee (FOREIGN KEY) and that deductions never exceeded the gross salary (CHECK constraint).

A challenge I’ve faced was when inserting data into multiple related tables — foreign key constraints would fail if the parent record wasn’t inserted first. To handle this, I ensured proper insertion order and sometimes temporarily disabled constraints during bulk imports (with caution).

One limitation is that overly restrictive constraints can block valid data scenarios if not well-planned, so designing them requires a balance between data protection and flexibility.

In short, constraints act as database-level guards, ensuring data reliability — by enforcing uniqueness, valid relationships, and correct values — before the data ever reaches your application logic.

Scroll to Top