Logging in:

su - user(i.e. postgres)
psql

Disconnect:
\q

Create new user:

CREATE SCHEMA test;
CREATE USER NguyenDoan PASSWORD 'password';
GRANT ALL ON SCHEMA test TO NguyenDoan
GRANT ALL ON ALL TABLES IN SCHEMA test TO NguyenDoan;

Show all tables:

\dt
\dn
From programming:
SELECT * FROM pg_catalog.pg_tables

Starting database server manually

service postgresql start

Restricting users to one session each

postgres=# ALTER ROLE fred CONNECTION LIMIT 1;
ALTER ROLE

Pushing users off of the system

SELECT pg_terminate_backend(pid)
FROM pg_stat_activity
WHERE ...

Private Database for Users

postgres=# create user fred;
CREATE ROLE
postgres=# create database fred owner = fred;
CREATE DATABASE
postgres=# BEGIN;
BEGIN
postgres=# REVOKE connect ON DATABASE fred FROM public;
REVOKE
postgres=# GRANT connect ON DATABASE fred TO fred;
GRANT
postgres=# COMMIT;
COMMIT

Multiple Servers on one System

sudo -u postgres pg_createcluster 9.4 main2
sudo -u postgres pg_ctlcluster 9.4 main2 start
psql --cluster 9.4/main2 ...
sudo -u postgres initdb -D /var/lib/pgsql/datadir2
sudo -u postgres pg_ctl -D /var/lib/pgsql/datadir2 start
Superuser/NonSuperuser
CREATE USER username SUPERUSER;
ALTER USER username NOSUPERUSER;
ALTER USER username SUPERUSER;

Revoke User Access From Table

REVOKE ALL ON table1 FROM user2;

Granting User Access To a Table

GRANT USAGE ON someschema TO somerole;
GRANT SELECT, INSERT, UPDATE, DELETE, TRUNCATE ON someschema.sometable TO somerole;
GRANT somerole TO someuser, otheruser;

Creating a New User w/ Prerequisite Options

createuser bob --interactive alice

Prevent a User From Connecting

pguser=# alter user bob nologin;
pguser=# alter user bob login; ALTER ROLE

Forcing number of Concurrent Connections By a User

pguser=# alter user bob connection limit 10;

Force NOLOGIN users to Disconnect

SELECT pg_terminate_backend(pid)
FROM pg_stat_activity a
JOIN pg_roles r ON a.usename = r.rolname AND not rolcanlogin;

Removing a User without Dropping Their Data

testdb=# drop user bob;
pguser=# alter user bob nologin;
pguser=# grant bob bobs_replacement

Enabling Access for Network/Remote Users

postgresql.conf:
listen_addresses = '*'
pg_hba.conf:
# TYPE DATABASE USER CIDR-ADDRESS METHOD
Host all all 0.0.0.0/0 md5

Changing Password Securely

\password
ALTER USER postgres PASSWORD 'yourpassword';

Using a Connection Service File

Create /etc/pg_service.conf
[dbservice1]
host=postgres1
port=5432
dbname=postgres

Find Version
SELECT version();

Server Uptime
SELECT date_trunc('second', current_timestamp - pg_postmaster_start_time()) as
uptime;dd

Listing Databases on this Database Server

psql -l
select datname from pg_database;

How many tables are in the database

SELECT count(*) FROM information_schema.tables
WHERE table_schema NOT IN ('information_schema', 'pg_catalog');

Disk space in a database

SELECT pg_database_size(current_database());

How much disk space a table uses

select pg_relation_size('pgbench_accounts');

Biggest Tables
SELECT table_name ,pg_relation_size(table_schema || '.' || table_name) as size
FROM information_schema.tables
WHERE table_schema
NOT IN ('information_schema', 'pg_catalog')
ORDER BY size DESC
LIMIT 10;

Rows in a table
SELECT count(*) FROM table;

MANAGING AND CREATING USERS:

*Assuming you are root user

CREATE USER:
useradd _______
PASSWORD - passwd

Ex: useradd Nguyen

passwd Nguyen

ATTACHING NEW USERS TO GROUPS:

-g (LOWERCASE) = primary group
-G (UPPERCASE) = additional groups
Adding an already created user to additonal groups:
usermod -G ____, ____, ____

User private group:

useradd -N _____

MODIFYING USER SETTINGS:

usermod
usermod -l "____" ____ = changing a users login

DELETING USERS:
userdel _____

COMPREHENSIVE USER INFORMATION :

lslogins []
lslogins ______
---------------------------------------------------------------------------
MANAGING AND CREATING GROUPS:
Add a new group, default settings:
groupadd ______

SELECT ALL COUNTS FROM TABLE

select table_schema,
table_name,
(xpath('/row/cnt/text()', xml_count))[1]::text::int as row_count
from (
select table_name, table_schema,
query_to_xml(format('select count(*) as cnt from %I.%I', table_schema,
table_name), false, true, '') as xml_count
from information_schema.tables
where table_schema = 'public' --<< change here for the schema you want
AND table_name != 'awsdms_ddl_audit'
) t
ORDER BY TABLE_NAME

-----------------------------------------------------------------------------------
---------------------

DROP ALL USERS IN SESSION

SELECT pg_terminate_backend(pg_stat_activity.pid)FROM pg_stat_activity

WHERE pg_stat_activity.datname = 'TARGET_DB'
AND pid <> pg_backend_pid();

-----------------------------------------------------------------------------------
--------------------

GRANT READER/WRITER/EXECUTOR ACCESS

CREATE ROLE db_writer;

GRANT CONNECT on DATABASE adminuser to db_writer;
GRANT USAGE,CREATE ON SCHEMA public to db_writer;
GRANT INSERT,UPDATE,DELETE,TRUNCATE,REFERENCES,TRIGGER on ALL TABLES in SCHEMA
public to db_writer;
GRANT UPDATE on ALL SEQUENCES in SCHEMA public to db_writer;

-----------------------------------------------------------------------------------
--------------------

Checking Whether a User is Connected

SELECT datname FROM pg_stat_activity WHERE usename = 'bob';

Checking which queries are running

#In postgresql.conf file
SET track_activities = on
SELECT datname, usename, state, query
FROM pg_stat_activity;

SELECT datname, usename, state, query

FROM pg_stat_activity WHERE state = 'active';

#Watching the longest queries

SELECT current_timestamp - query_start AS runtime,datname, usename, query
FROM pg_stat_activity
WHERE state = 'active' ORDER BY 1 DESC;

Checking which queries are active or blocked

SELECT datname, usename, query
FROM pg_stat_activity
WHERE waiting = true;

#Catches Queries waiting on locks

db=# SELECT pg_sleep(10); pg_sleep

Knowing who is blocking a query

SELECT
w.query AS waiting_query,
w.pid AS waiting_pid,
w.usename AS waiting_user,
l.query AS locking_query,
l.pid AS locking_pid,
l.usename AS locking_user,
t.schemaname || '.' || t.relname AS tablename
FROM pg_stat_activity w
JOIN pg_locks l1 ON w.pid = l1.pid AND NOT l1.granted
JOIN pg_locks l2 ON l1.relation = l2.relation AND l2.granted
JOIN pg_stat_activity l ON l2.pid = l.pid
JOIN pg_stat_user_tables t ON l1.relation = t.relid
WHERE w.waiting;

Killing a specific session

#First try to simply cancel the query
pg_cancel_backend(pid)

#Then try
pg_terminate_ backend(pid).

Killing Idle Transaction Queries

SELECT pg_terminate_backend(pid)
FROM pg_stat_activity
WHERE state = 'idle in transaction'
AND current_timestamp - query_start > '10 min';f

Knowing whether anybody is using a specific table

CREATE TEMPORARY TABLE tmp_stat_user_tables AS
SELECT * FROM pg_stat_user_tables;

SELECT * FROM pg_stat_user_tables n

JOIN tmp_stat_user_tables t
ON n.relid=t.relid
AND (n.seq_scan,n.idx_scan,n.n_tup_ins,n.n_tup_upd,n.n_tup_del)
<> (t.seq_scan,t.idx_scan,t.n_tup_ins,t.n_tup_upd,t.n_tup_del);

Writing a Script that Only Succeeds or Fails

BEGIN;
command 1;
command 2;
command 3;
COMMIT;

Add/Remove Column On Table

ALTER TABLE mytable
ADD COLUMN last_update_timestamp TIMESTAMP WITHOUT TIME ZONE;

ALTER TABLE mytable

DROP COLUMN last_update_timestamp;

PostgreSQL Super User

CREATE USER username SUPERUSER;
ALTER USER username NOSUPERUSER; (removes super user status)
ALTER USER username SUPERUSER; (restores super user status)

Revoking User Access to a Table

REVOKE ALL ON table1 FROM user2;

Temporarily Preventing a User from Connecting

alter user bob nologin;
alter user bob login;

Checks whether or not all Users have a Secure Password

select usename,passwd from pg_shadow where passwd not like 'md5%' or length(passwd)
<> 35;

Giving limited superuser powers to specific users

ALTER ROLE BOB WITH CREATEDB;
ALTER ROLE BOB WITH CREATEUSER;

Always knowing which user is logged in

select current_user, session_user;

Starting the Database Server Manually

pg_ctl -D /var/lib/pgsql/data start
service postgresql start

Stopping the Server Safely and Quickly

pg_ctl -D datadir -m fast stop

******* Stopping Server in an Emergency *******

pg_ctl -D datadir stop -m immediate

Reloading Server Configuration Files

service postgresql reload
Prevent New Connections
ALTER DATABASE foo_db CONNECTION LIMIT 0;

Specific User:
ALTER USER foo CONNECTION LIMIT 0;

SELECT procpid, age(query_start, clock_timestamp()), usename, current_queryFROM

pg_stat_activityWHERE current_query != '<IDLE>' AND current_query NOT ILIKE
'%pg_stat_activity%'ORDER BY query_start desc;
-- show running queries (9.2)SELECT pid, age(query_start, clock_timestamp()),
usename, queryFROM pg_stat_activityWHERE query != '<IDLE>' AND query NOT ILIKE
'%pg_stat_activity%'ORDER BY query_start desc;
-- kill running querySELECT pg_cancel_backend(procpid);
-- kill idle querySELECT pg_terminate_backend(procpid);
-- vacuum commandVACUUM (VERBOSE, ANALYZE);
-- all database usersselect * from pg_stat_activity where current_query not like '<
%';
-- all databases and their sizesselect * from pg_user;
-- all tables and their size, with/without indexesselect datname,
pg_size_pretty(pg_database_size(datname))from pg_databaseorder by
pg_database_size(datname) desc;
-- cache hit rates (should not be less than 0.99)SELECT sum(heap_blks_read) as
heap_read, sum(heap_blks_hit) as heap_hit, (sum(heap_blks_hit) -
sum(heap_blks_read)) / sum(heap_blks_hit) as ratioFROM pg_statio_user_tables;
-- table index usage rates (should not be less than 0.99)SELECT relname, 100 *
idx_scan / (seq_scan + idx_scan) percent_of_times_index_used, n_live_tup
rows_in_tableFROM pg_stat_user_tablesORDER BY n_live_tup DESC;
-- how many indexes are in cacheSELECT sum(idx_blks_read) as idx_read,
sum(idx_blks_hit) as idx_hit, (sum(idx_blks_hit) - sum(idx_blks_read)) /
sum(idx_blks_hit) as ratioFROM pg_statio_user_indexes;
-- Dump database on remote host to file$ pg_dump -U username -h hostname
databasename > dump.sql
-- Import dump into existing database$ psql -d newdb -f dump.sql