⭐ 6 Types of SQL Constraints Explained With Simple Examples (Easy 2026 Guide)

In any relational database, maintaining accuracy, validity, and consistency of data is essential. This is where SQL constraints play a crucial role. A constraint is a rule applied to a column or table that controls what type of data can be inserted, helping enforce data integrity and preventing incorrect, duplicate, or missing entries.

Whether you’re a beginner learning SQL or a developer building production-level applications, understanding constraints is key to designing robust and error-free databases. In this easy guide, we break down the 6 major types of SQL constraints with simple explanations, syntax, and practical SQL examples you can use right away.

Understanding SQL Constraints: Why They Matter

SQL constraints are rules applied to columns or tables that restrict the type of data that can be inserted. They ensure the database always maintains valid, consistent, and accurate information. By enforcing these rules at the database level, constraints provide stronger data integrity than relying on application logic alone.

In the next section, we’ll look at the 6 major types of SQL constraints and understand how each one works, along with simple syntax and practical SQL examples.

🧩 Types of SQL Constraints (With Examples)

1) NOT NULL

The NOT NULL constraint ensures that a column cannot store empty or missing values, making it essential for fields where data must always be provided. 


CREATE TABLE students (
  id INT,
  name VARCHAR(100) NOT NULL
);

2) UNIQUE

The UNIQUE constraint ensures that all values in a column are distinct. It prevents duplicate entries and is commonly used for fields like email or username. 


CREATE TABLE employees (
  emp_id INT PRIMARY KEY,
  email VARCHAR(150) UNIQUE
);

3) PRIMARY KEY

A PRIMARY KEY uniquely identifies each row in a table. It automatically applies both NOT NULL and UNIQUE, making it one of the most important constraints in SQL. 


CREATE TABLE products (
  product_id INT PRIMARY KEY,
  name VARCHAR(100),
  price DECIMAL(10,2)
);

4) FOREIGN KEY

A FOREIGN KEY constraint maintains referential integrity by linking a column in one table to the PRIMARY KEY of another table. It ensures valid relationships between tables. 


CREATE TABLE orders (
  order_id INT PRIMARY KEY,
  product_id INT,
  FOREIGN KEY (product_id) REFERENCES products(product_id)
);

5) CHECK

The CHECK constraint validates data based on a specific condition. It ensures that only values meeting the rule are allowed—for example, age must be 18 or above. 


CREATE TABLE users (
  user_id INT PRIMARY KEY,
  username VARCHAR(50) NOT NULL,
  age INT CHECK (age >= 18)
);

6) DEFAULT

The DEFAULT constraint automatically assigns a value to a column when no value is provided. It is useful for setting standard values such as account status or initial balance. 


CREATE TABLE accounts (
  acct_id INT PRIMARY KEY,
  balance DECIMAL(10,2) DEFAULT 0.00,
  status VARCHAR(20) DEFAULT 'active'
);

⚡ Why Are SQL Constraints Important?

SQL constraints are not just database rules—they are guardrails that keep your data accurate, secure, and meaningful. Without constraints, a database can quickly become inconsistent, error-prone, and unreliable.

🔑 Example: PRIMARY KEY in SQL

A PRIMARY KEY uniquely identifies each record in a table. Here’s a simple example using a students table: 


CREATE TABLE students (
  student_id INT PRIMARY KEY,
  name VARCHAR(100),
  age INT
);
student_id (PK) name age
101 Aman 20
102 Priya 22

✔ The PRIMARY KEY column (student_id) always contains unique, non-null values.

✔ Ensures Data Integrity

PRIMARY KEY and FOREIGN KEY constraints prevent duplicates and maintain valid relationships between tables.

✔ Enforces Business Rules

Constraints like CHECK and NOT NULL guarantee that only valid, business-approved values are stored in your database.

✔ Improves Query Performance

Unique indexes created by PRIMARY and UNIQUE constraints help databases run queries faster and more efficiently.

✔ Reduces Human Errors

By automatically rejecting invalid or missing data, constraints minimize mistakes and ensure clean, trustworthy records.

🚀 Key Takeaway

SQL constraints act as safety nets in database design. They protect data accuracy, enforce rules, and make your applications faster, smarter, and more reliable.

Foreign Key Constraint (With Simple Example Table)

A Foreign Key in SQL creates a connection between two tables. It ensures referential integrity by allowing only values that already exist in the parent table’s Primary Key column.

Example Tables (Customers → Orders)

📌 Customers Table (Parent Table)

CustomerID (PK) CustomerName
1 John Doe
2 Emma Watson

📌 Orders Table (Child Table with FOREIGN KEY)

OrderID (PK) CustomerID (FK) Product
101 1 Laptop
102 2 Headphones

SQL Code Example of Foreign Key 

CREATE TABLE Customers (
    CustomerID INT PRIMARY KEY,
    CustomerName VARCHAR(100)
);

CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    Product VARCHAR(100),
    FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);

Foreign Keys Keep Your Data Consistent

This constraint ensures that every order belongs to a valid customer — preventing invalid or orphaned records.

Unique Constraint in SQL (With Example Table & Use Cases)

The UNIQUE constraint in SQL ensures that no two rows contain the same value in a given column. It is commonly used for fields like email, phone numbers, usernames, and product codes where duplicates must be avoided.

Example Table (Users Table With UNIQUE Columns)

UserID (PK) Username (UNIQUE) Email (UNIQUE)
1 john_doe john@example.com
2 emma123 emma@example.com

This table shows how Username and Email must both remain unique.

🔑 Key Points About SQL Unique Constraint:

  • Ensures Uniqueness: No duplicate values allowed in the column.
  • Multiple Unique Columns: A table can have more than one UNIQUE field.
  • NULL Allowed: A UNIQUE column can store a single NULL value.
  • Common Use Cases: Emails, usernames, phone numbers, product SKUs.

Example of Unique Constraint in SQL: 

CREATE TABLE Users (
    UserID INT PRIMARY KEY,
    Username VARCHAR(100) UNIQUE,
    Email VARCHAR(100) UNIQUE
);

Both Username and Email are marked as UNIQUE, ensuring no duplicate entries can exist in these columns.

✅ Why Unique Constraints Matter in SQL

The UNIQUE constraint prevents duplicated data, maintains consistent records, and ensures that every user or product has distinct identifying information.

NOT NULL Constraint in SQL (Definition, Example & Use Cases)

The SQL NOT NULL constraint ensures that a column cannot have a NULL value. It enforces mandatory fields, making sure every record has valid and complete data. Commonly used for usernames, product names, and order statuses.

🔑 Key Highlights of NOT NULL:

  • Mandatory Data: Ensures no field is left empty.
  • Data Integrity: Prevents missing or incomplete data entries.
  • Use Cases: Ideal for names, statuses, and other required values.

✅ Example: NOT NULL Constraint in SQL 

CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    ProductName VARCHAR(255) NOT NULL,
    OrderStatus VARCHAR(100) NOT NULL
);

Here, both ProductName and OrderStatus are NOT NULL. This ensures every order has complete, valid information.

CHECK Constraint in SQL (Definition, Example & Use Cases)

The SQL CHECK constraint restricts values in a column to meet specific conditions. It enforces business rules like ensuring salaries are above minimum wage, prices are positive, or age is within a valid range.

🔎 Key Highlights of CHECK:

  • Validation: Ensures only valid data values are inserted.
  • Custom Rules: Can enforce logical conditions (>, <, AND, OR).
  • Use Cases: Salary validation, product price restrictions, minimum quantity checks.

✅ Example: CHECK Constraint in SQL 

CREATE TABLE Products (
    ProductID INT PRIMARY KEY,
    ProductName VARCHAR(255) NOT NULL,
    Price DECIMAL(10, 2) CHECK (Price > 0)
);

Here, the Price column must always be greater than 0, preventing invalid or negative values from being entered.

🚀 Why NOT NULL and CHECK Constraints Are Essential

NOT NULL guarantees required fields are always filled, while CHECK enforces valid values based on business rules. Together, they protect your SQL database from incomplete or invalid data.

CHECK Constraint in SQL (Definition, Example & Use Cases)

The CHECK constraint in SQL ensures that values stored in a column (or across columns) satisfy a rule. It’s ideal for enforcing business logic like age limits, positive prices, or valid ranges.

🔎 Key Points

  • Data Validation: Accepts only values that meet specified criteria.
  • Business Rules: Enforce policies such as minimum age, positive quantity, or valid ranges.
  • Flexible Logic: Supports conditions with AND, OR, and comparison operators.

✅ Example: CHECK Constraint in SQL

CREATE TABLE Employees (
    EmployeeID INT PRIMARY KEY,
    Name       VARCHAR(100),
    Age        INT CHECK (Age > 18),
    Position   VARCHAR(100)
);

Here, Age must be greater than 18. Any row that violates this rule is rejected by the database engine.

Why the CHECK Constraint Matters

By validating values at the database layer, the CHECK constraint prevents invalid or inconsistent data, strengthens data integrity, and keeps application logic clean and reliable.

DEFAULT Constraint in SQL (Definition & Example)

The DEFAULT constraint in SQL automatically assigns a predefined value to a column when no value is provided during insertion. This ensures that important fields are never left blank and your database maintains consistency.

🔑 Key Points of the DEFAULT Constraint

  • Automatic Assignment: Fills in a default value if none is provided during INSERT.
  • Error Prevention: Reduces the chances of incomplete or missing data.
  • Common Use Cases: Useful for status, timestamps, and default numeric values.

✅ Example of DEFAULT Constraint in SQL 

CREATE TABLE Users (
    UserID INT PRIMARY KEY,
    UserName VARCHAR(100),
    AccountStatus VARCHAR(50) DEFAULT 'Active'
);

Here, if AccountStatus is not specified while inserting a record, SQL automatically assigns it the default value 'Active'.

Why the DEFAULT Constraint Matters

The DEFAULT constraint guarantees consistency and prevents empty values in crucial fields. By setting meaningful defaults, you simplify data entry and maintain reliable, high-quality databases.

SQL Constraints: A Complete Guide (With Examples)

Learn what constraints in SQL are, why they matter, and how to apply each one to build robust, error-free databases. Includes ready-to-use code samples for PRIMARY KEY, FOREIGN KEY, UNIQUE, NOT NULL, CHECK, and DEFAULT.

Primary Key Constraint

A PRIMARY KEY uniquely identifies each row and disallows NULL. It’s the backbone of relational design and speeds up lookups and joins.

  • Uniqueness: No two rows share the same key value.
  • NOT NULL: The key column(s) cannot be NULL.
  • Composite Keys: May span multiple columns when a single column isn’t enough.
CREATE TABLE Customers (
    CustomerID INT PRIMARY KEY,
    Name       VARCHAR(100),
    Email      VARCHAR(100)
);

Foreign Key Constraint (Referential Integrity)

A FOREIGN KEY enforces relationships by referencing a parent table’s primary key, preventing orphaned records.

  • Integrity: Values must exist in the parent table.
  • Cascades: Use ON DELETE/UPDATE CASCADE to auto-sync changes.
  • Multiple FKs: A table can reference multiple parents.
CREATE TABLE Orders (
    OrderID    INT PRIMARY KEY,
    CustomerID INT,
    FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);

Unique Constraint

The UNIQUE constraint ensures column values are distinct. Perfect for emails, usernames, product codes.

  • No Duplicates: Enforced at the database layer.
  • Multiple UNIQUEs: A table can have several UNIQUE columns.
  • NULLs: Typically allows a single NULL per column (varies by DB engine).
CREATE TABLE Users (
    UserID   INT PRIMARY KEY,
    Username VARCHAR(100) UNIQUE,
    Email    VARCHAR(100) UNIQUE
);

NOT NULL Constraint

NOT NULL makes a column mandatory—no missing values. Great for essential fields like names or statuses.

  • Completeness: Prevents empty required fields.
  • Quality: Improves reliability of downstream analytics.
CREATE TABLE Orders (
    OrderID      INT PRIMARY KEY,
    ProductName  VARCHAR(255) NOT NULL,
    OrderStatus  VARCHAR(100) NOT NULL
);

CHECK Constraint

CHECK validates values against a condition—ideal for enforcing business rules and valid ranges.

  • Validation: Ensures only acceptable values are stored.
  • Flexible Logic: Supports comparisons and AND/OR conditions.
CREATE TABLE Employees (
    EmployeeID INT PRIMARY KEY,
    Name       VARCHAR(100),
    Age        INT CHECK (Age > 18),
    Position   VARCHAR(100)
);

DEFAULT Constraint

DEFAULT assigns a value automatically when none is provided, keeping data consistent.

  • Fewer Errors: Prevents unintended blanks.
  • Common Uses: Status, timestamps, flags, counters.
CREATE TABLE Users (
    UserID        INT PRIMARY KEY,
    UserName      VARCHAR(100),
    AccountStatus VARCHAR(50) DEFAULT 'Active'
);

Best Practices

  • Name constraints explicitly (e.g., CONSTRAINT uq_users_email) for clarity.
  • Validate at the database layer (NOT NULL, CHECK) rather than only in app code.
  • Index wisely: UNIQUE creates an index; avoid overlapping redundant indexes.
  • Use cascades carefully to prevent accidental mass deletes/updates.
  • Document business rules that your CHECK/DEFAULT constraints encode.

Common Errors & How to Fix

Violation of PRIMARY/UNIQUE: Remove duplicates or change the key value.
FOREIGN KEY constraint fails: Insert parent row first, or use valid IDs; consider cascades if appropriate.
CHECK violated: Ensure values meet the rule (e.g., positive price, minimum age).
Cannot insert NULL: Provide a value or adjust column to allow NULL / add DEFAULT if logical.

FAQ: SQL Constraints

Q1: What is a constraint in SQL?
A rule enforced by the database to maintain data integrity (e.g., PRIMARY KEY, FOREIGN KEY, UNIQUE, NOT NULL, CHECK, DEFAULT).

Q2: Difference between PRIMARY KEY and UNIQUE?
Both enforce uniqueness, but PRIMARY KEY also implies NOT NULL and identifies rows. A table has one PRIMARY KEY but can have many UNIQUE constraints.

Q3: Can a column with UNIQUE be NULL?
Usually yes—often one NULL per column (implementation-specific).

Q4: When should I use CHECK?
When business rules (ranges, thresholds, logical conditions) must be guaranteed by the database.

Q5: What are the types of constraints in SQL?
The main types of SQL constraints are PRIMARY KEY, FOREIGN KEY, UNIQUE, NOT NULL, CHECK, and DEFAULT. These ensure valid, consistent, and reliable data.

Q6: Can you give an example of SQL constraints?
Example:
CREATE TABLE Users ( UserID INT PRIMARY KEY, Email VARCHAR(100) UNIQUE, Age INT CHECK(Age > 18) );
This combines PRIMARY KEY, UNIQUE, and CHECK constraints in one table.

Q7: What are database constraints?
Database constraints are rules that enforce data accuracy and consistency. They prevent duplicates, invalid values, and maintain valid relationships between tables.

Q8: Why are constraints important in a database?
They protect data integrity, stop duplicate/missing values, enforce valid links between tables, and improve query performance.

Q9: What is the difference between data constraints and integrity constraints?
Data constraints (NOT NULL, UNIQUE, CHECK) apply at the column level. Integrity constraints (PRIMARY KEY, FOREIGN KEY) maintain consistency across tables.

Q10: What are CHECK and DEFAULT constraints in SQL?
CHECK enforces conditions (e.g., salary > 0). DEFAULT inserts a predefined value when none is provided (e.g., status = ‘Active’).

SQL Constraints — Quick Reference

Constraint Ensures Typical Use Example (DDL)
PRIMARY KEY Unique row identity; no NULL IDs like CustomerID, OrderID 
CREATE TABLE T(
  id INT PRIMARY KEY
);
FOREIGN KEY Referential integrity to parent table Links Orders→Customers 
FOREIGN KEY (customer_id)
  REFERENCES Customers(id)
UNIQUE No duplicate values Email, Username, SKU 
email VARCHAR(255) UNIQUE
NOT NULL Value required (no NULL) Names, statuses, required fields 
name VARCHAR(100) NOT NULL
CHECK Values meet a condition Age > 18, Price > 0 
age INT CHECK (age > 18)
DEFAULT Auto-fill when not provided Status, timestamps, flags 
status VARCHAR(20) DEFAULT 'Active'

🧠 Test Your Knowledge: SQL Constraints Quiz

Answer these 10 questions to check how well you understand SQL constraints. Your score will be shown at the end!

🎥 Learn SQL Constraints in Action

Watch this detailed video to understand SQL Constraints with real-world examples. It will help you connect the theory with practical usage in databases.

🚀 Call to Action: Take Your SQL Skills to the Next Level

✨ Explore Additional SQL Tutorials and Real-World Practice

Now that you’ve mastered SQL Constraints, it’s time to expand your knowledge and practice with more advanced SQL topics. The best way to improve is through hands-on experience. Explore the tutorials below and practice on real-world datasets to level up your SQL expertise:

These resources will help you understand complex SQL concepts with real-world examples. Keep practicing and refining your skills — hands-on experience is the fastest way to become an SQL expert.