Check the below input data and expected output for updating the table using SELECT JOIN statement.

Create sample tables with data:

CREATE TABLE tbl_abc (ID INT, Name VARCHAR(10))
CREATE TABLE tbl_xyz (ID INT, Name VARCHAR(10))
GO

INSERT INTO tbl_abc VALUES 
(1,'a'),(2,'b'),(3,'c')
INSERT INTO tbl_xyz VALUES
(1,'x'),(2,'y'),(3,'z')
GO

UPDATE Statement:

UPDATE tbl_abc
	SET tbl_abc.Name = tbl_xyz.Name
FROM tbl_abc 
INNER JOIN tbl_xyz 
	ON tbl_abc.ID = tbl_xyz.ID
GO

Result:

SELECT *FROM tbl_abc
GO

ID          Name
----------- ----------
1           x
2           y
3           z

Please try the different solution for this puzzle and share it via comment...

What is HOT UPDATE (Heap Only Tuple) and How It helps to increase the performance of UPDATE Query?
In this post, I am going to explain the answer of this question.

This is one of the internal of PostgreSQL, but I am sure that most of you guys don’t know about PostgreSQL HOT.

PostgreSQL requires HOT because of MVCC architecture.
Please read below articles, before start to knowing about the HOT.

What is MVCC?

What is Fillfactor in PostgreSQL?

What is Vacuum in PostgreSQL?

In the MVCC architecture, When we update any record, internally MVCC architecture inserts a new record with new values and marks old record as deleted or discarded.
When we vacuum, we can clean that deleted records and utilize that space.

What is HOT (Hot Only Tuple)?

Now imagine that, we have total 500 data pages and we are updating record of page number 3, but unfortunately new record insert in page number 500.

It looks like very big internal fragmentation because of MVCC architecture.
But actually this is not happening.

PostgreSQL has a concept of HOT, With a HOT dead tuple space can be automatically reclaimed at the time of INSERT or UPDATE if no changes are made to indexed columns. This allows for more consistent performance.

HOT means, creating a new update tuple if possible on the same page as the old tuple, and maintaining a chain of updated tuples linking a new version to the old tuple.

HOT updates can only reuse dead tuples from previous transactions directly, not from the same or concurrent ones.
If you have big updates, changing large portions of the table at once, you might want to split them up in a couple of chunks.

HOT updates only work when the changed columns are not involved in indexes in any way because the indexes pointing the the old tuples need to point to the new version of it as of transaction id.

You might be blocking HOT updates with indexes on updated columns. If those are expendable, you might get better overall performance without them.

Let’s understand PostgreSQL HOT practically.

Create a table with Sample data:

CREATE TABLE tbl_Employees
(
	EmpID INT
	,EmpName CHARACTER VARYING 	
	,EmpDepartment CHARACTER VARYING
	,EmpSalary INT
);
 
INSERT INTO tbl_Employees
VALUES 
(1,'Anvesh','Database',90000)
,(2,'Jenny','JAVA',65000)
,(3,'Martin','PHP',85000)
,(4,'Roy','PHP',94000)
,(5,'Eric','PHP',70000)
,(6,'Rajesh','Animation',50000)
,(7,'Mahi','Database',40000)
,(8,'Sofia','JAVA',60000);

Delete one record:

DELETE FROM tbl_Employees WHERE EmpID = 7;

Insert one New Record:

INSERT INTO tbl_Employees
VALUES 
(7,'Junik','Database',10000);

Please check If any HOT Update or not on table:

SELECT pg_stat_get_tuples_hot_updated('tbl_employees'::regclass::oid);
/*
Result:
pg_stat_get_tuples_hot_updated
------------------------------
0
*/

Please update the statestic of that table:

ANALYZE tbl_Employees;

Now execute one more update command:

UPDATE tbl_Employees SET EmpName = 'Robort' WHERE EmpID=7;

Please check If any HOT Update or not on table:

SELECT pg_stat_get_tuples_hot_updated('tbl_employees'::regclass::oid);
/*
Result:
pg_stat_get_tuples_hot_updated
------------------------------
1
*/

Again, do more update:

UPDATE tbl_Employees SET EmpName = 'Manish' WHERE EmpID=8;
UPDATE tbl_Employees SET EmpName = 'Cerlin' WHERE EmpID=4;

Please check If any change in number of HOT Update of a table:

SELECT pg_stat_get_tuples_hot_updated('tbl_employees'::regclass::oid);
/*
Result:
pg_stat_get_tuples_hot_updated
------------------------------
3
*/

Now Apply, Index on EmpName Column:

CREATE INDEX idx_tbl_employees_empname 
ON tbl_employees USING BTREE (EmpName);

After Index, execute few more update:

UPDATE tbl_Employees SET EmpName = 'Kulin' WHERE EmpID=3;
UPDATE tbl_Employees SET EmpName = 'Priya' WHERE EmpID=5;

After Index, Please check If any change in number of HOT Update of a table:
The result is same because If column has an Index, HOT Update does not work.

SELECT pg_stat_get_tuples_hot_updated('tbl_employees'::regclass::oid);
/*
Result:
pg_stat_get_tuples_hot_updated
------------------------------
3
*/

You can also check number of HOT update of current transaction:

SELECT pg_stat_get_xact_tuples_hot_updated('tbl_employees'::regclass::oid);

In this post, I am going to share a demonstration on how to update the table data using a Subquery in the PostgreSQL.

This is a fundamental help, but I found that most of the beginners always try to find the script for Subquery or Joins.

Below is a small demonstration:

Create two sample tables for Employee:

CREATE TABLE tbl_EmployeeDetails 
(
	EmpID SERIAL PRIMARY KEY
	,EmpName CHARACTER VARYING(50)
	,TotalPerformanceCount INTEGER DEFAULT 0
);

CREATE TABLE tbl_EmployeePerformanceCounter
(
	PerformanceCounterID SERIAL PRIMARY KEY
	,EmpID INTEGER
	,PerformanceCounter INTEGER
	,RecordDateTime TIMESTAMP WITHOUT TIME ZONE
	,CONSTRAINT fk_tbl_EmployeePerformanceCounter_EmpID 
         FOREIGN KEY (EmpID) REFERENCES tbl_EmployeeDetails(EmpID)
);

Insert sample data into both the tables:

INSERT INTO tbl_EmployeeDetails (EmpName)
VALUES ('Anvesh'),('Neevan'),('Martin'),('Roy'),('Jenny');

INSERT INTO tbl_EmployeePerformanceCounter
(EmpID,PerformanceCounter,RecordDateTime)
VALUES
(1,300,'20150101')
,(1,100,'20150201')
,(1,200,'20150301')
,(2,140,'20150101')
,(2,320,'20150201')
,(3,120,'20150101')
,(3,150,'20150201')
,(4,150,'20150101')
,(4,200,'20150201')
,(4,100,'20150301');

Update the count of the employee performance counter using Subquery:

UPDATE tbl_EmployeeDetails
SET TotalPerformanceCount=T.TotalCount   
FROM (SELECT EmpID,SUM(PerformanceCounter) AS TotalCount
      FROM tbl_EmployeePerformanceCounter GROUP BY EmpID) AS T
WHERE tbl_EmployeeDetails.EmpID=T.EmpID;

The Result:

SELECT *FROM tbl_EmployeeDetails ORDER BY 1;