In this post, I am sharing tips like how to use a psql session variable to make your queries more dynamic in PostgreSQL.

As a DBA, we prepared lots of .sql files in our server for different purposes like check DB stats, get tables size, get object information.

We are executing this scripts (.sql files) many times, but every time we have to change the schema name parameters because we are checking for different schemas and we hard coded the schema values in the SQL scripts.

I found one solution to resolve this problem, that is PSQL Command line variable. You can declare the variable in the PSQL Session and can use for that session.

The benefit of this is, you do not require to update .sql files for again and again, and multiple people can use same SQL script at a time for different schemas.

Note: As this is a session variable so whenever you connect to PSQL, you have to declare this variable.

Check the below demonstration:

Step 1: Connect to PSQL

root-> psql -d database_name

Step 2: Create a session variable

psql-> \set SchemaVariable '\'my_schema_1\''

Step 3: Embed that variable in your SELECT script of .sql file

select       
       tablename
       ,attname      
       ,avg_width
from pg_stats
where schemaname = :SchemaVariable;

If you are using a list of schemas, you can also assign multiple schema names to a session variable.

Declare session variable for multiple values:

\set SchemaVariable '\'my_schema_1\',\'my_schema_2\''

Use session variable in IN clause:

select       
       tablename
       ,attname      
       ,avg_width
from pg_stats
where schemaname in (:SchemaVariable);

I found lots of questions and discussions on the difference between stored procedure local variable and session-specific user-defined variable of MySQL.

MySQL provides session specific user defined variable to initialize and use during the session.

The scope of this variable is for the specific session only and outside of that session another client connection cannot access this variable and once session terminates, it destroys automatically.

This is loosely typed variables and we can initialize somewhere in a session.
We can write @var_name to define a session specific variable.

We also have one local variable, which we can define and use for specific stored objects like a stored procedure.
The scope of this local variable is for that object execution purpose. Once a stored procedure executes, it destroys automatically.

Below is a small demonstration on use of @variable vs variable:
Create a sample stored procedure with session and local variable:

DELIMITER //
CREATE PROCEDURE usp_TestVariables()
BEGIN
    -- Declare Local Variable.....
    DECLARE MyVariable INT DEFAULT 1;
    SET MyVariable := MyVariable + 1;
    
    -- Define Session Specific Variable.....
    SET @MyVariable := @MyVariable + 1;
    
    SELECT  MyVariable, @MyVariable;
END;

-- Assign value to user defined variable.
SET @MyVariable = 1;

-- Execute this stored procedure multiple times to check a value of both the variables.
CALL usp_TestVariables();

--The result of first call.
MyVariable    @MyVariable
-----------  ----------------
    2	           2

--The result of second call.
MyVariable    @MyVariable
-----------  ----------------
    2	           3

--The result of third call.
MyVariable    @MyVariable
-----------  ----------------
    2	           4

--The result of fourth call.
MyVariable    @MyVariable
-----------  ----------------
    2	           5

You can check the above result, where @MyVariable is incrementing because it persists values until session end.
A stored procedure local variable is not incrementing because it destroyed after every execution of the stored procedure.