RETURNING in PostgreSQL
The RETURNING clause in PostgreSQL is a powerful feature that allows developers to retrieve data directly after executing SQL operations such as INSERT, UPDATE, or DELETE. This feature eliminates the need for multiple queries to fetch modified data, resulting in optimized performance, cleaner code, and more efficient database interactions.
In this article, we will explore how the RETURNING clause works in PostgreSQL with practical examples and outputs. We will also discuss how to implement this clause in real-world scenarios involving auto-incremented primary keys and data validation post-update or deletion, ensuring performance improvements and seamless coding practices.
What is RETURNING in PostgreSQL?
The RETURNING clause lets us instantly get data from a modified record right after an INSERT, UPDATE, or DELETE operations. Instead of running separate queries to retrieve the affected rows, RETURNING helps retrieve the data in the same query. This feature is especially useful for obtaining auto-generated IDs during INSERT, UPDATE and DELETE operations.
Syntax:
1. INSERT Statement with RETURNING
INSERT INTO table_name (column1, column2, ...)
VALUES (value1, value2, ...)
RETURNING column1, column2, ...;
2. UPDATE Statement with RETURNING
UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition
RETURNING column1, column2, ...;
3. DELETE Statement with RETURNING
DELETE FROM table_name
WHERE condition
RETURNING column1, column2, ...;
Examples of RETURNING Clause in PostgreSQL
Example 1: Using RETURNING with INSERT
Let’s consider a scenario where we have a table named employees. We want to insert a new employee named "Alice" into this table and retrieve her newly assigned id right after the insertion. The INSERT operation will generate a new employee ID, which we can retrieve using the RETURNING clause. Here’s how we can accomplish this:
Query:
INSERT INTO employees (name, salary)
VALUES ('Alice', 60000)
RETURNING id, name;
Output
id | name |
|---|---|
1 | Alice |
Explanation:
In this example, we inserted Alice into the employees table and received his id immediately. This feature is very useful with auto-incremented primary keys, as it help us to obtain the newly created record's identifier without running an additional query.
Example 2: Using RETURNING with UPDATE
Next, we will see how to use the RETURNING clause with an UPDATE statement. Suppose we need to update Alice's salary to 65,000 and retrieve her id, name, and the updated salary in the same query. This confirms the success of the update and eliminates the need for a second query, thus improving code efficiency.
Query:
UPDATE employees
SET salary = 65000
WHERE name = 'Alice'
RETURNING id, name, salary;
Output
id | name | salary |
|---|---|---|
1 | Alice | 65000 |
Explanation:
Here, we updated Alice's salary to 65000 and used the RETURNING clause to fetch her id, name, and the new salary in a single operation. This not only confirms the success of the update but also increases our code's efficiency by reducing the number of database calls.
Example 3: Using RETURNING with DELETE
Let's say Alice decides to leave the company, and we need to delete her record from the employees table. We want to confirm which record was deleted by retrieving her id and name after the deletion.
Query:
DELETE FROM employees
WHERE name = 'Alice'
RETURNING id, name;
Output
id | name |
|---|---|
1 | Alice |
Explanation:
In this example, we deleted Alice's record from the employees table and received her id and name as output. This way, we can confirm which record was deleted and work with that data if needed.
Why Use the RETURNING Clause?
The RETURNING clause in PostgreSQL offers several advantages:
- Reduces Multiple Queries: Instead of executing separate queries to retrieve updated or inserted data, RETURNING fetches the required information in the same operation.
- Optimizes Performance: By minimizing the number of database calls, this clause helps improve application performance.
- Simplifies Code: Code becomes cleaner and more readable since you don’t need extra logic to fetch modified records.
- Works with Auto-increment Keys: It is especially useful when auto-generated IDs are needed immediately after an INSERT operation.
Conclusion
The RETURNING clause in PostgreSQL is a very useful tool that simplifies data retrieval immediately after INSERT, UPDATE, or DELETE operations. By integrating this feature into our SQL statements, we can efficiently manage our processes, minimize the need for additional queries, and increase overall performance.
By using RETURNING with auto-incremented primary keys, we can instantly capture new record IDs. Additionally, the ability to validate updates and deletions in real-time ensures data accuracy and reliability. Incorporating this feature into your PostgreSQL operations will undoubtedly make your applications more efficient, faster, and easier to maintain.
