---
# System prepended metadata

title: Constraints in PostgreSQL

---

# Constraints in PostgreSQL

In database management systems like PostgreSQL, creating constraints between tables is a way to enforce the relationships and integrity of the data stored in those tables. These constraints ensure that certain conditions are met, and they typically involve the use of foreign keys. Let's explore the concept of constraints and provide a few examples.

1. Primary Key Constraint:
A primary key constraint ensures that each row in a table has a unique identifier. It is commonly used to uniquely identify records in a table. In PostgreSQL, the primary key constraint is implemented using the `PRIMARY KEY` keyword. Here's an example:

```sql
CREATE TABLE Students (
  student_id SERIAL PRIMARY KEY,
  name VARCHAR(100),
  age INTEGER
);
```

In this example, the `student_id` column is defined as the primary key. It guarantees that each student record will have a unique identifier.

2. Foreign Key Constraint:
A foreign key constraint establishes a link between two tables, enforcing referential integrity. It ensures that values in one table's column (referencing table) correspond to values in another table's column (referenced table). In PostgreSQL, the foreign key constraint is defined using the `FOREIGN KEY` keyword. Here's an example:

```sql
CREATE TABLE Orders (
  order_id SERIAL PRIMARY KEY,
  order_date DATE,
  customer_id INTEGER REFERENCES Customers(customer_id)
);
```

In this example, the `customer_id` column in the `Orders` table references the `customer_id` column in the `Customers` table. This constraint ensures that only valid customer IDs from the `Customers` table can be inserted into the `Orders` table.

3. Unique Constraint:
A unique constraint ensures that the values in a column or a group of columns are unique across the table. It prevents duplicate entries. In PostgreSQL, the unique constraint is defined using the `UNIQUE` keyword. Here's an example:

```sql
CREATE TABLE Employees (
  employee_id SERIAL PRIMARY KEY,
  employee_name VARCHAR(100),
  email VARCHAR(100) UNIQUE
);
```

In this example, the `email` column is defined as unique. It guarantees that each employee has a unique email address.

4. Check Constraint:
A check constraint ensures that the values in a column meet specific conditions or rules. It allows you to restrict the range of valid values. In PostgreSQL, the check constraint is defined using the `CHECK` keyword. Here's an example:

```sql
CREATE TABLE Products (
  product_id SERIAL PRIMARY KEY,
  product_name VARCHAR(100),
  price DECIMAL(10, 2),
  quantity INTEGER,
  CHECK (price >= 0 AND quantity >= 0)
);
```

In this example, the `CHECK` constraint ensures that both the price and quantity columns have non-negative values.

These are just a few examples of constraints that can be created in PostgreSQL to maintain data integrity and enforce relationships between tables. Constraints play a crucial role in ensuring the accuracy, consistency, and reliability of your database.