I have already written a similar article to delete duplicate records in SQL Server and MySQL.
Here, You can also access that articles.

Delete all duplicate rows in MySQL

Delete all duplicates rows except one in SQL Server

Recently, I got one request for one script to delete duplicate records in PostgreSQL.
Most of the Database Developers have such a requirement to delete duplicate records from the Database.

Like SQL Server, ROW_NUMBER() PARTITION BY is also available in PostgreSQL.
I have prepared this script, using simple inner query with the use of ROW_NUMBER() PARTITION BY clause.

Create a sample table:

CREATE TABLE tbl_RemoveDuplicate
(	
	ID INTEGER PRIMARY KEY
	,Name VARCHAR(150)
);

Insert few duplicate records:

INSERT INTO tbl_RemoveDuplicate VALUES
(1,'ABC'),(2,'XYZ')
,(3,'XYZ'),(4,'RFQ')
,(5,'PQR'),(6,'EFG')
,(7,'EFG'),(8,'ABC');

Except one, Delete all duplicate records:

DELETE FROM tbl_RemoveDuplicate
WHERE ID IN 
(SELECT ID
FROM (SELECT id,
	     ROW_NUMBER() OVER (partition BY Name ORDER BY ID) AS RowNumber
     FROM tbl_RemoveDuplicate) AS T
WHERE T.RowNumber > 1);

Check the result:

SELECT *FROM tbl_RemoveDuplicate;
 id | name
----+------
  1 | ABC
  2 | XYZ
  4 | RFQ
  5 | PQR
  6 | EFG
(5 rows)

In this post, I am sharing an example of applying Full Text Search on PostgreSQL Table with Index.

Here, I am using tsvector for full text search which is document type and uses match operator like @@.

PostgreSQL: Example of Trigram Index for Full Text Search using pg_trgm Extension

Below is an example:

Create a sample table with data:

CREATE TABLE tbl_Textdata
(id int, txt character varying);

INSERT INTO tbl_Textdata VALUES
(1,'I am DBA'),(2,'database research & development'),(3,'think for data only')
,(4,'data is important'),(5,'data is a future'),(6,'I am data owner');

Do Full Text Searching:

SELECT txt
FROM tbl_Textdata
WHERE to_tsvector(txt) @@ to_tsquery('data');

Result:

txt
--------------------------
'think for data only'
'data is important'
'data is a future'
'I am data owner'

Apply an Index on require Text Pattern:

CREATE INDEX tbl_Textdata_txt_idx ON tbl_Textdata USING GIN (to_tsvector('english',txt));

Check the execution plan:

explain analyze
SELECT txt
FROM tbl_Textdata
WHERE to_tsvector(txt) @@ to_tsquery('data');

'Seq Scan on tbl_textdata  (cost=0.00..4.07 rows=1 width=32) (actual time=0.043..0.058 rows=4 loops=1)'
'  Filter: (to_tsvector((txt)::text) @@ to_tsquery('data'::text))'
'  Rows Removed by Filter: 2'
'Planning time: 5.494 ms'
'Execution time: 0.083 ms'

THE SERIALIZABLE Isolation level is one kind of extended version of the REPEATABLE READ Isolation level.
Now with the SERIALIZABLE Isolation level, you cannot modify the data while another transaction is reading the same data.

For SELECT-only transactions, use the SERIALIZABLE isolation level when you do not want to see the other transaction commits during your transaction.

For UPDATE and DELETE transactions, SERIALIZABLE isolation prevents concurrent modification of the same data row; it should therefore be used with caution.

Create a table with few sample records:

CREATE TABLE tbl_Employee
(
	EmpID INTEGER
	,EmpName VARCHAR(50)
);
 
INSERT INTO tbl_Employee
VALUES 
(1,'Anvesh'),(2,'Neevan')
,(3,'Roy'),(4,'Martin');

Execute in this current session. e.g. Session – A:

BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;  

UPDATE tbl_Employee SET EmpName ='Varlin' WHERE EmpID=4;

SELECT *FROM tbl_Employee;

 empid | empname
-------+---------
     1 | Anvesh
     2 | Neevan
     3 | Roy
     4 | Varlin

Execute in anohter session, e.g. Session – B:

UPDATE tbl_Employee SET EmpName ='Loother' WHERE EmpID=3;

SELECT *FROM tbl_Employee;

 empid | empname
-------+---------
     1 | Anvesh
     2 | Neevan
     4 | Varlin
     3 | Loother

Execute in anohter session, e.g. Session – C:

INSERT INTO tbl_Employee
VALUES (5,'Mahi');

SELECT *FROM tbl_Employee;

 empid | empname
-------+---------
     1 | Anvesh
     2 | Neevan
     4 | Martin
     3 | Loother
     5 | Mahi

Execute COMMIT on first Current Session – A:

--Nothing happen to this Query and Data is as it is. 

SELECT *FROM tbl_Employee; 

 empid | empname
-------+---------
     1 | Anvesh
     2 | Neevan
     3 | Roy
     4 | Varlin

-- Now Execute COMMIT:
COMMIT TRANSACTION;

Important notice: Never try in your Production or any other Live server. This post is only ad-hoc and test server.

Data Durability is an important part of Database ACID property. In this post, I am sharing few parameters which we can disable for achieving good performance of PostgreSQL Database Server.

We should disable Non-Durable parameters on our test server where we need only POC related work, and if your system doesn’t require any guarantee of data, then you can disable.

Why disabling the Non-Durable parameters?

PostgreSQL guarantees the full durability of data even if the server crashes or loses power.
But committing every single transaction in datafile and log file is also extra overhead on the database server.
So simple, just disable that parameter for achieving good performance.

ACID Properties in Database System (Atomicity, Consistency, Isolation, Durability)

Below are parameters:

fsync: Turn off – no need to flush data to disk

synchronous_commit: Turn off – not need to write to disk on every commit

full_page_writes: Turn off – no need to guard against partial page writes

max_wal_size: Increase – reduces the frequency of checkpoints

checkpoint_timeout: Increase – reduces the frequency of checkpoints

In this post, I am sharing the use of “unaccent” extension of PostgreSQL.

Use unaccent, for removing diacritic signs from the string and convert into the valid character as per the specified collation.

When we are importing data from different types of datasets, we can find diacritic signs in the data. We can use unaccent() for removing those signs.

Check below demonstration:

Create an extension:

CREATE EXTENSION unaccent;

Use unaccent():

SELECT unaccent('ô ã À Æ ß Ä');

Result:

unaccent
------------------
'o a A AE ss A'

In this post, I am sharing few mathematical operators for finding factorial, absolute and negation value in PostgreSQL.

I was reading the official the official page of PostgreSQL and found few interesting operators which we can use for the mathematical purpose.

Check below examples:

! operator for factorial:

SELECT 8 ! AS "8 factorial";

8 factorial
------------
'40320'

@ operator for absolute:

SELECT @ '-8.8' AS "absolute value";

absolute values
------------
'40320'

~ operator for negation:

SELECT ~ CAST('16' AS int8) AS "negation value";

negation value
---------------
'-17'

Beginners are always searching for sample database so, in this post, I am sharing an official download link to a MySQL Sakila sample database which we can use for our testing purpose.

Sakila sample database is a DVD rental database. The database contains sample tables, views, SPs, Functions and Triggers.

The MySQL beginner can install this database and can start the practice with it.
PostgreSQL beginner can also use this database.

Please check the official page here, and you can see all require documentation like, database structure, installation steps.

In this post, I am sharing a script for transforming normal DB user to Super User in PostgreSQL.

The Super User is the admin user and it has all kind of access to PostgreSQL Server. We can create multiple superusers in PostgreSQL.

I need this kind of handy commands/scripts because when any new dba join the team, giving basic permission of database and later the same user requires superuser permission.

Convert a user into Super User:

ALTER USER user_name WITH SUPERUSER;

Revoke Super User Permission:

ALTER USER user_name WITH NOSUPERUSER;

As per the en.wikibooks.org:

Bash is a “Unix shell”: a command-line interface for interacting with the operating system. It has the ability to run an entire script of commands, known as a “Bash shell script”.

I recently started to create UNIX / LINUX Bash Shell script for enhancing my PostgreSQL DBA Work. You can create a Bash shell script and can connect PostgreSQL using psql.

In this post, I am sharing a sample bash shell script to execute psql commands.

Open a new file in vi editor:

[root@dbrnd anvesh]$ vi helloworld.bash

Press [i] key to get an insert prompt:

Copy below sample Bash Shell Script and Paste into vi editor:

#!/bin/bash

###################################################
# First Bash Shell script to execute psql command 
###################################################

#Set the value of variable
database="database_name"

#Execute few psql commands: 
#Note: you can also add -h hostname -U username in the below commands. 

psql -d $database -c "CREATE TABLE public.tbl_students(rno integer, name character varying)"
psql -d $database -c "INSERT INTO public.tbl_students VALUES (1,'Anvesh'),(2,'Neevan'),(3,'Roy'),(4,'Martin'),(5,'Jenny')"
psql -d $database -c "SELECT *FROM public.tbl_students"

#Assign table count to variable
TableCount=$(psql -d $database -t -c "select count(1) from public.tbl_students")

#Print the value of variable
echo "Total table records count....:"$TableCount

Press [Esc] key to get a command prompt and execute below command:
To save and exit vi editor.

:wq

Give permission to the file:

[root@dbrnd anvesh]$ chmod +x helloworld.bash

Execute this file:

[root@dbrnd anvesh]$ ./helloworld.bash

You can find below result:

rno |  name
-----+--------
   1 | Anvesh
   5 | Jenny
   2 | Neevan
   3 | Roy
   4 | Martin
(5 rows)

Total table records count....: 5

In this post, I am sharing an important tip for PostgreSQL DBAs.

I recently started work with a new PostgreSQL Client. They have total 326 databases in their PostgreSQL Server. They are taking full backup for all the database and this process is taking around total 7 hours.

When I looked this, my first step was to find database statistics. I have found 25% of databases are not being updated frequently.

I added one additional check in a backup process like “skip the backup for those databases which have not been changed for any operations (DDL or DML operation)”.
After this check, the backup process is taking around total 5 hours to complete the job.

Using pg_stat_database, you can check the stats of database and can compare the value for tuple columns with the old value. If you found any changes, your database has been changed.

If any of your DBA reset the PostgreSQL database statistics using something like pg_stat_reset, you have to add some more extra logic to understand the difference between statistics.

Below is a sample demonstration:
Create a backup table to store DatabaseStats:

CREATE TABLE public.tbl_DatabaseStats AS
SELECT 
	datname
	,tup_inserted
	,tup_updated
	,tup_deleted	
FROM pg_stat_database;

Perform few DDLs and DMLs actions:

CREATE TABLE public.tbl_Students(rno int, name character varying);
INSERT INTO public.tbl_Students VALUES(1,'Anvesh');
CREATE TABLE public.tbl_Test88(id int);

Compare the result of below two queries:
If you find differences on any of the columns of your Database, your database stats has been changed and you should take the backup of your database.

SELECT 
	datname
	,tup_inserted
	,tup_updated
	,tup_deleted	
FROM pg_stat_database;

SELECT *FROM public.tbl_DatabaseStats;