---
# System prepended metadata

title: Constraints in Postgresql (Advanced Topics)

---

# Constraints in Postgresql (Advanced Topics)

## How to add jointly unique constraints?

To add jointly unique constraints in PostgreSQL, you can specify multiple columns in the unique constraint definition. This ensures that the combination of values across those columns is unique. Here's an example of how to add jointly unique constraints:

```sql
CREATE TABLE my_table (
  id SERIAL PRIMARY KEY,
  first_name VARCHAR(255),
  last_name VARCHAR(255),
  email VARCHAR(255),
  ...
);

-- Add jointly unique constraint on first_name and last_name
ALTER TABLE my_table ADD CONSTRAINT uq_name UNIQUE (first_name, last_name);
```

In this example, a jointly unique constraint named `uq_name` is added to the `my_table` table, covering the `first_name` and `last_name` columns. This constraint ensures that no two rows can have the same combination of values for `first_name` and `last_name`.

You can also define jointly unique constraints during table creation. Here's an example:

```sql
CREATE TABLE my_table (
  id SERIAL PRIMARY KEY,
  first_name VARCHAR(255),
  last_name VARCHAR(255),
  email VARCHAR(255),
  ...
  CONSTRAINT uq_name UNIQUE (first_name, last_name)
);
```

In this case, the jointly unique constraint `uq_name` is defined inline with the table creation statement, covering the `first_name` and `last_name` columns.

Jointly unique constraints are useful when you want to ensure the uniqueness of combinations of values across multiple columns. They allow you to enforce business rules or data integrity requirements that involve multiple fields in your database schema.

## Altering Constraints

To alter check constraints and unique constraints in PostgreSQL, you can use the `ALTER TABLE` statement along with the `ADD`, `DROP`, or `ALTER` clauses. Here are the steps for altering check constraints and unique constraints:

### 1. Altering Check Constraints:
   To alter a check constraint, you need to drop and re-create it with the desired changes. Follow these steps:

   a. Find the name of the check constraint:
      You can query the `pg_constraint` system catalog table to retrieve the name of the check constraint associated with the table. Here's an example:

  ```sql
  SELECT conname
  FROM pg_constraint
  WHERE conrelid like 'user_table_%';
```

   b. Drop the existing check constraint:
      Once you have the name of the check constraint, you can drop it using the `ALTER TABLE` statement with the `DROP CONSTRAINT` clause. Here's an example:

  ```sql
  ALTER TABLE your_table
  DROP CONSTRAINT your_constraint_name;
  ```

   c. Add the altered check constraint:
      After dropping the existing check constraint, you can add the altered check constraint using the `ALTER TABLE` statement with the `ADD CONSTRAINT` clause. Here's an example:

  ```sql
  ALTER TABLE your_table
  ADD CONSTRAINT your_new_constraint_name CHECK (new_condition);
  ```

   Replace `your_table` with the name of your table, `your_constraint_name` with the name of the existing check constraint, and `your_new_constraint_name` with the desired name for the altered check constraint. Also, modify `new_condition` with the updated condition for the check constraint.

### 2. Altering Unique Constraints:
   To alter a unique constraint, you can use the `ALTER TABLE` statement with the `ALTER CONSTRAINT` clause. Follow these steps:

   a. Find the name of the unique constraint:
      Similar to check constraints, you can query the `pg_constraint` system catalog table to retrieve the name of the unique constraint associated with the table. Here's an example:

  ```sql
  SELECT conname
  FROM pg_constraint
  WHERE conrelid like 'your_table_%'::regclass;
  ```

   b. Alter the unique constraint:
      Once you have the name of the unique constraint, you can alter it using the `ALTER TABLE` statement with the `ALTER CONSTRAINT` clause. Here's an example:

  ```sql
  ALTER TABLE your_table
  ALTER CONSTRAINT your_constraint_name [RENAME TO your_new_constraint_name];
  ```

  In this example, you can optionally use the `RENAME TO` clause to change the name of the unique constraint. If you don't want to change the name, you can omit the `RENAME TO` clause.

Replace `your_table` with the name of your table, `your_constraint_name` with the name of the existing unique constraint, and `your_new_constraint_name` with the desired new name for the unique constraint.

Remember to adjust the table and constraint names according to your specific scenario. By following these steps, you can alter check constraints and unique constraints in PostgreSQL.

## Drop Constraints

To drop constraints in PostgreSQL, you can use the `ALTER TABLE` statement with the `DROP CONSTRAINT` clause. Here's the general syntax for dropping constraints:

```sql
ALTER TABLE table_name
DROP CONSTRAINT constraint_name;
```

You need to replace `table_name` with the name of the table that contains the constraint and `constraint_name` with the name of the constraint you want to drop.