├── README.md
├── dba_scripts
    ├── README.txt
    ├── cache_hit_ratio.sh
    ├── cancel_all_queries.sh
    ├── check_postgresql_log.sh
    ├── columns_of_type_x.sh
    ├── connect_count.sh
    ├── current_locks.sh
    ├── current_queries.sh
    ├── database_sizes.sh
    ├── filename_tables.sh
    ├── flip_database_connect.sh
    ├── get_trans_min_cnt.sh
    ├── groups_users.sh
    ├── index_bloat.sh
    ├── index_comments.sh
    ├── logins_allow.sh
    ├── logins_block.sh
    ├── pg_backup.sh
    ├── pg_runtime.sh
    ├── pg_stat_all_indexes.sh
    ├── pg_stat_all_tables.sh
    ├── pg_vacuum_time.sh
    ├── remove_ctrl.sh
    ├── role_members.sh
    ├── slony_status.sh
    ├── table_column_stats.sh
    ├── table_comments.sh
    ├── table_dependents.sh
    ├── table_in_function.sh
    ├── table_in_trigger.sh
    ├── table_sizes.sh
    ├── tables_and_owners.sh
    ├── tables_filenames.sh
    ├── tables_with_FKs.sh
    ├── tables_with_column_name.sh
    ├── tables_with_no_public_grants.sh
    ├── tablespace_use.sh
    ├── triggers_and_constraints.sh
    ├── user_table_access.sh
    └── user_table_access_detail.sh
└── queries
    ├── ALL_COLUMNS.sql
    ├── ALL_CONSTRAINTS.sql
    ├── ALL_TABLES.sql
    ├── README.txt
    ├── Tables_and_PKs.sql
    ├── Tables_with_FKs.sql
    ├── Tables_with_no_FK.sql
    ├── bad_idx.sql
    ├── blocked_transactions.sql
    ├── cache_hit_ratio.sql
    ├── cancel_all_queries.sql
    ├── check_fks.sql
    ├── column_name_type_difference.sql
    ├── columns_of_type_x.sql
    ├── connection_counts.sql
    ├── current_locks.sql
    ├── current_queries.sql
    ├── current_queries_blocked.sql
    ├── database_info.sql
    ├── database_sizes.sql
    ├── distinct_data_types.sql
    ├── enum_maint.sql
    ├── enums.sql
    ├── filenames_and_tables.sql
    ├── gen_create_indexes.sql
    ├── gen_drop_indexes.sql
    ├── gen_get_seq_max.sql
    ├── gen_revoke_all.sql
    ├── gen_table_compare_counts.sql
    ├── get_slony_schemas.sql
    ├── get_trans_min_cnt.sql
    ├── groups_users.sql
    ├── inactive_tables.sql
    ├── index_bloat.sql
    ├── index_bloat2.sql
    ├── index_comments.sql
    ├── index_sizes.sql
    ├── index_tablespaces.sql
    ├── make_alter_index_spc.sql
    ├── make_alter_table_spc.sql
    ├── most_active_tables.sql
    ├── parent_and_children.sql
    ├── pg_runtime.sql
    ├── pg_stat_all_indexes.sql
    ├── pg_stat_all_tables.sql
    ├── role_members.sql
    ├── rules.sql
    ├── sequence_cols.sql
    ├── show_dead_tuples.sql
    ├── table_access.sql
    ├── table_columns.sql
    ├── table_comments.sql
    ├── table_constraints.sql
    ├── table_dependents.sql
    ├── table_grants.sql
    ├── table_in_function.sql
    ├── table_in_schema.sql
    ├── table_in_trigger.sql
    ├── table_indexes.sql
    ├── table_row_counts.sql
    ├── table_sizes.sql
    ├── table_stats.sql
    ├── table_triggers.sql
    ├── tables_and_comments.sql
    ├── tables_and_filenames.sql
    ├── tables_and_owners.sql
    ├── tables_and_pkey.sql
    ├── tables_with_FKs.sql
    ├── tables_with_column_name.sql
    ├── tables_with_large_index_size.sql
    ├── tables_with_no_FK.sql
    ├── tables_with_no_pkey.sql
    ├── tables_with_no_public_grants.sql
    ├── tcp_settings.sql
    ├── triggers_and_constraints.sql
    ├── useless_indexes.sql
    ├── useless_indexes2.sql
    ├── user_table_access.sql
    ├── user_table_access_detail.sql
    ├── users.sql
    └── wasted_index_space.sql


/README.md:
--------------------------------------------------------------------------------
 1 | This is a set of Linux scripts and PostgreSQL 9.4
 2 | queries by Melvin Davidson. They were shared on the
 3 | pgsql-general mailing list on 26 May 2015.
 4 | 
 5 | CAVEAT EMPTOR! 
 6 | Please DO NOT write to me asking me why I did things one 
 7 | way when you think it should be done another way, 
 8 | or way I chose specific values for a query. 
 9 | There are several available editors you can use to make your own changes.
10 | 
11 | IOW: Do not peer into the oral cavity of an equestrian present!
12 | 


--------------------------------------------------------------------------------
/dba_scripts/README.txt:
--------------------------------------------------------------------------------
 1 | These scripts should work on all versions of PostgreSQL up to 9.4
 2 | Most have options to specify host and port.
 3 | ./<script> -h shows all options
 4 | 
 5 | cache_hit_ratio.sh -> Shows the cache hit ration for all databases 
 6 | cancel_all_queries.sh -> Terminates all queries in progress
 7 | check_postgresql_log.sh -> greps the postgres log file for ERROR, WARNING and ref's to pg_hba. You will probably need to edit and adjust the directory path  and suffix for your cluster.
 8 | columns_of_type_x -> Shows all tables and columns with specific character type
 9 | connect_count.sh -> Shows connection count for each database
10 | current_locks.sh -> Shows status for all current locks
11 | current_queries.sh -> Shows information on all current queries, will loop continuously unless -x option is specified. -s option specifies sleeptime, default is 5 secs. -i will ignore <IDLE> queries
12 | database_sizes.sh -> shows size of all databases 
13 | filename_tables.sh -> shows physical directory, filename, owner & size for all tables in specified database
14 | 
15 | flip_database_connect.sh -> Flips state of datallowconn for database
16 | 
17 | get_trans_min_cnt.sh -> shows transaction count per minute for cluster
18 | groups_users.sh -> shows all groups & members in cluster and if group or user is a superuser
19 | index_bloat.sh -> shows index ration to table size for all indexes of all or specified table in database.
20 | index_comments.sh -> shows comments on all or specified index for database
21 | 
22 | logins_block.sh -> prevents all non-superusers from future logins. MUST be run as user postgres
23 | logins_allow.sh -> re-allows login access to all normal users. MUST be run as user postgres
24 | 
25 | pg_backup.sh -> generic backup script for postgres database. You will need to edit and adjust for your needs.
26 | pg_runtime.sh -> shows startup and continuous runtime for the cluster
27 | pg_stat_all_indexes.sh -> shows stats and status of all indexes or just for specified table
28 | pg_stat_all_tables.sh -> shows stats for all or specified table
29 | pg_vacuum_time.sh -> Shows total time to vacuum a database
30 | remove_ctrl.sh -> removes control characters from a script. Useful if script was created on a windows PC and then copied to Linux
31 | role_members.sh -> Shows roles and all members
32 | slony_status.sh -> shows status and lag time of slony cluster. Should be run on master node.
33 | table_column_stats.sh -> shows stats for all columns of specified table
34 | table_comments.sh -> shows comments for all or specified table
35 | table_dependents.sh -> shows foreign key constraints for all or specified table
36 | table_in_functions.sh -> shows all functions that reference specified table
37 | table_in_trogger.sh -> shows all triggerss that reference specified table
38 | tables_and_owners.sh -> shows owners and permits on all tables
39 | tables-filenames.sh -> shows physical directory, filename, owner & size for all tables in specified database
40 | table_sizes.sh -> shows tuple count and size for all or specified table
41 | tablespace_use.sh -> shows tablespace used by all or specified table/index
42 | tables_with_column_name.sh -> shows all tables that have a column name LIKE specified column name
43 | tables_with_FKS.sh -> shows all tables taht have a foreign key constraint 
44 | tables_with_no_public_grants.sh -> shows tables that have no public grants (restricted table)
45 | triggers_and_constraints.sh -> shows all triggers and called functions for all or specified table
46 | user_table_access_detail.sh -> shows table access for specified user
47 | user_table_access.sh -> shows permit and position in permit for specified user
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/dba_scripts/cache_hit_ratio.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Shows cache hit ratio for all databases
 3 | 
 4 | USER=""
 5 | PORT=""
 6 | DBNAME="postgres"
 7 | 
 8 | usage() {
 9 |     echo "Usage: $0 [-d <dbname> -h <host> -U <user> -p <port>]"
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:h:p:uU:" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME=$OPTARG
16 | 	 ;;
17 |       h) HOST="-h $OPTARG"
18 | 	 ;;
19 |       p) PORT="-p $OPTARG"
20 | 	 ;;
21 |       U) USER="-U $OPTARG"
22 | 	 ;;
23 |       u) usage
24 | 	 ;;
25 |     [?]) usage
26 |    esac;
27 | done
28 | 
29 | if [ "$DBNAME" = "" ]
30 |   then
31 |     usage
32 |     exit 1
33 | fi
34 | 
35 | psql $USER $HOST $PORT $DBNAME <<_EOF_
36 | SELECT pg_stat_database.datname,
37 |        pg_stat_database.blks_read,
38 |        pg_stat_database.blks_hit,
39 |        round((pg_stat_database.blks_hit::double precision
40 | 	      / (pg_stat_database.blks_read
41 | 		 + pg_stat_database.blks_hit
42 | 		 +1)::double precision * 100::double precision)::numeric, 2) AS cachehitratio
43 |    FROM pg_stat_database
44 |   WHERE pg_stat_database.datname !~ '^(template(0|1)|postgres)$'::text
45 |   ORDER BY round((pg_stat_database.blks_hit::double precision
46 | 		 / (pg_stat_database.blks_read
47 | 		    + pg_stat_database.blks_hit
48 | 		    + 1)::double precision * 100::double precision)::numeric, 2) DESC;
49 | _EOF_
50 | 


--------------------------------------------------------------------------------
/dba_scripts/cancel_all_queries.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | usage() {
 4 |     echo "Usage: $0 [-h <host> -p <port>]"
 5 |     echo "-p will default to 5432"
 6 |     exit 1
 7 | }
 8 | 
 9 | while getopts "h:p:" OPT;
10 | do case "${OPT}" in
11 |       h) HOST="-h $OPTARG"
12 | 	 ;;
13 |       p) PORT="-p $OPTARG"
14 | 	 ;;
15 |       u) usage
16 | 	 ;;
17 |     [?]) usage
18 |    esac;
19 | done
20 | 
21 | getver()
22 | {
23 | VER=$(psql -t $HOST $PORT -U postgres <<_QRYVER_
24 | SELECT substring(version() from 12 for 1);
25 | _QRYVER_
26 | )
27 | }
28 | 
29 | cancel_pids()
30 | {
31 | psql -t $HOST $PORT -U postgres <<_QRYVER_
32 | --SELECT pg_cancel_backend($PID)
33 | SELECT pg_terminate_backend($PID)
34 |   FROM pg_stat_activity WHERE pg_backend_pid() <> $PID);
35 | _QRYVER_
36 | 
37 | }
38 | 
39 | ##### MAIN #####
40 | 
41 | getveri
42 | declare -i VER
43 | if [ "$VER" -lt 9 ]
44 |   then
45 |     PID="procpid"
46 |   else
47 |     PID="pid"
48 | fi
49 | cancel_pids
50 | 
51 | exit 0;
52 | 
53 | 


--------------------------------------------------------------------------------
/dba_scripts/check_postgresql_log.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # if arguments > 0, set count option
 4 | 
 5 | if [ $# -eq 0 ]
 6 |   then
 7 |     cntflg='-c'
 8 | else
 9 |     cntflg=''
10 | fi
11 | 
12 | set $(date '+%m%d')
13 | MMDD=$1
14 | 
15 | #set $(date)
16 | ## if day number less than 10, prefix a '0'
17 | #if [ $3 -le 9 ]
18 | #  then
19 | #    DD=0${3}
20 | #  else
21 | #    DD=${3}
22 | #fi
23 | 
24 | set $(date +%m)
25 | MM=${1}
26 | logdir=/var/log/postgresql/
27 | 
28 | echo "Current error log is: ${logdir}postgresql.${MMDD}"
29 | echo
30 | echo -n "ERROR: "
31 | grep ${cntflg} -i ERROR   ${logdir}postgresql.${MMDD}
32 | echo -n "WARNING: "
33 | grep ${cntflg} -i WARNING ${logdir}postgresql.${MMDD}
34 | echo -n "pg_hba: "
35 | grep ${cntflg} -i pg_hba  ${logdir}postgresql.${MMDD}
36 | 


--------------------------------------------------------------------------------
/dba_scripts/columns_of_type_x.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Shows tables and columns that are of type specified
 3 | 
 4 | PORT=""
 5 | USER=""
 6 | COLTYPE="?"
 7 | 
 8 | usage() {
 9 |     echo "Usage: $0 -d <dbname> -t <coltype> [-h <host> -U <user> -p <port>]"
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:t:h:p:uU:" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME=$OPTARG
16 | 	 ;;
17 |       h) HOST="-h $OPTARG"
18 | 	 ;;
19 |       p) PORT="-p $OPTARG"
20 | 	 ;;
21 |       t) COLTYPE="$OPTARG"
22 | 	 ;;
23 |       U) USER="-U $OPTARG"
24 | 	 ;;
25 |       u) usage
26 | 	 ;;
27 |     [?]) usage
28 |    esac;
29 | done
30 | 
31 | if [ "$DBNAME" = "" ]
32 |   then
33 |     DBNAME="postgres"
34 | fi
35 | 
36 | choose_qry ()
37 | {
38 | 
39 | if [ "$COLTYPE" = "?" ]
40 |   then
41 |      echo "Usage: $0 -d <dbname> -t <coltype> [-h <host> -U <user> -p <port>]"
42 |      echo
43 |      echo "Available Data Types"
44 |      QRY="SELECT DISTINCT (c.data_type)
45 |       FROM information_schema.columns c
46 |       ORDER BY c.data_type;"
47 | else
48 |      QRY="SELECT quote_ident(c.table_schema) as schema,
49 | 	   quote_ident(c.table_name) as table,
50 | 	   quote_ident(c.column_name) as column,
51 | 	   c.data_type as type,
52 | 	   case when c.data_type LIKE '%char%'
53 | 		    then COALESCE(character_maximum_length::text, 'N/A')
54 | 		    when c.data_type LIKE '%numeric%'
55 | 		    then '(' || c.numeric_precision::text || ', ' || c.numeric_scale::text || ')'
56 | 		    when c.data_type LIKE '%int%'
57 | 		    then c.numeric_precision::text
58 | 		    else COALESCE(character_maximum_length::text, 'N/A')
59 | 	   end as size
60 |       FROM information_schema.columns c
61 |      WHERE c.table_schema NOT LIKE 'pg_%'
62 |        AND c.table_schema NOT LIKE 'information%'
63 |        AND c.table_name NOT LIKE 'sql_%'
64 |        AND c.data_type LIKE '%$COLTYPE%'
65 |        AND c.is_updatable = 'YES'
66 |     ORDER BY 1, 2, 3;"
67 | fi
68 | 
69 | psql $HOST $USER $PORT $DBNAME <<_CODE_
70 | 
71 | ${QRY}
72 | 
73 | _CODE_
74 | 
75 | }
76 | 
77 | choose_qry
78 | 


--------------------------------------------------------------------------------
/dba_scripts/connect_count.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | 
  3 | DBNAME="postgres"
  4 | USER="-U postgres"
  5 | PORT="-p 5432"
  6 | 
  7 | usage() {
  8 |     echo "Usage: $0 [-d <dbname> -h <host> -U <user> -p <port> u]"
  9 |     exit 1
 10 | }
 11 | 
 12 | while getopts "d:h:p:uU:" OPT;
 13 | do case "${OPT}" in
 14 |       d) DBNAME=$OPTARG
 15 | 	 ;;
 16 |       h) HOST="-h $OPTARG"
 17 | 	 ;;
 18 |       p) PORT="-p $OPTARG"
 19 | 	 ;;
 20 |       U) USER="-U $OPTARG"
 21 | 	 ;;
 22 |       u) usage
 23 | 	 ;;
 24 |     [?]) usage
 25 |    esac;
 26 | done
 27 | 
 28 | 
 29 | set $(date '+%m%d')
 30 | MMDD=$1
 31 | 
 32 | LOGDIR='/var/log/postgresql'
 33 | 
 34 | getver()
 35 | {
 36 | VER=$(psql $HOST $PORT $USER $DBNAME <<_QUERY_
 37 | SELECT version();
 38 | 
 39 | _QUERY_
 40 | 
 41 | )
 42 | 
 43 | #VER=$(cat ${PGDATA}/PG_VERSION)
 44 | #use next line only if PGDATA has version in path
 45 | #VER=$(echo $PGDATA | cut -d / -f 5)
 46 | }
 47 | 
 48 | clear
 49 | 
 50 | getver
 51 | echo "PostgreSQL Version is $VER"
 52 | 
 53 | connect_cnts() {
 54 | DBLIST=$(psql -q -t $HOST $PORT $USER $DBNAME <<_QUERY_
 55 | 
 56 | SELECT d.datname
 57 |   FROM pg_database d
 58 |  WHERE datallowconn = TRUE
 59 |    AND datistemplate = FALSE
 60 |  ORDER BY 1;
 61 | 
 62 | _QUERY_
 63 | 
 64 | )
 65 | 
 66 | 
 67 | }
 68 | 
 69 | get_cnt() {
 70 | 
 71 | 
 72 | CNT=$(psql -t $PORT $USER $DBNAME <<_QUERY_
 73 | 
 74 | /*
 75 | SELECT count(*)
 76 |   FROM pg_stat_activity
 77 |  WHERE datname = '$DB';
 78 | */
 79 | SELECT usename,
 80 |        count(*)
 81 |   FROM pg_stat_activity
 82 |  WHERE datname = '$DB'
 83 |   GROUP BY usename;
 84 | 
 85 | 
 86 | _QUERY_
 87 | )
 88 | 
 89 | }
 90 | 
 91 | all_count() {
 92 | CNT=$(psql -t $PORT $USER $DBNAME <<_QUERY_
 93 | 
 94 | SELECT count(*)
 95 |   FROM pg_stat_activity;
 96 | 
 97 | _QUERY_
 98 | )
 99 | 
100 | }
101 | 
102 | ###############################################################
103 | #			  MAIN				      #
104 | ###############################################################
105 | 
106 | connect_cnts
107 | 
108 | for DB in $DBLIST;
109 | do
110 |  echo -n "$DB "
111 | get_cnt
112 | # grep -E -c "$DB.*connection auth" #LOGDIR/postgresql.${MMDD}
113 | echo -e "\t$CNT"
114 | done
115 | 
116 | all_count
117 | echo
118 | echo -e "TOTAL \t\t$CNT"
119 | 
120 | #exit 0
121 | 
122 | #echo "$(hostname -f) CONNECTION COUNTS"
123 | #echo "Current log file is: $logdir/postgresql.$MMDD"
124 | #echo
125 | 
126 | #for DB in $DBLIST
127 | #    do
128 | #	 echo -n "$DB: "
129 | #	 grep 'connection authorized' $LOGDIR/postgresql.${MMDD} | grep -c "$DB"
130 | #done
131 | #exit 0
132 | 


--------------------------------------------------------------------------------
/dba_scripts/current_locks.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | 
  3 | USER="-U postgres"
  4 | PORT="-p 5432"
  5 | 
  6 | usage() {
  7 |     echo "Usage: $0 -d <dbname> [-h <host> -U <user> -p <port>]"
  8 |     exit 1
  9 | }
 10 | 
 11 | while getopts "d:h:p:uU:" OPT;
 12 | do case "${OPT}" in
 13 |       d) DBNAME=$OPTARG
 14 | 	 ;;
 15 |       h) HOST="-h $OPTARG"
 16 | 	 ;;
 17 |       p) PORT="-p $OPTARG"
 18 | 	 ;;
 19 |       U) USER="-U $OPTARG"
 20 | 	 ;;
 21 |       u) usage
 22 | 	 ;;
 23 |     [?]) usage
 24 |    esac;
 25 | done
 26 | 
 27 | if [ "$DBNAME" = "" ]
 28 |   then
 29 |     DBNAME="postgres"
 30 | fi
 31 | 
 32 | #Column names changed from procpid $ current_query to pid & query from 9.2 up
 33 | gettstver()
 34 | {
 35 | TSTVER=$(psql  -q -t $HOST $PORT $USER $DBNAME <<_QRY_
 36 | SELECT CASE WHEN SUBSTRING(version() FROM 12 FOR 3) < '9.2'
 37 | 	    THEN 'procpid'
 38 | 	    ELSE 'pid'
 39 | 	END;
 40 | _QRY_
 41 | 
 42 | )
 43 | 
 44 | TSTVER=${TSTVER:1:7}
 45 | 
 46 | }
 47 | 
 48 | gettstver
 49 | 
 50 | if [ "${TSTVER}" = "procpid" ]
 51 |   then
 52 |     COL="procpid"
 53 |     QRY="current_query"
 54 |   else
 55 |     COL="pid"
 56 |     QRY="query"
 57 | fi
 58 | 
 59 | 
 60 | getver()
 61 | {
 62 | VER=$(psql -t $HOST $PORT $USER $DBNAME <<_QRYVER_
 63 | SELECT version();
 64 | _QRYVER_
 65 | )
 66 | }
 67 | 
 68 | getver
 69 | VER=$(echo $VER | cut -c -16)
 70 | echo "Version is $VER"
 71 | 
 72 | current_locks() {
 73 | LCKLIST=$(psql -q $HOST $PORT $USER $DBNAME <<_QUERY_
 74 | 
 75 | SELECT l.database,
 76 |        d.datname,
 77 |        l.relation,
 78 |        n.nspname,
 79 |        c.relname,
 80 |        l.pid,
 81 |        a.usename,
 82 |        l.locktype,
 83 |        l.mode,
 84 |        l.granted,
 85 |        l.tuple
 86 |   FROM pg_locks l
 87 |   JOIN pg_class c ON (c.oid = l.relation)
 88 |   JOIN pg_database d ON (CASE WHEN l.database = 0 THEN d.oid = 0 ELSE d.oid = l.database END)
 89 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 90 |   JOIN pg_stat_activity a ON (a.$COL = l.pid)
 91 | ORDER BY l.database,
 92 | 	 l.relation,
 93 | 	 l.pid;
 94 | 
 95 | _QUERY_
 96 | 
 97 | )
 98 | 
 99 | }
100 | 
101 | if [ "$DBNAME" = "" ]
102 |   then
103 |     usage
104 | fi
105 | 
106 | current_locks
107 | echo "${LCKLIST}"
108 | 
109 | exit 0
110 | 


--------------------------------------------------------------------------------
/dba_scripts/current_queries.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | 
  3 | DBNAME="postgres"
  4 | USER="-U postgres"
  5 | PORT="-p 5432"
  6 | SLEEPTIME=5
  7 | CANCEL="F"
  8 | NOIDLE=""
  9 | 
 10 | usage() {
 11 |     echo "Usage: $0 [-s <sleeptime> -d <dbname> -h <host> -U <user> -p <port> -x -i]"
 12 |     echo "-x will exit after 1 iteration"
 13 |     echo "-i will exclude <IDLE> queries"
 14 |     exit 1
 15 | }
 16 | 
 17 | while getopts "d:s:h:p:uU:xi" OPT;
 18 | do case "${OPT}" in
 19 |       d) DBNAME=$OPTARG
 20 | 	 ;;
 21 |       s) SLEEPTIME=$OPTARG
 22 | 	 ;;
 23 |       h) HOST="-h $OPTARG"
 24 | 	 ;;
 25 |       p) PORT="-p $OPTARG"
 26 | 	 ;;
 27 |       U) USER="-U $OPTARG"
 28 | 	 ;;
 29 |       x) CANCEL="T"
 30 | 	 ;;
 31 |       i) NOIDLE="AND current_query <> '<IDLE>'"
 32 | 	 ;;
 33 |       u) usage
 34 | 	 ;;
 35 |     [?]) usage
 36 |    esac;
 37 | done
 38 | 
 39 | if [ "$DBNAME" = "" ]
 40 |   then
 41 |     usage
 42 |     exit 1
 43 | fi
 44 | 
 45 | getver() {
 46 | VER=$(psql  -q -t $HOST $PORT $USER $DBNAME <<_VER_
 47 | 
 48 | SELECT SUBSTR(version(), 1, 16);
 49 | 
 50 | _VER_
 51 | 
 52 | )
 53 | 
 54 | }
 55 | 
 56 | #Column names changed from procpid $ current_query to pid & query from 9.2 up
 57 | gettstver()
 58 | {
 59 | TSTVER=$(psql  -q -t $HOST $PORT $USER $DBNAME <<_QRY_
 60 | SELECT CASE WHEN SUBSTRING(version() FROM 12 FOR 3) < '9.2'
 61 | 	    THEN 'procpid'
 62 | 	    ELSE 'pid'
 63 | 	END;
 64 | _QRY_
 65 | 
 66 | )
 67 | 
 68 | TSTVER=${TSTVER:1:7}
 69 | 
 70 | }
 71 | 
 72 | gettstver
 73 | 
 74 | if [ "${TSTVER}" = "procpid" ]
 75 |   then
 76 |     COL="procpid"
 77 |     QRY="current_query"
 78 |   else
 79 |     COL="pid"
 80 |     QRY="query"
 81 | fi
 82 | 
 83 | getver
 84 | echo "$VER"
 85 | sleep 2
 86 | 
 87 | current_qry() {
 88 | QRYLIST=$(psql -q $HOST $PORT $USER $DBNAME <<_QUERY_
 89 | 
 90 | SELECT datname,
 91 |        $COL as pid,
 92 | --	 procpid as pid,
 93 |        client_addr,
 94 |        usename as user,
 95 | --	 regexp_replace(current_query, '	(..)', ' ', 'g') as query,
 96 |        regexp_replace($QRY, '	(..)', ' ', 'g') as query,
 97 |        waiting,
 98 |        query_start,
 99 |        clock_timestamp() - query_start as duration
100 |   FROM pg_stat_activity
101 |  --WHERE procpid != pg_backend_pid()
102 |  WHERE $COL != pg_backend_pid()
103 |   $NOIDLE
104 | ORDER BY datname,
105 | 	 query_start;
106 | 
107 | _QUERY_
108 | 
109 | )
110 | 
111 | }
112 | 
113 | #### MAIN ####
114 | 
115 | while [ 1 -ge 0 ]
116 | do
117 |   clear
118 |   current_qry
119 |   echo "${QRYLIST}"
120 |   if [ "$CANCEL" = "T" ]
121 |     then
122 |     exit 0
123 |   fi
124 |   echo "Sleeping $SLEEPTIME"
125 |   sleep $SLEEPTIME
126 | done
127 | 
128 | 


--------------------------------------------------------------------------------
/dba_scripts/database_sizes.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Reports sizes for all or selected database
 3 | 
 4 | PORT=""
 5 | USER=""
 6 | DBNAME="%"
 7 | usage() {
 8 |     echo "Usage: $0 [-d <dbname> -U <user> -p <port>]"
 9 |     exit 1
10 | }
11 | 
12 | while getopts "d:p:uU:" OPT;
13 | do case "${OPT}" in
14 |       d) DBNAME=$OPTARG
15 | 	 ;;
16 |       p) PORT="-p $OPTARG"
17 | 	 ;;
18 |       U) USER="-U $OPTARG"
19 | 	 ;;
20 |       u) usage
21 | 	 ;;
22 |     [?]) usage
23 |    esac;
24 | done
25 | 
26 | if [ "$DBNAME" = "" ]
27 |   then
28 |     usage
29 |     exit 1
30 | fi
31 | 
32 | 
33 | psql $PORT $USER postgres <<_EOF_
34 | SELECT datname,
35 |        rolname as owner,
36 |        pg_size_pretty(pg_database_size(datname)  )as size_pretty,
37 |        pg_database_size(datname) as size,
38 |        (SELECT pg_size_pretty (SUM( pg_database_size(datname))::bigint)
39 | 	  FROM pg_database)  AS total,
40 |        ((pg_database_size(datname) / (SELECT SUM( pg_database_size(datname))
41 | 				       FROM pg_database) ) * 100)::numeric(6,3) AS pct
42 |   FROM pg_database d
43 |   JOIN pg_authid a ON a.oid = datdba
44 |   WHERE datname LIKE '%$DBNAME%'
45 | ORDER BY datname;
46 | _EOF_
47 | 


--------------------------------------------------------------------------------
/dba_scripts/filename_tables.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SHOWS TABLES AND SIZES FOR ALL TABLES
 4 | # SHOULD BE RUN AS a SUPERUSER
 5 | 
 6 | HOST=""
 7 | PORT=""
 8 | USER=""
 9 | 
10 | usage() {
11 |     echo "Usage: $0 -d <dbname> [-h <host> -p <port> -U <user>]"
12 |     exit 1
13 | }
14 | 
15 | while getopts "d:h:p:U:u" OPT;
16 | do case "${OPT}" in
17 |       d) DBNAME=$OPTARG
18 | 	 ;;
19 |       p) PORT="-p $OPTARG"
20 | 	 ;;
21 |       h) HOST="-h $OPTARG"
22 | 	 ;;
23 |       U) USER="-U $OPTARG"
24 | 	 ;;
25 |       u) usage
26 | 	 ;;
27 |     [?]) usage
28 |    esac;
29 | done
30 | 
31 | if [ "$DBNAME" = "" ]
32 |   then
33 |     usage
34 | fi
35 | 
36 | psql $HOST $PORT $USER $DBNAME <<_CODE_
37 | 
38 | SELECT d.oid as directory,
39 |        c.relfilenode as filename,
40 |        n.nspname as schema,
41 |        c.relname as table,
42 |        a.rolname as owner,
43 |        pg_size_pretty(pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(c.relname))) as size
44 |   FROM pg_class c
45 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
46 |   JOIN pg_authid a ON ( a.oid = c.relowner ),
47 |        pg_database d
48 | WHERE d.datname = current_database()
49 |   AND relname NOT LIKE 'pg_%'
50 |   AND relname NOT LIKE 'information%'
51 |   AND relname NOT LIKE 'sql_%'
52 |   AND relkind = 'r'
53 | ORDER BY relfilenode;
54 | 
55 | _CODE_
56 | 


--------------------------------------------------------------------------------
/dba_scripts/flip_database_connect.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Disables or Enables connections to specified database
 3 | 
 4 | PORT=""
 5 | USER=""
 6 | 
 7 | usage() {
 8 |     echo "Usage: $0 -d <dbname> [-p <port> -U <user>]"
 9 |     echo Database name to disable/enable is required
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:p:U:u" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME=$OPTARG
16 | 	 ;;
17 |       p) PORT="-p $OPTARG"
18 | 	 ;;
19 |       U) USER="-U $OPTARG"
20 | 	 ;;
21 |       u) usage
22 | 	 ;;
23 |     [?]) usage
24 |    esac;
25 | done
26 | 
27 | 
28 | if [ "$DBNAME" = "" ]
29 |   then
30 |     usage
31 |     exit 1
32 | fi
33 | 
34 | if [ $DBNAME == "postgres" ]
35 |   then
36 |     echo Disable of postgres is prohibited
37 |     exit
38 | fi
39 | 
40 | echo changing $DBNAME
41 | 
42 | psql $PORT $USER -v ON_ERROR_STOP=on postgres  <<_EOF_
43 | SELECT datname, datallowconn
44 |   FROM pg_database
45 |   WHERE datname = '$DBNAME' ;
46 | 
47 | UPDATE pg_database
48 |   SET datallowconn = CASE
49 | 		     WHEN datallowconn = TRUE THEN
50 | 		       FALSE
51 | 		     ELSE
52 | 		       TRUE
53 | 		     END
54 | WHERE datname = '$DBNAME' ;
55 | 
56 | SELECT datname, datallowconn
57 |   FROM pg_database
58 |     WHERE datname = '$DBNAME' ;
59 | 
60 | \echo Connect status for $DBNAME has been reversed
61 | 
62 | _EOF_
63 | 
64 | 


--------------------------------------------------------------------------------
/dba_scripts/get_trans_min_cnt.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Counts transaction per minute
 3 | # for postgresql server
 4 | # Note: transactions are actual / not potential
 5 | 
 6 | PORT=""
 7 | USER=""
 8 | DBNAME="postgres"
 9 | 
10 | usage() {
11 |     echo "Usage: $0 [-d <dbname> -p <port> -U <user>]"
12 |     exit 1
13 | }
14 | 
15 | while getopts "d:p:U:u" OPT;
16 | do case "${OPT}" in
17 |       d) DBNAME="$OPTARG"
18 | 	 ;;
19 |       p) PORT="-p $OPTARG"
20 | 	 ;;
21 |       U) USER="-U $OPTARG"
22 | 	 ;;
23 |       u) usage
24 | 	 ;;
25 |     [?]) usage
26 |    esac;
27 | done
28 | 
29 | get_procnum() {
30 | PROCNUM=$(psql $PORT -q -t $USER $DBNAME <<_QUERY_
31 | SELECT SUM(xact_commit + xact_rollback)
32 |   FROM pg_stat_database;
33 | 
34 | _QUERY_
35 | 
36 | )
37 | }
38 | 
39 | get_procnum
40 | echo "$PROCNUM"
41 | FIRST_CNT=$PROCNUM
42 | sleep 60
43 | get_procnum
44 | LAST_CNT=$PROCNUM
45 | echo "$PROCNUM"
46 | (( TOT_QRY = $LAST_CNT - $FIRST_CNT ))
47 | echo "Total queries = $TOT_QRY"
48 | 
49 | 


--------------------------------------------------------------------------------
/dba_scripts/groups_users.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | psql -U postgres postgres <<_EOF_
 4 | SELECT g.rolname as group,
 5 |        u.rolname as user,
 6 |        r.admin_option,
 7 |        CASE WHEN g.rolsuper = TRUE
 8 | 	    THEN 'SUPERUSER'
 9 | 	    ELSE 'f'
10 | 	END as g_super,
11 |        CASE WHEN u.rolsuper = TRUE
12 | 	    THEN 'SUPERUSER'
13 | 	    ELSE 'f'
14 | 	END as u_super
15 |   FROM pg_auth_members r
16 |   JOIN pg_authid g ON (r.roleid = g.oid)
17 |   JOIN pg_authid u ON (r.member = u.oid)
18 |   ORDER BY 1;
19 | _EOF_
20 | 


--------------------------------------------------------------------------------
/dba_scripts/index_bloat.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SHOWS TABLES AND SIZES FOR ALL TABLES
 4 | # SHOULD BE RUN AS SUPERUSER
 5 | 
 6 | PORT=""
 7 | USER=""
 8 | TBL=""
 9 | 
10 | usage() {
11 |     echo "Usage: $0 -d <dbname> [-t <table> -p <port> -U <user>]"
12 |     exit 1
13 | }
14 | 
15 | while getopts "d:p:t:U:u" OPT;
16 | do case "${OPT}" in
17 |       d) DBNAME=$OPTARG
18 | 	 ;;
19 |       p) PORT="-p $OPTARG"
20 | 	 ;;
21 |       t) TBL="$OPTARG"
22 | 	 ;;
23 |       U) USER="-U $OPTARG"
24 | 	 ;;
25 |       u) usage
26 | 	 ;;
27 |     [?]) usage
28 |    esac;
29 | done
30 | 
31 | 
32 | if [ "$DBNAME" = "" ]
33 |   then
34 |     usage
35 |     exit 1
36 | fi
37 | 
38 | psql $PORT $USER $DBNAME <<_CODE_
39 | 
40 | SELECT quote_ident(N.nspname),
41 |        quote_ident(T.relname) AS "table",
42 |        quote_ident(C.relname) AS idx_name,
43 |        round(100 * pg_relation_size(indexrelid) / pg_relation_size(indrelid) ) / 100 AS "index_ratio %",
44 |        pg_size_pretty(pg_relation_size(indexrelid) ) AS index_size,
45 |        pg_size_pretty(pg_relation_size(indrelid) )   AS table_size_size
46 |   FROM pg_index I
47 |   LEFT JOIN pg_class C ON (c.oid = I.indexrelid)
48 |   LEFT JOIN pg_class T ON (T.oid = I.indrelid)
49 |   LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
50 |  WHERE nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
51 |    AND c.relkind = 'i'
52 |    AND pg_relation_size(indrelid) > 0
53 |    AND C.relname LIKE '%$TBL%'
54 |  ORDER BY 4 DESC, 2;
55 | 
56 | _CODE_
57 | 


--------------------------------------------------------------------------------
/dba_scripts/index_comments.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | #Shows commnets on all or selected index
 4 | 
 5 | USER=""
 6 | PORT=""
 7 | 
 8 | usage() {
 9 |     echo "Usage: $0 -d <dbname> [-i <index> -U <user> -p <port>]"
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:i:p:uU:" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME=$OPTARG
16 | 	 ;;
17 |       i) IDX=$OPTARG
18 | 	 ;;
19 |       p) PORT="-p $OPTARG"
20 | 	 ;;
21 |       U) USER="-U $OPTARG"
22 | 	 ;;
23 |       u) usage
24 | 	 ;;
25 |     [?]) usage
26 |    esac;
27 | done
28 | 
29 | if [ "$DBNAME" = "" ]
30 |   then
31 |     usage
32 | fi
33 | 
34 | getver()
35 | {
36 | VER=$(psql $PORT -t $USER $DBNAME <<_QRYVER_
37 | SELECT version();
38 | _QRYVER_
39 | )
40 | }
41 | getver
42 | 
43 | VER=$(echo $VER | cut -c -16)
44 | echo "Version is $VER"
45 | 
46 | QRY="SELECT quote_ident(n.nspname) as schema,
47 |        quote_ident(c.relname),
48 |        d.description as comment
49 |        FROM pg_class c
50 |       LEFT JOIN pg_description d ON (d.objoid = c.oid)
51 |       JOIN pg_namespace n ON (n.oid = c.relnamespace)
52 |      WHERE n.nspname NOT LIKE 'information%'
53 |        AND relname NOT LIKE 'pg_%'
54 |        AND relname NOT LIKE 'information%'
55 |        AND relname NOT LIKE 'sql_%'
56 |        AND relname LIKE '%$IDX%'
57 |        AND relkind = 'i'
58 |        AND d.description IS NOT NULL
59 |      ORDER BY 2;"
60 | 
61 | current_stats() {
62 | STATLIST=$(psql $PORT -q $USER $DBNAME <<_QUERY_
63 | 
64 | ${QRY}
65 | 
66 | _QUERY_
67 | 
68 | )
69 | 
70 | }
71 | 
72 | current_stats
73 | echo "${STATLIST}"
74 | 
75 | exit 0
76 | 


--------------------------------------------------------------------------------
/dba_scripts/logins_allow.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | DBNAME="postgres"
 4 | USER="-U postgres"
 5 | PORT="-p 5432"
 6 | 
 7 | usage() {
 8 |     echo "Usage: $0 [-d <dbname> -h <host> -U <user> -p <port> u]"
 9 |     exit 1
10 | }
11 | 
12 | while getopts "d:h:p:uU:" OPT;
13 | do case "${OPT}" in
14 |       d) DBNAME=$OPTARG
15 | 	 ;;
16 |       h) HOST="-h $OPTARG"
17 | 	 ;;
18 |       p) PORT="-p $OPTARG"
19 | 	 ;;
20 |       U) USER="-U $OPTARG"
21 | 	 ;;
22 |       u) usage
23 | 	 ;;
24 |     [?]) usage
25 |    esac;
26 | done
27 | 
28 | 
29 | allow_logins()
30 | {
31 | 
32 | CNT=$(psql $HOST $PORT $USER $DBNAME <<_QUERY_
33 | 
34 | UPDATE pg_authid au
35 |    SET rolcanlogin = TRUE
36 |   FROM pg_lockout lo
37 |  WHERE au.rolname = lo.rolname;
38 | 
39 | _QUERY_
40 | 
41 | )
42 | 
43 | }
44 | 
45 | current_user()
46 | {
47 | 
48 | CUSER=$(psql -t $HOST $PORT $USER $DBNAME <<_QUERY_
49 | 
50 | SELECT TRIM(BOTH FROM current_user);
51 | 
52 | _QUERY_
53 | 
54 | )
55 | 
56 | }
57 | 
58 | 
59 | 
60 | ###############################################################
61 | #			  MAIN				      #
62 | ###############################################################
63 | 
64 | current_user
65 | 
66 | if [ $CUSER != "postgres" ]
67 |   then
68 |     echo "You must be postgres to execute this script."
69 |     echo "Aborting."
70 |     exit 1
71 | fi
72 | 
73 | allow_logins
74 | 
75 | echo "Users allowed to login = $CNT"
76 | 
77 | exit 0
78 | 
79 | 


--------------------------------------------------------------------------------
/dba_scripts/logins_block.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | DBNAME="postgres"
 4 | USER="-U postgres"
 5 | PORT="-p 5432"
 6 | 
 7 | usage() {
 8 |     echo "Usage: $0 [-d <dbname> -U <user> -p <port> u]"
 9 |     exit 1
10 | }
11 | 
12 | while getopts "d:p:uU:" OPT;
13 | do case "${OPT}" in
14 |       d) DBNAME=$OPTARG
15 | 	 ;;
16 |       p) PORT="-p $OPTARG"
17 | 	 ;;
18 |       U) USER="-U $OPTARG"
19 | 	 ;;
20 |       u) usage
21 | 	 ;;
22 |     [?]) usage
23 |    esac;
24 | done
25 | 
26 | 
27 | lockout()
28 | {
29 | 
30 | CNT=$(psql $PORT $USER $DBNAME <<_QUERY_
31 | 
32 | DROP TABLE IF EXISTS pg_lockout;
33 | CREATE TABLE pg_lockout
34 | AS SELECT rolname,
35 | 	  rolsuper,
36 | 	  rolcanlogin
37 |   FROM pg_authid
38 |  WHERE rolsuper IS FALSE;
39 | 
40 | ALTER TABLE pg_lockout
41 |    ADD CONSTRAINT pg_lockout_pkey PRIMARY KEY (rolname);
42 | 
43 | UPDATE pg_authid au
44 |    SET rolcanlogin = FALSE
45 |   FROM pg_lockout lo
46 |  WHERE lo.rolcanlogin = TRUE
47 |    AND au.rolname = lo.rolname;
48 | 
49 | _QUERY_
50 | 
51 | )
52 | 
53 | }
54 | 
55 | current_user()
56 | {
57 | 
58 | CUSER=$(psql -t $PORT $USER $DBNAME <<_QUERY_
59 | 
60 | SELECT TRIM(BOTH FROM current_user);
61 | 
62 | _QUERY_
63 | 
64 | )
65 | 
66 | }
67 | 
68 | 
69 | ###############################################################
70 | #			  MAIN				      #
71 | ###############################################################
72 | 
73 | current_user
74 | 
75 | echo "current user is $CUSER"
76 | 
77 | if [ $CUSER != "postgres" ]
78 |   then
79 |     echo "You must be postgres to execute this script."
80 |     echo "Aborting."
81 |     exit 1
82 | fi
83 | 
84 | 
85 | lockout
86 | 
87 | echo "Users locked out = $CNT"
88 | 
89 | exit 0
90 | 
91 | 


--------------------------------------------------------------------------------
/dba_scripts/pg_backup.sh:
--------------------------------------------------------------------------------
1 | BACKFILE=pgbackup.`date +%C%y%m%d%H%M`
2 | pg_dump  -f /home/pgsql/backup/$BACKFILE -F c postgres
3 | 
4 | 


--------------------------------------------------------------------------------
/dba_scripts/pg_runtime.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Show start and runtime for postgresql server
 3 | 
 4 | DBNAME="postgres"
 5 | PORT=""
 6 | USER=""
 7 | 
 8 | usage() {
 9 |     echo "Usage: $0 [-d <dbname> -p <port> -U <user>]"
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:p:U:u" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME="$OPTARG"
16 | 	 ;;
17 |       p) PORT="-p $OPTARG"
18 | 	 ;;
19 |       U) USER="-U $OPTARG"
20 | 	 ;;
21 |       u) usage
22 | 	 ;;
23 |     [?]) usage
24 |    esac;
25 | done
26 | 
27 | getver()
28 | {
29 | VER=$(psql -t $PORT $USER $DBNAME <<_QRYVER_
30 | SELECT version();
31 | _QRYVER_
32 | )
33 | }
34 | 
35 | getver
36 | VER=$(echo $VER | cut -c -16)
37 | echo "Version is $VER"
38 | 
39 | show_runtime() {
40 | RUNTIME=$(psql -q $PORT $USER $DBNAME <<_QUERY_
41 | 
42 | SELECT pg_postmaster_start_time() as pg_start,
43 |        current_timestamp - pg_postmaster_start_time() as runtime;
44 | 
45 | _QUERY_
46 | 
47 | )
48 | 
49 | }
50 | 
51 | show_runtime
52 | echo "${RUNTIME}"
53 | 
54 | exit 0
55 | 


--------------------------------------------------------------------------------
/dba_scripts/pg_stat_all_indexes.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | 
  3 | # Shows statistics for all indexes on all selected table
  4 | 
  5 | PORT=""
  6 | USER=""
  7 | TBL="%"
  8 | COLS=""
  9 | 
 10 | usage() {
 11 |     echo "Usage: $0 -d <dbname> [-U <user> -p <port> -t <table> -s ]"
 12 |     echo "dbname REQUIRED"
 13 |     echo "-s will show columns used in index"
 14 |     exit 1
 15 | }
 16 | 
 17 | getver()
 18 | {
 19 | VER=$(psql -t $PORT $USER $DBNAME <<_QRYVER_
 20 | SELECT version();
 21 | _QRYVER_
 22 | )
 23 | }
 24 | 
 25 | set_qry_cols() {
 26 | 
 27 | QRY="SELECT n.nspname as schema,
 28 |        i.relname as table,
 29 |        i.indexrelname as index,
 30 |        i.idx_scan,
 31 |        i.idx_tup_read,
 32 |        i.idx_tup_fetch,
 33 |        CASE WHEN idx.indisprimary
 34 | 	    THEN 'pkey'
 35 | 	    WHEN idx.indisunique
 36 | 	    THEN 'uidx'
 37 | 	    ELSE 'idx'
 38 | 	    END AS type,
 39 |        pg_get_indexdef(idx.indexrelid, 1, FALSE) as idxcol1,
 40 |        pg_get_indexdef(idx.indexrelid, 2, FALSE) as idxcol2,
 41 |        pg_get_indexdef(idx.indexrelid, 3, FALSE) as idxcol3,
 42 |        pg_get_indexdef(idx.indexrelid, 4, FALSE) as idxcol4,
 43 |        CASE WHEN idx.indisvalid
 44 | 	    THEN 'valid'
 45 | 	    ELSE 'INVALID'
 46 | 	    END as status,
 47 |        pg_relation_size( quote_ident(n.nspname) || '.' || quote_ident(i.relname) ) as size_in_bytes,
 48 |        pg_size_pretty(pg_relation_size(quote_ident(n.nspname)|| '.' || quote_ident(i.relname) )) as size
 49 |   FROM pg_stat_all_indexes i
 50 |   JOIN pg_class c ON (c.oid = i.relid)
 51 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 52 |   JOIN pg_index idx ON (idx.indexrelid =  i.indexrelid )
 53 |  WHERE i.relname LIKE '%$TBL%'
 54 |    AND n.nspname NOT LIKE 'pg_%'
 55 |  ORDER BY 1, 2, 3;"
 56 | 
 57 | }
 58 | 
 59 | set_qry_nocols() {
 60 | 
 61 | QRY="SELECT n.nspname as schema,
 62 |        i.relname as table,
 63 |        i.indexrelname as index,
 64 |        i.idx_scan,
 65 |        i.idx_tup_read,
 66 |        i.idx_tup_fetch,
 67 |        CASE WHEN idx.indisprimary
 68 | 	    THEN 'pkey'
 69 | 	    WHEN idx.indisunique
 70 | 	    THEN 'uidx'
 71 | 	    ELSE 'idx'
 72 | 	    END AS type,
 73 |        CASE WHEN idx.indisvalid
 74 | 	    THEN 'valid'
 75 | 	    ELSE 'INVALID'
 76 | 	    END as status,
 77 |        pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(i.relname) ) as size_in_bytes
 78 |   FROM pg_stat_all_indexes i
 79 |   JOIN pg_class c ON (c.oid = i.relid)
 80 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 81 |   JOIN pg_index idx ON (idx.indexrelid =  i.indexrelid )
 82 |  WHERE i.relname LIKE '%$TBL%'
 83 |    AND n.nspname NOT LIKE 'pg_%'
 84 |  ORDER BY 1, 2, 3;"
 85 | 
 86 | }
 87 | 
 88 | current_stats() {
 89 | STATLIST=$(psql -q -U postgres $DBNAME <<_QUERY_
 90 | 
 91 | $QRY
 92 | 
 93 | _QUERY_
 94 | 
 95 | )
 96 | 
 97 | }
 98 | 
 99 | ###########################################################
100 | #			 MAIN				  #
101 | ###########################################################
102 | 
103 | while getopts "d:p:st:uU:" OPT;
104 | do case "${OPT}" in
105 |       d) DBNAME=$OPTARG
106 | 	 ;;
107 |       p) PORT="-p $OPTARG"
108 | 	 ;;
109 |       s) COLS="TRUE"
110 | 	 ;;
111 |       t) TBL="$OPTARG"
112 | 	 ;;
113 |       U) USER="-U $OPTARG"
114 | 	 ;;
115 |       u) usage
116 | 	 ;;
117 |     [?]) usage
118 |    esac;
119 | done
120 | 
121 | if [ "$DBNAME" = "" ]
122 |   then
123 |     usage
124 | fi
125 | 
126 | getver
127 | VER=$(echo $VER | cut -c -16)
128 | echo "Version is $VER"
129 | 
130 | if [ "$COLS" = "TRUE" ]
131 |   then
132 |     set_qry_cols
133 |   else
134 |     set_qry_nocols
135 | fi
136 | 
137 | current_stats
138 | echo "${STATLIST}"
139 | 
140 | exit 0
141 | 


--------------------------------------------------------------------------------
/dba_scripts/pg_stat_all_tables.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | # Reports statistics for all tables
  3 | 
  4 | PORT=""
  5 | USER=""
  6 | TBL=""
  7 | 
  8 | usage() {
  9 |     echo "Usage: $0 -d <dbname> [-t <table> -U <user> -p <port>]"
 10 |     exit 1
 11 | }
 12 | 
 13 | while getopts "d:p:t:uU:" OPT;
 14 | do case "${OPT}" in
 15 |       d) DBNAME=$OPTARG
 16 | 	 ;;
 17 |       p) PORT="-p $OPTARG"
 18 | 	 ;;
 19 |       t) TBL=$OPTARG
 20 | 	 ;;
 21 |       U) USER="-U $OPTARG"
 22 | 	 ;;
 23 |       u) usage
 24 | 	 ;;
 25 |     [?]) usage
 26 |    esac;
 27 | done
 28 | 
 29 | if [ "$DBNAME" = "" ]
 30 |   then
 31 |     usage
 32 | fi
 33 | 
 34 | getver()
 35 | {
 36 | VER=$(psql -t $PORT $USER $DBNAME <<_QRYVER_
 37 | SELECT version();
 38 | _QRYVER_
 39 | )
 40 | }
 41 | getver
 42 | 
 43 | VER=$(echo $VER | cut -c -16)
 44 | echo "Version is $VER"
 45 | 
 46 | if [ "${VER:11:3}"  \< "8.3" ]
 47 |   then
 48 |     QRY="SELECT n.nspname as schema,
 49 |        s.relname as table,
 50 |        c.reltuples::bigint,
 51 |        n_tup_ins,
 52 |        n_tup_upd,
 53 |        n_tup_del,
 54 |        date_trunc('second', last_vacuum) as last_vacuum,
 55 |        date_trunc('second', last_autovacuum) as last_autovacuum,
 56 |        date_trunc('second', last_analyze) as last_analyze,
 57 |        date_trunc('second', last_autoanalyze) as last_autoanalyze
 58 |   FROM pg_stat_all_tables s
 59 |   JOIN pg_class c ON c.oid = s.relid
 60 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 61 |  WHERE s.relname NOT LIKE 'pg_%'
 62 |    AND s.relname NOT LIKE 'sql_%'
 63 |    AND s.relname LIKE '%$TBL%'
 64 |   ORDER by 1, 2;"
 65 | else
 66 |   QRY="SELECT n.nspname as schema,
 67 |        s.relname as table,
 68 |        c.reltuples::bigint,
 69 |        n_live_tup,
 70 |        n_tup_ins,
 71 |        n_tup_upd,
 72 |        n_tup_del,
 73 |        date_trunc('second', last_vacuum) as last_vacuum,
 74 |        date_trunc('second', last_autovacuum) as last_autovacuum,
 75 |        date_trunc('second', last_analyze) as last_analyze,
 76 |        date_trunc('second', last_autoanalyze) as last_autoanalyze
 77 |   FROM pg_stat_all_tables s
 78 |   JOIN pg_class c ON c.oid = s.relid
 79 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 80 |  WHERE s.relname NOT LIKE 'pg_%'
 81 |    AND s.relname NOT LIKE 'sql_%'
 82 |    AND s.relname LIKE '%$TBL%'
 83 |   ORDER by 1, 2;"
 84 | fi
 85 | 
 86 | current_stats() {
 87 | STATLIST=$(psql -q $PORT $USER $DBNAME <<_QUERY_
 88 | 
 89 | ${QRY}
 90 | 
 91 | _QUERY_
 92 | 
 93 | )
 94 | 
 95 | }
 96 | 
 97 | current_stats
 98 | echo "${STATLIST}"
 99 | 
100 | exit 0
101 | 


--------------------------------------------------------------------------------
/dba_scripts/pg_vacuum_time.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Shows vacuum time for all or selected table.
 3 | 
 4 | PORT=""
 5 | USER=""
 6 | TBL=""
 7 | 
 8 | usage() {
 9 |     echo "Usage: $0 -d <dbname> [-t <table> -p <port> -U <user>]"
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:p:t:U:u" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME=$OPTARG
16 | 	 ;;
17 |       p) PORT="-p $OPTARG"
18 | 	 ;;
19 |       U) USER="-U $OPTARG"
20 | 	 ;;
21 |       t)  TBL="$OPTARG"
22 | 	 ;;
23 |       u) usage
24 | 	 ;;
25 |     [?]) usage
26 |    esac;
27 | done
28 | 
29 | 
30 | if [ "$DBNAME" = "" ]
31 |   then
32 |     usage
33 | fi
34 | 
35 | getver()
36 | {
37 | VER=$(psql $PORT -t $USER $DBNAME <<_QRYVER_
38 | SELECT version();
39 | _QRYVER_
40 | )
41 | }
42 | getver
43 | 
44 | VER=$(echo $VER | cut -c -16)
45 | echo "Version is $VER"
46 | 
47 | vacuum_time() {
48 | TIMEINFO=$(psql -q $PORT $USER $DBNAME <<_QUERY_
49 | 
50 | SELECT max(last_vacuum) - min(last_vacuum) as vacuum_time
51 |   FROM pg_stat_all_tables s
52 |  WHERE s.relname NOT LIKE 'pg_%'
53 |    AND s.relname NOT LIKE 'sql_%'
54 |    AND s.relname LIKE '%$TBL%'
55 |  ORDER by 1;
56 | 
57 | _QUERY_
58 | 
59 | )
60 | 
61 | }
62 | 
63 | vacuum_time
64 | echo "${TIMEINFO}"
65 | 
66 | exit 0
67 | 


--------------------------------------------------------------------------------
/dba_scripts/remove_ctrl.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | #!/bin/bash
 4 | 
 5 | OLDFILE=$1
 6 | 
 7 | usage() {
 8 |     echo "Usage: $0 oldfile"
 9 |     exit 1
10 | }
11 | 
12 | if [ -z "$OLDFILE" ]
13 |   then 
14 |     usage
15 |     exit 1
16 | fi
17 | 
18 | OLDFILE=$1
19 | NEWFILE=x$1
20 | 
21 | col -bp < $OLDFILE >> $NEWFILE
22 | chmod +x $NEWFILE
23 | rm $OLDFILE
24 | mv $NEWFILE $OLDFILE
25 | 


--------------------------------------------------------------------------------
/dba_scripts/role_members.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #Shows roles and members
 3 | 
 4 | PORT=""
 5 | USER="-U postgres"
 6 | DBNAME="postgres"
 7 | 
 8 | usage() {
 9 |     echo "Usage: $0 [-d <dbname> -U <user> -p <port>]"
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:p:uU:" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME=$OPTARG
16 | 	 ;;
17 |       p) PORT="-p $OPTARG"
18 | 	 ;;
19 |       U) USER="-U $OPTARG"
20 | 	 ;;
21 |       u) usage
22 | 	 ;;
23 |     [?]) usage
24 |    esac;
25 | done
26 | 
27 | getver()
28 | {
29 | VER=$(psql -t $PORT $USER $DBNAME <<_QRYVER_
30 | SELECT version();
31 | _QRYVER_
32 | )
33 | }
34 | 
35 | getver
36 | VER=$(echo $VER | cut -c -16)
37 | echo "Version is $VER"
38 | 
39 | show_members() {
40 | MEMBERS=$(psql -q $PORT $USER $DBNAME <<_QUERY_
41 | 
42 | SELECT a.rolname as role,
43 |        u.rolname as member,
44 |        CASE
45 | 	 WHEN m.admin_option THEN
46 | 	 'YES'
47 | 	 ELSE
48 | 	  'no'
49 |        END as admin
50 | FROM pg_auth_members m
51 | JOIN pg_authid a ON (a.oid = m.roleid)
52 | JOIN pg_authid u ON (u.oid = m.member)
53 | ORDER BY 1, 2
54 | 
55 | _QUERY_
56 | 
57 | )
58 | 
59 | }
60 | 
61 | show_members
62 | echo "${MEMBERS}"
63 | 
64 | exit 0
65 | 


--------------------------------------------------------------------------------
/dba_scripts/slony_status.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | PORT=""
 4 | 
 5 | usage() {
 6 |     echo "Usage: $0 [-p <port>]"
 7 |     exit 1
 8 | }
 9 | 
10 | while getopts "p:u" OPT;
11 | do case "${OPT}" in
12 |       p) PORT="-p $OPTARG"
13 | 	 ;;
14 |       u) usage
15 | 	 ;;
16 |     [?]) usage
17 |    esac;
18 | done
19 | 
20 | 
21 | getver()
22 | {
23 | VER=$(psql $PORT -t -U postgres postgres <<_QRYVER_
24 | SELECT version();
25 | _QRYVER_
26 | )
27 | }
28 | getver
29 | 
30 | VER=$(echo $VER | cut -c -16)
31 | echo "Version is $VER"
32 | 
33 | slony_status() {
34 | STATUS=$(psql $PORT -q <<_QUERY_
35 | 
36 | BEGIN;
37 | 
38 | SELECT st_origin as org,
39 |        st_last_event as last_event,
40 |        st_lag_num_events as lag_events,
41 |        st_lag_time
42 |   FROM _slony.sl_status;
43 | 
44 | COMMIT;
45 | 
46 | _QUERY_
47 | 
48 | )
49 | 
50 | }
51 | 
52 | slony_status
53 | echo "${STATUS}"
54 | 
55 | exit 0
56 | 


--------------------------------------------------------------------------------
/dba_scripts/table_column_stats.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Reports statistics for all tables
 3 | 
 4 | HOST=""
 5 | PORT=""
 6 | USER=""
 7 | TBL=""
 8 | 
 9 | usage() {
10 |     echo "Usage: $0 -d <dbname> -t <table> [-h <host> -U <user> -p <port>]"
11 |     exit 1
12 | }
13 | 
14 | while getopts "d:h:p:t:U:u" OPT;
15 | do case "${OPT}" in
16 |       d) DBNAME=$OPTARG
17 | 	 ;;
18 |       h) HOST="-h $OPTARG"
19 | 	 ;;
20 |       p) PORT="-p $OPTARG"
21 | 	 ;;
22 |       t) TBL=$OPTARG
23 | 	 ;;
24 |       U) USER="-U $OPTARG"
25 | 	 ;;
26 |       u) usage
27 | 	 ;;
28 |     [?]) usage
29 |    esac;
30 | done
31 | 
32 | if [ "$DBNAME" = "" ]
33 |   then
34 |     DBNAME="playmaker"
35 | fi
36 | 
37 | if [ "$TBL" = "" ]
38 |   then
39 |     usage
40 | fi
41 | 
42 | getver()
43 | {
44 | VER=$(psql -t $PORT $HOST $USER $DBNAME <<_QRYVER_
45 | SELECT version();
46 | _QRYVER_
47 | )
48 | }
49 | 
50 | getver
51 | 
52 | current_stats() {
53 | STATLIST=$(psql -q $HOST $PORT $USER $DBNAME <<_QUERY_
54 | 
55 | SELECT schemaname, 
56 |        tablename,
57 |        attname As colname,
58 |        n_distinct,
59 |        array_to_string(most_common_vals, E'\n') AS common_vals,
60 |        array_to_string(most_common_freqs, E'\n') As dist_freq
61 |   FROM pg_stats
62 |  WHERE tablename = '$TBL'
63 |  ORDER BY schemaname,
64 | 	  tablename,
65 | 	  attname;
66 | 
67 | _QUERY_
68 | 
69 | )
70 | 
71 | }
72 | 
73 | ##### MAIN #####
74 | echo "HOST=$HOST"
75 | echo "PORT=$PORT"
76 | echo "USER=$USER"
77 | echo "TBL=$TBL"
78 | echo "DBNAME=$DBNAME"
79 | 
80 | current_stats
81 | echo "${STATLIST}"
82 | 
83 | exit 0
84 | 


--------------------------------------------------------------------------------
/dba_scripts/table_comments.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | # Shows comments for all or specified table
  3 | 
  4 | USER=""
  5 | PORT=""
  6 | TBL=""
  7 | 
  8 | usage() {
  9 |     echo "Usage: $0 -d <dbname> [-t <table> -U <user> -p <port>]"
 10 |     exit 1
 11 | }
 12 | 
 13 | while getopts "d:t:p:uU:" OPT;
 14 | do case "${OPT}" in
 15 |       d) DBNAME=$OPTARG
 16 | 	 ;;
 17 |       p) PORT="-p $OPTARG"
 18 | 	 ;;
 19 |       t) TBL=$OPTARG
 20 | 	 ;;
 21 |       U) USER="-U $OPTARG"
 22 | 	 ;;
 23 |       u) usage
 24 | 	 ;;
 25 |     [?]) usage
 26 |    esac;
 27 | done
 28 | 
 29 | if [ "$DBNAME" = "" ]
 30 |   then
 31 |     usage
 32 | fi
 33 | 
 34 | getver()
 35 | {
 36 | VER=$(psql $PORT -t $USER $DBNAME <<_QRYVER_
 37 | SELECT version();
 38 | _QRYVER_
 39 | )
 40 | }
 41 | getver
 42 | 
 43 | VER=$(echo $VER | cut -c -16)
 44 | echo "Version is $VER"
 45 | 
 46 | QRY="SELECT DISTINCT ON (c.relname)
 47 |        n.nspname as schema,
 48 |        c.relname,
 49 |        a.rolname as owner,
 50 |        0 as col_seq,
 51 |        '' as column,
 52 |        d.description as comment
 53 |   FROM pg_class c
 54 | LEFT  JOIN pg_attribute col ON (col.attrelid = c.oid)
 55 | LEFT  JOIN pg_description d ON (d.objoid = col.attrelid AND d.objsubid = 0)
 56 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 57 |   JOIN pg_authid a ON ( a.OID = c.relowner )
 58 |   WHERE n.nspname NOT LIKE 'information%'
 59 |   AND relname NOT LIKE 'pg_%'
 60 |   AND relname NOT LIKE 'information%'
 61 |   AND relname NOT LIKE 'sql_%'
 62 |   AND relname LIKE '%$TBL%'
 63 |   AND relkind = 'r'
 64 | --  AND d.description IS NOT NULL
 65 | UNION
 66 | SELECT n.nspname as schema,
 67 |        c.relname,
 68 |        '' as owner,
 69 |        col.attnum as col_seq,
 70 |        col.attname as column,
 71 |        d.description
 72 |   FROM pg_class c
 73 |   JOIN pg_attribute col ON (col.attrelid = c.oid)
 74 |   LEFT JOIN pg_description d ON (d.objoid = col.attrelid AND d.objsubid = col.attnum)
 75 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 76 |   JOIN pg_authid a ON ( a.OID = c.relowner )
 77 | WHERE n.nspname NOT LIKE 'information%'
 78 |   AND relname NOT LIKE 'pg_%'
 79 |   AND relname NOT LIKE 'information%'
 80 |   AND relname NOT LIKE 'sql_%'
 81 |   AND relname LIKE '%$TBL%'
 82 |   AND relkind = 'r'
 83 | --  AND d.description IS NOT NULL
 84 |   AND col.attnum >= 0
 85 | ORDER BY 1, 2, 4;"
 86 | 
 87 | current_stats() {
 88 | STATLIST=$(psql $USER $PORT -q $DBNAME <<_QUERY_
 89 | 
 90 | ${QRY}
 91 | 
 92 | _QUERY_
 93 | 
 94 | )
 95 | 
 96 | }
 97 | 
 98 | current_stats
 99 | echo "${STATLIST}"
100 | 
101 | exit 0
102 | 


--------------------------------------------------------------------------------
/dba_scripts/table_dependents.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | USER=""
 4 | PORT=""
 5 | TBL=""
 6 | 
 7 | usage() {
 8 |     echo "Usage: $0 -d <dbname> [-t <table> -p <port> -U <user>]"
 9 |     exit 1
10 | }
11 | 
12 | while getopts "d:p:t:U:u" OPT;
13 | do case "${OPT}" in
14 |       d) DBNAME=$OPTARG
15 | 	 ;;
16 |       p) PORT="-p $OPTARG"
17 | 	 ;;
18 |       t) TBL=$OPTARG
19 | 	 ;;
20 |       U) USER="-U $OPTARG"
21 | 	 ;;
22 |       u) usage
23 | 	 ;;
24 |     [?]) usage
25 |    esac;
26 | done
27 | 
28 | 
29 | if [ "$DBNAME" = "" ]
30 |   then
31 |     usage
32 | fi
33 | 
34 | getver()
35 | {
36 | VER=$(psql $PORT -t $USER $DBNAME <<_QRYVER_
37 | SELECT version();
38 | _QRYVER_
39 | )
40 | }
41 | getver
42 | 
43 | VER=$(echo $VER | cut -c -16)
44 | echo "Version is $VER"
45 | 
46 | get_dependents() {
47 | DEPLIST=$(psql $PORT -q $USER $DBNAME <<_QUERY_
48 | 
49 | SELECT n.nspname as schema,
50 |        pa.relname as parent,
51 |        ch.relname as dependent,
52 |        cn.conname as constraint_name
53 |   FROM pg_constraint cn
54 |   JOIN pg_class pa ON (pa.oid = cn.confrelid)
55 |   JOIN pg_class ch ON (ch.oid = cn.conrelid)
56 |   JOIN pg_namespace n ON (n.oid = pa.relnamespace)
57 |  WHERE pa.relname LIKE '%$TBL%'
58 |    AND contype = 'f'
59 |  ORDER BY 1, 2, 3;
60 | 
61 | _QUERY_
62 | 
63 | )
64 | 
65 | }
66 | 
67 | get_dependents
68 | echo "${DEPLIST}"
69 | 
70 | exit 0
71 | 


--------------------------------------------------------------------------------
/dba_scripts/table_in_function.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Shows functions that specified table occurs in
 4 | 
 5 | USER=""
 6 | PORT=""
 7 | 
 8 | usage() {
 9 |     echo "Usage: $0 -d <dbname> -t <table> [-U <user> -p <port>]"
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:t:p:uU:" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME=$OPTARG
16 | 	 ;;
17 |       t) TBL=$OPTARG
18 | 	 ;;
19 |       p) PORT="-p $OPTARG"
20 | 	 ;;
21 |       U) USER="-U $OPTARG"
22 | 	 ;;
23 |       u) usage
24 | 	 ;;
25 |     [?]) usage
26 |    esac;
27 | done
28 | 
29 | if [ "$DBNAME" = "" ]
30 |   then
31 |     DBNAME="enf"
32 | fi
33 | 
34 | if [ "$TBL" = "" ]
35 |   then
36 |     usage
37 |     exit 1
38 | fi
39 | 
40 | echo "$TBL"
41 | 
42 | psql $USER $PORT $DBNAME <<_CODE_
43 | SELECT p.proname,
44 |        CASE WHEN p.proretset = TRUE
45 | 	    THEN 'SET OF '
46 | 	    ELSE ''
47 | 	END ||
48 |        UPPER( (SELECT typname
49 | 	  FROM pg_type
50 | 	 WHERE oid = p.prorettype) ) AS return_type,
51 |        proargnames as parameters
52 |   FROM pg_proc p
53 |  WHERE prosrc LIKE '%$TBL%'
54 |  ORDER BY p.proname;
55 | 
56 | _CODE_
57 | 
58 | exit 0
59 | 


--------------------------------------------------------------------------------
/dba_scripts/table_in_trigger.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Shows trigger functions that specified table occurs in
 4 | 
 5 | USER=""
 6 | PORT=""
 7 | 
 8 | usage() {
 9 |     echo "Usage: $0 -d <dbname> -t <table> [-U <user> -p <port>]"
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:t:p:uU:" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME=$OPTARG
16 | 	 ;;
17 |       t) TBL=$OPTARG
18 | 	 ;;
19 |       p) PORT="-p $OPTARG"
20 | 	 ;;
21 |       U) USER="-U $OPTARG"
22 | 	 ;;
23 |       u) usage
24 | 	 ;;
25 |     [?]) usage
26 |    esac;
27 | done
28 | 
29 | if [ "$DBNAME" = "" ]
30 |   then
31 |     DBNAME="enf"
32 | fi
33 | 
34 | if [ "$TBL" = "" ]
35 |   then
36 |     usage
37 |     exit 1
38 | fi
39 | 
40 | echo "$TBL"
41 | 
42 | psql $USER $PORT $DBNAME <<_CODE_
43 | SELECT c.relname,
44 |        t.tgname,
45 |        p.proname
46 |   FROM pg_proc p
47 |   JOIN pg_trigger t ON (t.tgfoid = p.oid)
48 |   JOIN pg_class c ON (c.oid = t.tgrelid)
49 |  WHERE prosrc LIKE ('%$TBL%')
50 |  ORDER BY c.relname;
51 | _CODE_
52 | 
53 | exit 0
54 | 


--------------------------------------------------------------------------------
/dba_scripts/table_sizes.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SHOWS TABLES AND SIZES FOR ALL TABLES
 4 | # SHOULD BE RUN AS SUPERUSER
 5 | 
 6 | PORT=""
 7 | USER=""
 8 | TBL=""
 9 | 
10 | usage() {
11 |     echo "Usage: $0 -d <dbname> [-t <table> -p <port> -U <user>]"
12 |     exit 1
13 | }
14 | 
15 | while getopts "d:p:t:U:u" OPT;
16 | do case "${OPT}" in
17 |       d) DBNAME=$OPTARG
18 | 	 ;;
19 |       p) PORT="-p $OPTARG"
20 | 	 ;;
21 |       t) TBL="$OPTARG"
22 | 	 ;;
23 |       U) USER="-U $OPTARG"
24 | 	 ;;
25 |       u) usage
26 | 	 ;;
27 |     [?]) usage
28 |    esac;
29 | done
30 | 
31 | 
32 | if [ "$DBNAME" = "" ]
33 |   then
34 |     usage
35 |     exit 1
36 | fi
37 | 
38 | psql $PORT $USER $DBNAME <<_CODE_
39 | 
40 | SELECT n.nspname as schema,
41 |        c.relname as table,
42 |        a.rolname as owner,
43 |        d.oid as directory,
44 |        c.relfilenode as filename,
45 |        c.reltuples::integer,
46 |        pg_size_pretty(pg_relation_size( quote_ident( n.nspname ) || '.' || quote_ident( c.relname ) )) as size,
47 |        pg_size_pretty(pg_relation_size( quote_ident( n.nspname ) || '.' || quote_ident( c.relname ) )  
48 |                    +  pg_relation_size(   i.indexrelid   ) ) as total_size,
49 |        pg_relation_size( quote_ident( n.nspname ) || '.' || quote_ident( c.relname ) ) as size_bytes,
50 |        pg_total_relation_size( quote_ident( n.nspname ) || '.' || quote_ident( c.relname ) ) as total_size_bytes,
51 |        CASE WHEN c.reltablespace = 0
52 | 	    THEN 'pg_default'
53 | 	    ELSE (SELECT t.spcname
54 | 		    FROM pg_tablespace t WHERE (t.oid = c.reltablespace) )
55 | 	END as tablespace
56 |   FROM pg_class c
57 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
58 |   JOIN pg_index i  ON (i.indrelid = c.oid ) 
59 |   JOIN pg_authid a ON ( a.oid = c.relowner ),
60 |        pg_database d
61 | WHERE d.datname = current_database()
62 |   AND relname NOT LIKE 'pg_%'
63 |   AND relname NOT LIKE 'information%'
64 |   AND relname NOT LIKE 'sql_%'
65 |   AND relname LIKE '%$TBL%'
66 |   AND relkind = 'r'
67 | ORDER BY 9 DESC, 1, 2;
68 | 
69 | _CODE_
70 | 


--------------------------------------------------------------------------------
/dba_scripts/tables_and_owners.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SHOWS TABLES AND OWNERS FOR ALL TABLES
 4 | # SHOULD BE RUN AS SUPERUSER
 5 | 
 6 | PORT=""
 7 | USER="-U postgres"
 8 | usage() {
 9 |     echo "Usage: $0 -d <dbname> [-U <user> -p <port>]"
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:p:uU:" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME=$OPTARG
16 | 	 ;;
17 |       p) PORT="-p $OPTARG"
18 | 	 ;;
19 |       U) USER="-U $OPTARG"
20 | 	 ;;
21 |       u) usage
22 | 	 ;;
23 |     [?]) usage
24 |    esac;
25 | done
26 | 
27 | 
28 | if [ "$DBNAME" = "" ]
29 |   then
30 |     usage
31 | fi
32 | 
33 | psql $PORT $USER $DBNAME <<_CODE_
34 | SELECT n.nspname as schema,
35 |        c.relname as table,
36 |        a.rolname as owner,
37 |        c.relacl as permits
38 |   FROM pg_class c
39 |   JOIN pg_namespace n ON ( n.oid = c.relnamespace )
40 |   JOIN pg_authid a ON ( a.OID = c.relowner )
41 | WHERE relname NOT LIKE 'pg_%'
42 |   AND relname NOT LIKE 'information%'
43 |   AND relname NOT LIKE 'sql_%'
44 |   AND relkind = 'r'
45 | --  AND position('useradmin' in ARRAY_TO_STRING(c.relacl, '') )> 0
46 | ORDER BY n.nspname, 
47 |          c.relname;
48 | 
49 | _CODE_
50 | 


--------------------------------------------------------------------------------
/dba_scripts/tables_filenames.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SHOWS TABLES AND SIZES FOR ALL TABLES
 4 | # SHOULD BE RUN AS postgres user
 5 | 
 6 | PORT=""
 7 | USER=""
 8 | 
 9 | usage() {
10 |     echo "Usage: $0 -d <dbname> [-p <port> -U <user>]"
11 |     exit 1
12 | }
13 | 
14 | while getopts "d:p:U:u" OPT;
15 | do case "${OPT}" in
16 |       d) DBNAME=$OPTARG
17 | 	 ;;
18 |       p) PORT="-p $OPTARG"
19 | 	 ;;
20 |       U) USER="-U $OPTARG"
21 | 	 ;;
22 |       u) usage
23 | 	 ;;
24 |     [?]) usage
25 |    esac;
26 | done
27 | 
28 | 
29 | if [ "$DBNAME" = "" ]
30 |   then
31 |     usage
32 | fi
33 | 
34 | psql $PORT $USER $DBNAME <<_CODE_
35 | 
36 | SELECT n.nspname as schema,
37 |        c.relname as table,
38 | --       c.relkind,
39 |        a.rolname as owner,
40 |        d.oid as directory,
41 |        c.relfilenode as filename,
42 |        pg_size_pretty(pg_relation_size( quote_ident(n.nspname ) || '.' || quote_ident( c.relname ) )) as size
43 |   FROM pg_class c
44 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
45 |   JOIN pg_authid a ON ( a.oid = c.relowner ),
46 |        pg_database d  
47 | WHERE d.datname = current_database()
48 |   AND relname NOT LIKE 'pg_%' 
49 |   AND relname NOT LIKE 'information%' 
50 |   AND relname NOT LIKE 'sql_%' 
51 |   AND relkind = 'r'
52 | --  AND relkind IN ('i', 'r')
53 | ORDER BY 1, 2;
54 | 
55 | _CODE_
56 | 


--------------------------------------------------------------------------------
/dba_scripts/tables_with_FKs.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SHOWS FOREIGN KEY COUNT FOR EACH TABLE
 4 | # THEN SHOWS FOREIGN KEYS FOR EACH TABLE
 5 | 
 6 | PORT=""
 7 | USER=""
 8 | 
 9 | usage() {
10 |     echo "Usage: $0 -d <dbname> [-U <user> -p <port>]"
11 |     exit 1
12 | }
13 | 
14 | while getopts "d:p:uU:" OPT;
15 | do case "${OPT}" in
16 |       d) DBNAME=$OPTARG
17 | 	 ;;
18 |       p) PORT="-p $OPTARG"
19 | 	 ;;
20 |       U) USER="-U $OPTARG"
21 | 	 ;;
22 |       u) usage
23 | 	 ;;
24 |     [?]) usage
25 |    esac;
26 | done
27 | 
28 | if [ "$DBNAME" = "" ]
29 |   then
30 |     usage
31 | fi
32 | 
33 | psql $PORT $USER $DBNAME <<_CODE_
34 | 
35 | SELECT n.nspname as schema,
36 |        t.relname as table,
37 |        count(c.conname)
38 |   FROM pg_class t
39 |   JOIN pg_constraint c ON ( c.conrelid = t.OID AND c.contype = 'f')
40 |   JOIN pg_namespace n ON (n.oid = t.relnamespace)
41 |  WHERE relkind = 'r'
42 |    AND t.relname NOT LIKE 'pg_%'
43 |    AND t.relname NOT LIKE 'sql_%'
44 |    GROUP BY 1, 2
45 |    ORDER BY 1, 3;
46 | 
47 | SELECT n.nspname as schema,
48 |        t.relname as table,
49 |        c.conname as fk_name
50 |   FROM pg_class t
51 |   JOIN pg_constraint c ON ( c.conrelid = t.OID AND c.contype = 'f')
52 |   JOIN pg_namespace n ON (n.oid = t.relnamespace)
53 |  WHERE relkind = 'r'
54 |    AND t.relname NOT LIKE 'pg_%'
55 |    AND t.relname NOT LIKE 'sql_%'
56 |    ORDER BY 1, 2, 3;
57 | 
58 | _CODE_
59 | 


--------------------------------------------------------------------------------
/dba_scripts/tables_with_column_name.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SHOWS ALL TABLES WITH A COLUMN NAME LIKE <ColumnName>
 4 | 
 5 | USER=""
 6 | PORT=""
 7 | 
 8 | usage() {
 9 |     echo "Usage: $0 -d <dbname> -c <colname> [-U <user> -p <port>]"
10 |     exit 1
11 | }
12 | 
13 | while getopts "d:c:p:uU:" OPT;
14 | do case "${OPT}" in
15 |       d) DBNAME=$OPTARG
16 | 	 ;;
17 |       p) PORT="-p $OPTARG"
18 | 	 ;;
19 |       c) COLNAME="$OPTARG"
20 | 	 ;;
21 |       U) USER="-U $OPTARG"
22 | 	 ;;
23 |       u) usage
24 | 	 ;;
25 |     [?]) usage
26 |    esac;
27 | done
28 | 
29 | echo "col=$COLNAME"
30 | if [ "$DBNAME" = "" ]
31 |   then
32 |     DBNAME="enf"
33 | fi
34 | 
35 | if [ "$COLNAME" = "" ]
36 |   then
37 |     usage
38 |     exit 1
39 | fi
40 | 
41 | psql -a $USER $PORT $DBNAME <<_CODE_
42 | 
43 | SELECt c.table_schema as schema,
44 |        c.table_name as table,
45 |        c.column_name as column,
46 |        c.data_type as type,
47 |        case when c.data_type LIKE '%char%'
48 | 	      then COALESCE(character_maximum_length::text, 'N/A')
49 | 	    when c.data_type LIKE '%numeric%'
50 | 	      then  '(' || c.numeric_precision::text || ', ' || c.numeric_scale::text || ')'
51 | 	    when c.data_type LIKE '%int%'
52 | 	      then  c.numeric_precision::text
53 | 	    else COALESCE(character_maximum_length::text, 'N/A')
54 |        end as size
55 |   FROM information_schema.columns c
56 |  WHERE c.table_schema NOT LIKE 'pg_%'
57 |    AND c.table_schema NOT LIKE 'information%'
58 |    AND c.table_name NOT LIKE 'sql_%'
59 |    AND c.column_name LIKE '%$COLNAME%'
60 |    AND c.is_updatable = 'YES'
61 | ORDER BY c.table_name, c.column_name;
62 | 
63 | _CODE_
64 | 
65 | exit 0
66 | 


--------------------------------------------------------------------------------
/dba_scripts/tables_with_no_public_grants.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # SHOWS TABLES AND OWNERS FOR ALL TABLES
 4 | # That have no public grants
 5 | # SHOULD BE RUN AS SUPERUSER
 6 | 
 7 | USER="-U postgres"
 8 | PORT=""
 9 | 
10 | usage() {
11 |     echo "Usage: $0 -d <dbname> [-U <user> -p <port>]"
12 |     exit 1
13 | }
14 | 
15 | while getopts "d:p:uU:" OPT;
16 | do case "${OPT}" in
17 |       d) DBNAME=$OPTARG
18 | 	 ;;
19 |       p) PORT="-p $OPTARG"
20 | 	 ;;
21 |       U) USER="-U $OPTARG"
22 | 	 ;;
23 |       u) usage
24 | 	 ;;
25 |     [?]) usage
26 |    esac;
27 | done
28 | 
29 | if [ "$DBNAME" = "" ]
30 |   then
31 |     usage
32 | fi
33 | 
34 | psql $PORT $USER $DBNAME <<_CODE_
35 | SELECT n.nspname as schema,
36 |        c.relname,
37 |        a.rolname as owner,
38 |        array_to_string(ARRAY[c.relacl], '|') as permits
39 |   FROM pg_class c
40 |   JOIN pg_authid a ON (a.OID = c.relowner)
41 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
42 | WHERE relkind = 'r'
43 |   AND relname NOT LIKE 'pg_%'
44 |   AND relname NOT LIKE 'information%'
45 |   AND relname NOT LIKE 'sql_%'
46 |   AND position('|=' in array_to_string(ARRAY[relacl], '|')) = 0
47 | ORDER BY 1, 2;
48 | 
49 | _CODE_
50 | 


--------------------------------------------------------------------------------
/dba_scripts/tablespace_use.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | # Shows tablespace use for all or selected table
  3 | # that are not in default tablespace
  4 | 
  5 | PORT=""
  6 | USER=""
  7 | TBL="%"
  8 | 
  9 | usage() {
 10 |     echo "Usage: $0 -d <dbname> [-t <table> -U <user> -p <port>]"
 11 |     exit 1
 12 | }
 13 | 
 14 | while getopts "d:t:p:uU:" OPT;
 15 | do case "${OPT}" in
 16 |       d) DBNAME=$OPTARG
 17 | 	 ;;
 18 |       p) PORT="-p $OPTARG"
 19 | 	 ;;
 20 |       t) TBL=$OPTARG
 21 | 	 ;;
 22 |       U) USER="-U $OPTARG"
 23 | 	 ;;
 24 |       u) usage
 25 | 	 ;;
 26 |     [?]) usage
 27 |    esac;
 28 | done
 29 | 
 30 | if [ "$DBNAME" = "" ]
 31 |   then
 32 |     usage
 33 |     exit 1
 34 | fi
 35 | 
 36 | getver()
 37 | {
 38 | VER=$(psql -t $USER $PORT $DBNAME <<_QRYVER_
 39 | SELECT version();
 40 | _QRYVER_
 41 | )
 42 | }
 43 | getver
 44 | 
 45 | VER=$(echo $VER | cut -c -16)
 46 | echo "Version is $VER"
 47 | 
 48 | gettstver()
 49 | {
 50 | TSTVER=$(psql  -q -t $HOST $PORT $USER $DBNAME <<_QRY_
 51 | SELECT CASE WHEN SUBSTRING(version() FROM 12 FOR 3) < '9.2'
 52 | 	    THEN 'oid'
 53 | 	    ELSE 'func'
 54 | 	END;
 55 | _QRY_
 56 | 
 57 | )
 58 | 
 59 | TSTVER=${TSTVER:1:4}
 60 | 
 61 | }
 62 | 
 63 | gettstver
 64 | 
 65 | if [ "${TSTVER}" = "oid" ]
 66 |   then
 67 |     TSL="t.spclocation"
 68 |   else
 69 |     TSL="pg_tablespace_location(t.oid)"
 70 | fi
 71 | 
 72 | tspace_use() {
 73 | TSPACELIST=$(psql -q $USER $PORT $DBNAME <<_QUERY_
 74 | 
 75 | SELECT CASE WHEN t.spcname IS NULL
 76 | 	    THEN 'pg_default'
 77 | 	    ELSE t.spcname
 78 | 	END as tablespace,
 79 |        $TSL as location,
 80 |        n.nspname as schema,
 81 |        c.relname as relation,
 82 |        a.rolname as owner,
 83 |        c.relkind as type
 84 |   FROM pg_class c
 85 |   LEFT JOIN pg_tablespace t ON (t.oid = c.reltablespace)
 86 |   JOIN pg_authid a ON ( a.oid = c.relowner )
 87 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 88 |  WHERE relname LIKE '%$TBL%'
 89 |    AND relkind IN ('i', 'r')
 90 |    AND c.relname NOT LIKE 'pg_%'
 91 |    AND c.relname NOT LIKE 'sql_%'
 92 |  ORDER BY 1, 2;
 93 | 
 94 | _QUERY_
 95 | 
 96 | )
 97 | 
 98 | }
 99 | 
100 | tspace_use
101 | echo "${TSPACELIST}"
102 | 
103 | exit 0
104 | 


--------------------------------------------------------------------------------
/dba_scripts/triggers_and_constraints.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | 
  3 | PORT=""
  4 | USER=""
  5 | TBL="%"
  6 | CONSTR=""
  7 | 
  8 | # Shows trigger function on all or selected trigger
  9 | 
 10 | usage() {
 11 |     echo "Usage: $0 -d <dbname> [-U <user> -p <port> -t <trigger> -s ]"
 12 |     echo "dbname REQUIRED"
 13 |     echo "-s will show constraints"
 14 |     exit 1
 15 | }
 16 | 
 17 | getver()
 18 | {
 19 | VER=$(psql -t $PORT $USER $DBNAME <<_QRYVER_
 20 | SELECT version();
 21 | _QRYVER_
 22 | )
 23 | }
 24 | 
 25 | set_qry_noconstraints() {
 26 | 
 27 | QRY="SELECT c.relname AS table,
 28 | 	    t.tgname,
 29 | 	    p.proname	     AS function_called,
 30 | --	    t.tgisconstraint AS is_constraint,
 31 | 	    cn.conname	 AS constraint_nm,
 32 | 	    CASE WHEN t.tgconstrrelid > 0
 33 | 		 THEN (SELECT relname
 34 | 			 FROM pg_class
 35 | 			WHERE oid = t.tgconstrrelid)
 36 | 		 ELSE ''
 37 | 	     END	     AS constr_tbl
 38 |        FROM pg_trigger t
 39 |        INNER JOIN pg_proc p  ON ( p.oid = t.tgfoid)
 40 |        INNER JOIN pg_class c ON ( c.oid = t.tgrelid)
 41 | 	LEFT JOIN pg_constraint cn ON ( cn.oid = t.tgconstraint )
 42 |       WHERE tgname NOT LIKE 'pg_%'
 43 | 	AND tgname NOT LIKE 'RI_%'  -- < comment out to see constraints
 44 | 	AND tgname LIKE '%$TRG%'
 45 |       ORDER BY 1;"
 46 | 
 47 | }
 48 | 
 49 | set_qry_constraints() {
 50 | 
 51 | QRY="SELECT c.relname	     AS table,
 52 | 	    t.tgname,
 53 | 	    p.proname	     AS function_called,
 54 | --	    t.tgisconstraint AS is_constraint,
 55 | 	    cn.conname	 AS constraint_nm,
 56 | 	    CASE WHEN t.tgconstrrelid > 0
 57 | 		 THEN (SELECT relname
 58 | 			 FROM pg_class
 59 | 			WHERE oid = t.tgconstrrelid)
 60 | 		 ELSE ''
 61 | 	     END	     AS constr_tbl
 62 |        FROM pg_trigger t
 63 |        INNER JOIN pg_proc p  ON ( p.oid = t.tgfoid)
 64 |        INNER JOIN pg_class c ON ( c.oid = t.tgrelid)
 65 | 	LEFT JOIN pg_constraint cn ON ( cn.oid = t.tgconstraint )
 66 |       WHERE tgname NOT LIKE 'pg_%'
 67 | 	AND tgname LIKE '%$TRG%'
 68 |       ORDER BY 1;"
 69 | 
 70 | }
 71 | 
 72 | 
 73 | list_triggers() {
 74 | LIST=$(psql -q $PORT $USER $DBNAME <<_QUERY_
 75 | 
 76 | $QRY
 77 | 
 78 | _QUERY_
 79 | 
 80 | )
 81 | 
 82 | }
 83 | 
 84 | ###########################################################
 85 | #			 MAIN				  #
 86 | ###########################################################
 87 | 
 88 | while getopts "d:p:st:uU:" OPT;
 89 | do case "${OPT}" in
 90 |       d) DBNAME=$OPTARG
 91 | 	 ;;
 92 |       p) PORT="-p $OPTARG"
 93 | 	 ;;
 94 |       s) CONSTR="TRUE"
 95 | 	 ;;
 96 |       t) TRG="$OPTARG"
 97 | 	 ;;
 98 |       U) USER="-U $OPTARG"
 99 | 	 ;;
100 |       u) usage
101 | 	 ;;
102 |     [?]) usage
103 |    esac;
104 | done
105 | 
106 | if [ "$DBNAME" = "" ]
107 |   then
108 |     usage
109 | fi
110 | 
111 | getver
112 | VER=$(echo $VER | cut -c -16)
113 | echo "Version is $VER"
114 | 
115 | if [ "$CONSTR" = "TRUE" ]
116 |   then
117 |     set_qry_constraints
118 |   else
119 |     set_qry_noconstraints
120 | fi
121 | 
122 | list_triggers
123 | echo "${LIST}"
124 | 
125 | exit 0
126 | 


--------------------------------------------------------------------------------
/dba_scripts/user_table_access.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Shows Tables access for user specified
 4 | # SHOULD BE RUN AS SUPERUSER
 5 | 
 6 | USER=""
 7 | PORT=""
 8 | 
 9 | usage() {
10 |     echo "Usage: $0 -d <dbname> -a <user2check> [-U <user> -p <port>]"
11 |     exit 1
12 | }
13 | 
14 | while getopts "d:a:p:uU:" OPT;
15 | do case "${OPT}" in
16 |       d) DBNAME=$OPTARG
17 | 	 ;;
18 |       a) CKUSER=$OPTARG
19 | 	 ;;
20 |       p) PORT="-p $OPTARG"
21 | 	 ;;
22 |       U) USER="-U $OPTARG"
23 | 	 ;;
24 |       u) usage
25 | 	 ;;
26 |     [?]) usage
27 |    esac;
28 | done
29 | 
30 | if [ "$DBNAME" = "" ]
31 |   then
32 |     DBNAME="enf"
33 | fi
34 | 
35 | if [ "$CKUSER" = "" ]
36 |   then
37 |     usage
38 |     exit 1
39 | fi
40 | 
41 | psql $USER $PORT $DBNAME <<_CODE_
42 | SELECT n.nspname,
43 |        c.relname,
44 |        array_to_string(ARRAY[c.relacl], '|') as permits,
45 |        position('useradmin' in array_to_string(ARRAY[relacl], '|'))
46 |   FROM pg_class c
47 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
48 | WHERE n.nspname not like 'pg_%'
49 |   AND n.nspname not like 'inform_%'
50 |   AND relkind = 'r'
51 |   AND (position('$CKUSER' in array_to_string(ARRAY[relacl], '|')) > 0
52 |   OR  position( (SELECT g.rolname
53 | 		 FROM pg_auth_members r
54 | 		 JOIN pg_authid g ON (r.roleid = g.oid)
55 | 		 JOIN pg_authid u ON (r.member = u.oid)
56 | 		  AND u.rolname LIKE '$CKUSER%') in array_to_string(ARRAY[relacl], '|')) > 0 )
57 | ORDER BY 1,2;
58 | 
59 | _CODE_
60 | 


--------------------------------------------------------------------------------
/dba_scripts/user_table_access_detail.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Shows table access detail for user specified
 4 | # SHOULD BE RUN AS SUPERUSER
 5 | 
 6 | USER=""
 7 | PORT=""
 8 | 
 9 | usage() {
10 |     echo "Usage: $0 -d <dbname> -a <user2check> [-U <user> -p <port>]"
11 |     exit 1
12 | }
13 | 
14 | while getopts "d:a:p:uU:" OPT;
15 | do case "${OPT}" in
16 |       d) DBNAME=$OPTARG
17 | 	 ;;
18 |       a) CKUSER=$OPTARG
19 | 	 ;;
20 |       p) PORT="-p $OPTARG"
21 | 	 ;;
22 |       U) USER="-U $OPTARG"
23 | 	 ;;
24 |       u) usage
25 | 	 ;;
26 |     [?]) usage
27 |    esac;
28 | done
29 | 
30 | if [ "$DBNAME" = "" ]
31 |   then
32 |     DBNAME="enf"
33 | fi
34 | 
35 | if [ "$CKUSER" = "" ]
36 |   then
37 |     usage
38 |     exit 1
39 | fi
40 | 
41 | psql $USER $PORT $DBNAME <<_CODE_
42 | SELECT n.nspname,
43 |        c.relname,
44 |        CASE WHEN has_table_privilege('$CKUSER', quote_ident(n.nspname) || '.' || quote_ident(c.relname), 'SELECT')
45 | 	    THEN 'YES'
46 | 	    ELSE 'no'
47 | 	END AS "SEL",
48 |        CASE WHEN has_table_privilege('$CKUSER', quote_ident(n.nspname) || '.' || quote_ident(c.relname), 'INSERT')
49 | 	    THEN 'YES'
50 | 	    ELSE 'no'
51 | 	END AS "INS",
52 |        CASE WHEN has_table_privilege('$CKUSER', quote_ident(n.nspname) || '.' || quote_ident(c.relname), 'UPDATE')
53 | 	    THEN 'YES'
54 | 	    ELSE 'no'
55 | 	END AS "UPD",
56 |        CASE WHEN has_table_privilege('$CKUSER', quote_ident(n.nspname) || '.' || quote_ident(c.relname), 'DELETE')
57 | 	    THEN 'YES'
58 | 	    ELSE 'no'
59 | 	END AS "DEL",
60 |        array_to_string(ARRAY[c.relacl], '|') as permits
61 |   FROM pg_class c
62 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
63 | WHERE n.nspname not like 'pg_%'
64 |   AND n.nspname not like 'inform_%'
65 |   AND relkind = 'r'
66 | /*
67 |   AND (position('$CKUSER' in array_to_string(ARRAY[relacl], '|')) > 0
68 |   OR  position( (SELECT g.rolname
69 | 		 FROM pg_auth_members r
70 | 		 JOIN pg_authid g ON (r.roleid = g.oid)
71 | 		 JOIN pg_authid u ON (r.member = u.oid)
72 | 		  AND u.rolname LIKE '$CKUSER%') in array_to_string(ARRAY[relacl], '|')) > 0 )
73 | */
74 | ORDER BY 1,2;
75 | 
76 | _CODE_
77 | 


--------------------------------------------------------------------------------
/queries/ALL_COLUMNS.sql:
--------------------------------------------------------------------------------
 1 | SELECT c.table_schema,
 2 |        c.table_name as table,
 3 |        c.ordinal_position as order,
 4 |        c.column_name as column,
 5 | --	 c.data_type as type,
 6 |        CASE WHEN c.data_type IN ('character', 'varchar') THEN c.data_type || '(' || c.character_maximum_length || ')'
 7 | 	    WHEN c.data_type IN ('numeric')		 THEN c.data_type || '(' || c.numeric_precision || ',' || c.numeric_scale || ')'
 8 | 	    ELSE c.data_type
 9 |        END,
10 | --	 c.character_maximum_length as max_len,
11 |        c.is_nullable as null,
12 |        col_description(t.oid, c.ordinal_position)
13 |   FROM information_schema.columns c
14 |   JOIN pg_class t ON (t.relname = c.table_name)
15 |  WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
16 | ORDER BY 1, 2, 3;
17 | 
18 | 


--------------------------------------------------------------------------------
/queries/ALL_CONSTRAINTS.sql:
--------------------------------------------------------------------------------
1 | SELECT table_schema,
2 |        table_name,
3 |        constraint_name as constraint,
4 |        constraint_type as type
5 |   FROM information_schema.table_constraints
6 |  WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
7 | ORDER BY 1, 2;
8 | 


--------------------------------------------------------------------------------
/queries/ALL_TABLES.sql:
--------------------------------------------------------------------------------
1 | SELECT table_schema as schema, 
2 |        table_name as table
3 |   FROM information_schema.tables
4 |  WHERE table_type = 'BASE TABLE'
5 |    AND table_schema NOT IN ('pg_catalog', 'information_schema')
6 | ORDER BY 1, 2;
7 | 


--------------------------------------------------------------------------------
/queries/README.txt:
--------------------------------------------------------------------------------
 1 | These are generic SQL queries. In some cases you need to replace variable holders -> <VARIABLE>
 2 | with the actual value you need.
 3 | 
 4 | ALL_COLUMNS.sql -> Lists all tables, their columns and data type
 5 | ALL_CONSTRAINTS.sql -> lists all tables and their associated constraints
 6 | ALL_TABLES.sql -> lists all tables
 7 | bad_idx.sql -> lists all indexes flagged as invalid
 8 | blocked_transaction.sql -> shows all blocked queries and transaction causing block
 9 | cache_hit_ratio.sql -> shows cache hit ratio for all databases
10 | cancel_all_queries.sql -> cancels all tranactions for specified <user_name>
11 | check_fks.sql -> shows fk status for all tables > 9mb in size or greater than 1000 writes
12 | column_name_type_difference.sql -> shows all tables and columns that have same column name but different data type
13 | columns_of_type_x.sql -> shows all tables that have columns of type <TYPE>
14 | connection_counts.sql -> shows connection totals and totals for users, database and user/database
15 | current_locks.sql -> shows current_locks
16 | current_queries_blocked.sql -> shows blocked transactions and blocking query
17 | current_queries.sql -> shows all current_queries
18 | database_info.sql -> shows information from pg_database
19 | database_sizes.sql -> shows size of all databases and percentage of total size
20 | distinct_data_types.sql -> shows all data types in use in cluster
21 | enum_maint.sql -> generic query to show all enums and commented delete / add code
22 | enums.sql -> generic query to show all enums
23 | filenames_and_tables.sql -> shows physical filenames for all tables
24 | gen_create_indexes.sql -> generates sql statements to recreate all indexes
25 | gen_drop_indexes.sql -> generates sql statements to drop all indexes
26 | gen_get_seq_max.sql -> generates sql to get the max value of all sequences
27 | gen_revoke_all.sql -> generates sql to revoke all priviliges from all tables for user <some_user>
28 | gen_table_compare_counts.sql -> generates sql to compare reltuples to actual row count for all tables
29 | get_slony_schemas.sql -> shows all slony schemas
30 | get_trans_min_cnt.sql -> shows trandaction count per minute in cluster
31 | groups_users.sql -> shows all groups and assigned users
32 | inactive_tables.sql -> shows all tables that have 0 fetch's & 0 read's
33 | index_bloat.sql -> shows size of index vs. table
34 | index_bloat2.sql > a more specific version of index bloat WHERE realbloat > 50 and wastedbytes > 50000000  (adjust to your requirements)
35 | index_comments.sql -> shows comments for all indexes
36 | index_sizes.sql -> show the size of all indexes
37 | index_tablespaces.sql -> shows the tablespace indexes are using
38 | make_alter_index_spc.sql -> generates sql to alter all indexes in public to <new_table_space>
39 | make_alter_table_spc.sql -> generates sql to alter all tables in public to <new_table_space>
40 | most_active_tables.sql -> sorts and lists all tables in descending order by tuples read
41 | parent_and_children.sql -> lists all tables and associated children
42 | pg_runtime.sql -> lists start and run time for cluster
43 | pg_stat_all_indexes.sql -> lists stats and status for all indexes
44 | pg_stat_all_tables.sql -> lists stats and vacuum info for all tables
45 | remove_ctrl.sh -> removes control characters from queries (used if query written in windows)
46 | role_members.sql -> lists all roles and their members
47 | rules.sql -> lists all tables and associated rules
48 | sequence_cols.sql -> lists all tables with sequence columns
49 | show_dead_tuples.sql -> shows table stats and status of dead tuples
50 | table_access.sql -> lists all tables and their acl
51 | table_columns.sql -> lists all columns for specified <table>
52 | table_comments.sql -> lists comments for all tables and columns
53 | table_constraints.sql -> lists all constraints for all tables
54 | table_dependents.sql -> lists all tables, children and related constraint name
55 | table_grants.sql -> lists all tables and their grants
56 | table_in_function.sql -> list all functions that reference <TABLE/COLUMN>
57 | table_in_schema.sql -> lists all tables in <schema_name>
58 | table_in_trigger.sql -> lists all triggers that reference <table>
59 | table_row_counts.sql -> lists all tables with greater than 0 rows
60 | tables_and_comments.sql -> lists only tables and columns with comments
61 | tables_and_filenames.sql -> lists all tables and physical filenames
62 | tables_and_owners.sql -> lists all tables, owners and permits
63 | tables_and_pkey.sql -> lists all tables and primary key name
64 | table_sizes.sql -> lists all tables, owner, physical filename, tuples, size, total size, size in bytes, total_size in bytes and tablespace
65 | table_stats.sql -> lists all tables and indexes, last vacuum, inserted, updated and deleted count
66 | tables_with_column_name.sql -> lists all tables with column name LIKE <COLUMN_NAME>
67 | tables_with_FKs.sql -> lists all tables that have foreign keys and FK name
68 | tables_with_large_index_size.sql -> lists all tables where index size > table size
69 | tables_with_no_FK.sql -> lists all tables that have no foreign key
70 | tables_with_no_pkey.sql -> lists all tables with no primary key
71 | tables_with_no_public_grants.sql -> lists all tables that have no public grants (Only owner has access)
72 | table_triggers.sql -> lists all tables with triggers, trigger name, trigger type and tgenabled value
73 | tcp_settings.sql -> lists the current tcp settings
74 | triggers_and_constraints.sql -> lists tables, their triggers and function called by the trigger
75 | useless_indexes.sql -> lists tables and associated indexes scanned < 200 times and are not unique indexes
76 | useless_indexes2.sql -> lists tables and associated indexes scanned < 200 times and are not unique indexes or primary keys
77 | users.sql -> lists all users/groups and if they are superuser or not
78 | user_table_access_detail.sql -> lists all table privileges for user <CKUSER>
79 | user_table_access.sql -> lists all tables, acl and position in acl for user <USERNAME>
80 | wasted_index_space.sql -> shows space wasted by unused indexes
81 | 
82 | 


--------------------------------------------------------------------------------
/queries/Tables_and_PKs.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname,
 2 |        t.relname as table, 
 3 |        c.conname as pk_name
 4 |   FROM pg_class t
 5 |   JOIN pg_constraint c ON ( c.conrelid = t.OID AND c.contype = 'p')
 6 |   JOIN pg_namespace n  ON (n.oid = t.relnamespace)
 7 |  WHERE relkind = 'r'
 8 |    AND t.relname NOT LIKE 'pg_%'
 9 |    AND t.relname NOT LIKE 'sql_%'
10 |    ORDER BY n.nspname, t.relname, c.conname;
11 | 


--------------------------------------------------------------------------------
/queries/Tables_with_FKs.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        t.relname as table, 
 3 |        count(c.conname)
 4 |   FROM pg_class t
 5 |   JOIN pg_namespace n ON n.oid = t.relnamespace
 6 |   JOIN pg_constraint c ON ( c.conrelid = t.OID AND c.contype = 'f')
 7 |  WHERE relkind = 'r'
 8 |    AND t.relname NOT LIKE 'pg_%'
 9 |    AND t.relname NOT LIKE 'sql_%'
10 |    GROUP BY n.nspname, 
11 |             t.relname
12 |    ORDER BY count, n.nspname, t.relname;
13 | 
14 | 
15 | SELECT n.nspname as schema, 
16 |        t.relname as table, 
17 |        c.conname as fk_name
18 |   FROM pg_class t
19 |   JOIN pg_namespace n ON n.oid = t.relnamespace
20 |   JOIN pg_constraint c ON ( c.conrelid = t.OID AND c.contype = 'f')
21 |  WHERE relkind = 'r'
22 |    AND t.relname NOT LIKE 'pg_%'
23 |    AND t.relname NOT LIKE 'sql_%'
24 |    ORDER BY n.nspname, 
25 |             t.relname, 
26 |             c.conname;


--------------------------------------------------------------------------------
/queries/Tables_with_no_FK.sql:
--------------------------------------------------------------------------------
 1 | SELECT relname as table
 2 |   FROM pg_class
 3 |  WHERE relkind = 'r'
 4 |    AND relname NOT LIKE 'pg_%'
 5 |    AND relname NOT LIKE 'sql_%'
 6 |    AND OID NOT IN 
 7 | (SELECT conrelid
 8 |    FROM pg_constraint
 9 |   WHERE contype = 'f'
10 |     AND contype <> 'p'
11 |     AND contype <> 'c')
12 |   ORDER BY relname;


--------------------------------------------------------------------------------
/queries/bad_idx.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname,
 2 |        i.relname,
 3 |        i.indexrelname,
 4 |        CASE WHEN idx.indisprimary
 5 | 	    THEN 'pkey'
 6 | 	    WHEN idx.indisunique
 7 | 	    THEN 'uidx'
 8 | 	    ELSE 'idx'
 9 | 	END AS type,
10 | 	'INVALID'
11 |   FROM pg_stat_all_indexes i
12 |   JOIN pg_class c     ON (c.oid = i.relid)
13 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
14 |   JOIN pg_index idx   ON (idx.indexrelid =  i.indexrelid )
15 |  WHERE idx.indisvalid = FALSE
16 |  ORDER BY 1, 2;
17 | 


--------------------------------------------------------------------------------
/queries/blocked_transactions.sql:
--------------------------------------------------------------------------------
 1 | /* Requires PostgreSQL version is 9.2 or Greater */
 2 | SELECT
 3 |  w.query as waiting_query,
 4 |  w.pid as w_pid,
 5 |  w.usename as w_user,
 6 |  l.query as locking_query,
 7 |  l.pid as l_pid,
 8 |  l.usename as l_user,
 9 |  t.schemaname || '.' || t.relname as tablename
10 |  FROM pg_stat_activity w
11 |  JOIN pg_locks l1 ON (w.pid = l1.pid and not l1.granted)
12 |  JOIN pg_locks l2 on (l1.relation = l2.relation and l2.granted)
13 |  JOIN pg_stat_activity l ON (l2.pid = l.pid)
14 |  JOIN pg_stat_user_tables t ON (l1.relation = t.relid)
15 |  WHERE w.waiting;
16 | 


--------------------------------------------------------------------------------
/queries/cache_hit_ratio.sql:
--------------------------------------------------------------------------------
 1 | SELECT pg_stat_database.datname,
 2 |        pg_stat_database.blks_read,
 3 |        pg_stat_database.blks_hit,
 4 |        round((pg_stat_database.blks_hit::double precision
 5 | 	      / (pg_stat_database.blks_read
 6 | 		 + pg_stat_database.blks_hit
 7 | 		 +1)::double precision * 100::double precision)::numeric, 2) AS cachehitratio
 8 |    FROM pg_stat_database
 9 |   WHERE pg_stat_database.datname !~ '^(template(0|1)|postgres)$'::text
10 |   ORDER BY round((pg_stat_database.blks_hit::double precision
11 | 		 / (pg_stat_database.blks_read
12 | 		    + pg_stat_database.blks_hit
13 | 		    + 1)::double precision * 100::double precision)::numeric, 2) DESC;
14 | 


--------------------------------------------------------------------------------
/queries/cancel_all_queries.sql:
--------------------------------------------------------------------------------
1 | SELECT pg_cancel_backend(procpid),
2 |        pg_terminate_backend(procpid)
3 | FROM pg_stat_activity
4 | WHERE usename = '<user_name>';
5 | 


--------------------------------------------------------------------------------
/queries/check_fks.sql:
--------------------------------------------------------------------------------
  1 | WITH fk_actions ( code, action ) AS (
  2 | VALUES ( 'a', 'error' ),
  3 | ( 'r', 'restrict' ),
  4 | ( 'c', 'cascade' ),
  5 | ( 'n', 'set null' ),
  6 | ( 'd', 'set default' )
  7 | ),
  8 | fk_list AS (
  9 | SELECT pg_constraint.oid as fkoid, conrelid, confrelid as parentid,
 10 | conname, relname, nspname,
 11 | fk_actions_update.action as update_action,
 12 | fk_actions_delete.action as delete_action,
 13 | conkey as key_cols
 14 | FROM pg_constraint
 15 | JOIN pg_class ON conrelid = pg_class.oid
 16 | JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid
 17 | JOIN fk_actions AS fk_actions_update ON confupdtype = fk_actions_update.code
 18 | JOIN fk_actions AS fk_actions_delete ON confdeltype = fk_actions_delete.code
 19 | WHERE contype = 'f'
 20 | ),
 21 | fk_attributes AS (
 22 | SELECT fkoid, conrelid, attname, attnum
 23 | FROM fk_list
 24 | JOIN pg_attribute
 25 | ON conrelid = attrelid
 26 | AND attnum = ANY( key_cols )
 27 | ORDER BY fkoid, attnum
 28 | ),
 29 | fk_cols_list AS (
 30 | SELECT fkoid, array_agg(attname) as cols_list
 31 | FROM fk_attributes
 32 | GROUP BY fkoid
 33 | ),
 34 | index_list AS (
 35 | SELECT indexrelid as indexid,
 36 | pg_class.relname as indexname,
 37 | indrelid,
 38 | indkey,
 39 | indpred is not null as has_predicate,
 40 | pg_get_indexdef(indexrelid) as indexdef
 41 | FROM pg_index
 42 | JOIN pg_class ON indexrelid = pg_class.oid
 43 | WHERE indisvalid
 44 | ),
 45 | fk_index_match AS (
 46 | SELECT fk_list.*,
 47 | indexid,
 48 | indexname,
 49 | indkey::int[] as indexatts,
 50 | has_predicate,
 51 | indexdef,
 52 | array_length(key_cols, 1) as fk_colcount,
 53 | array_length(indkey,1) as index_colcount,
 54 | round(pg_relation_size(conrelid)/(1024^2)::numeric) as table_mb,
 55 | cols_list
 56 | FROM fk_list
 57 | JOIN fk_cols_list USING (fkoid)
 58 | LEFT OUTER JOIN index_list
 59 | ON conrelid = indrelid
 60 | AND (indkey::int2[])[0:(array_length(key_cols,1) -1)] @> key_cols
 61 | ),
 62 | fk_perfect_match AS (
 63 | SELECT fkoid
 64 | FROM fk_index_match
 65 | WHERE (index_colcount - 1) <= fk_colcount
 66 | AND NOT has_predicate
 67 | AND indexdef LIKE '%USING btree%'
 68 | ),
 69 | fk_index_check AS (
 70 | SELECT 'no index' as issue, *, 1 as issue_sort
 71 | FROM fk_index_match
 72 | WHERE indexid IS NULL
 73 | UNION ALL
 74 | SELECT 'questionable index' as issue, *, 2
 75 | FROM fk_index_match
 76 | WHERE indexid IS NOT NULL
 77 | AND fkoid NOT IN (
 78 | SELECT fkoid
 79 | FROM fk_perfect_match)
 80 | ),
 81 | parent_table_stats AS (
 82 | SELECT fkoid, tabstats.relname as parent_name,
 83 | (n_tup_ins + n_tup_upd + n_tup_del + n_tup_hot_upd) as parent_writes,
 84 | round(pg_relation_size(parentid)/(1024^2)::numeric) as parent_mb
 85 | FROM pg_stat_user_tables AS tabstats
 86 | JOIN fk_list
 87 | ON relid = parentid
 88 | ),
 89 | fk_table_stats AS (
 90 | SELECT fkoid,
 91 | (n_tup_ins + n_tup_upd + n_tup_del + n_tup_hot_upd) as writes,
 92 | seq_scan as table_scans
 93 | FROM pg_stat_user_tables AS tabstats
 94 | JOIN fk_list
 95 | ON relid = conrelid
 96 | )
 97 | SELECT nspname as schema_name,
 98 | relname as table_name,
 99 | conname as fk_name,
100 | issue,
101 | table_mb,
102 | writes,
103 | table_scans,
104 | parent_name,
105 | parent_mb,
106 | parent_writes,
107 | cols_list,
108 | indexdef
109 | FROM fk_index_check
110 | JOIN parent_table_stats USING (fkoid)
111 | JOIN fk_table_stats USING (fkoid)
112 | /*WHERE table_mb > 9
113 | AND ( writes > 1000
114 | OR parent_writes > 1000
115 | OR parent_mb > 10 )
116 | */ORDER BY issue_sort, table_mb DESC, table_name, fk_name;
117 | 


--------------------------------------------------------------------------------
/queries/column_name_type_difference.sql:
--------------------------------------------------------------------------------
 1 | SELECT sa.nspname as schemaa,
 2 |        ca.relname as tablea,
 3 |        a.attname as columna, ta.typname,
 4 |        sb.nspname as schemab,
 5 |        cb.relname as tableb,
 6 |        a.attname as columnb, tb.typname
 7 |   FROM pg_attribute a
 8 |        JOIN pg_type ta ON (ta.oid = a.atttypid)
 9 |        JOIN pg_class ca ON (ca.oid = a.attrelid)
10 |        JOIN pg_catalog.pg_namespace sa ON (ca.relnamespace = sa.oid),
11 |        pg_attribute b
12 |        JOIN pg_type tb ON (tb.oid = b.atttypid)
13 |        JOIN pg_class cb ON (cb.oid = b.attrelid)
14 |        JOIN pg_catalog.pg_namespace sb ON (cb.relnamespace = sb.oid)
15 |  WHERE a.attname = b.attname
16 |    AND ta.typname <> tb.typname
17 |    AND ca.relname NOT LIKE 'pg_%'
18 |    AND ca.relname NOT LIKE 'information%'
19 |    AND ca.relname NOT LIKE 'sql_%'
20 |    AND ca.relkind = 'r'
21 |    AND cb.relname NOT LIKE 'pg_%'
22 |    AND cb.relname NOT LIKE 'information%'
23 |    AND cb.relname NOT LIKE 'sql_%'
24 |    AND cb.relkind = 'r'
25 |    AND 'rollback' NOT IN (sa.nspname, sb.nspname)
26 |    AND 'id' NOT IN (a.attname, b.attname);
27 | 


--------------------------------------------------------------------------------
/queries/columns_of_type_x.sql:
--------------------------------------------------------------------------------
 1 | --SELECT DISTINCT (c.data_type),
 2 | --	 COALESCE(character_maximum_length::text, 'N/A'),
 3 | --	 c.numeric_precision,
 4 | --	 c.numeric_scale
 5 | --  FROM information_schema.columns c;
 6 | 
 7 | SELECT c.table_schema as schema,
 8 |        c.table_name as table,
 9 |        c.column_name as column,
10 |        c.data_type as type,
11 |        case when c.data_type LIKE '%char%'
12 | 	      then COALESCE(character_maximum_length::text, 'N/A')
13 | 	    when c.data_type LIKE '%numeric%'
14 | 	      then  '(' || c.numeric_precision::text || ', ' || c.numeric_scale::text || ')'
15 | 	    when c.data_type LIKE '%int%'
16 | 	      then  c.numeric_precision::text
17 | 	 else COALESCE(character_maximum_length::text, 'N/A')
18 |        end as size
19 |   FROM information_schema.columns c
20 | WHERE c.table_schema NOT LIKE 'pg_%'
21 |   AND c.table_schema NOT LIKE 'information%'
22 |   AND c.table_name NOT LIKE 'sql_%'
23 |   AND c.data_type LIKE '%<TYPE>%'
24 |   AND c.is_updatable = 'YES'
25 | ORDER BY c.table_name, c.column_name;
26 | 
27 | 


--------------------------------------------------------------------------------
/queries/connection_counts.sql:
--------------------------------------------------------------------------------
 1 | SELECT COUNT(*)
 2 |   FROM pg_stat_activity;
 3 | 
 4 | SELECT usename,
 5 |        count(*)
 6 |  FROM pg_stat_activity
 7 | GROUP BY 1
 8 | ORDER BY 1;
 9 | 
10 | SELECT datname,
11 |        usename,
12 |        count(*)
13 |  FROM pg_stat_activity
14 | GROUP BY 1, 2
15 | ORDER BY 1, 2;
16 | 
17 | SELECT usename,
18 |        datname,
19 |        count(*)
20 |  FROM pg_stat_activity
21 | GROUP BY 1, 2
22 | ORDER BY 1, 2;
23 | 


--------------------------------------------------------------------------------
/queries/current_locks.sql:
--------------------------------------------------------------------------------
 1 | SELECT database,
 2 |        relation,
 3 |        n.nspname,
 4 |        c.relname,
 5 |        pid,
 6 |        a.usename,
 7 |        locktype,
 8 |        mode,
 9 |        granted,
10 |        tuple
11 |   FROM pg_locks l
12 |   JOIN pg_class c ON (c.oid = l.relation)
13 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
14 |   JOIN pg_stat_activity a ON (a.procpid = l.pid)
15 | ORDER BY database,
16 | 	 relation,
17 | 	 pid;
18 | 
19 | 


--------------------------------------------------------------------------------
/queries/current_queries.sql:
--------------------------------------------------------------------------------
 1 | SELECT a.datname,
 2 |        a.procpid as pid,
 3 |        CASE WHEN a.client_addr IS NULL
 4 |             THEN 'local'
 5 |             ELSE a.client_addr::text
 6 |        END as client_addr,
 7 |        a.usename as user,
 8 |        a.waiting,
 9 |        l.procpid as blocking_pid,
10 |        l.usename as blicking_user,
11 |        a.current_query,
12 |        a.query_start,
13 |        current_timestamp - a.query_start as duration 
14 |   FROM pg_stat_activity a
15 | LEFT  JOIN pg_locks l1 ON (a.procpid = l1.pid )
16 | LEFT  JOIN pg_locks l2 on (l1.relation = l2.relation )
17 | LEFT  JOIN pg_stat_activity l ON (l2.pid = l.procpid)
18 | LEFT  JOIN pg_stat_user_tables t ON (l1.relation = t.relid)
19 |  WHERE pg_backend_pid() <> a.procpid
20 | ORDER BY a.datname,
21 |          a.query_start;
22 | 
23 | 
24 | SELECT
25 |  w.current_query as waiting_query,
26 |  w.procpid as w_pid,
27 |  w.usename as w_user,
28 |  l.current_query as locking_query,
29 |  l.procpid as l_pid,
30 |  l.usename as l_user,
31 |  t.schemaname || '.' || t.relname as tablename
32 |  FROM pg_stat_activity w 
33 |  JOIN pg_locks l1 ON (w.procpid = l1.pid and not l1.granted)
34 |  JOIN pg_locks l2 on (l1.relation = l2.relation and l2.granted)
35 |  JOIN pg_stat_activity l ON (l2.pid = l.procpid)
36 |  JOIN pg_stat_user_tables t ON (l1.relation = t.relid)
37 |  WHERE w.waiting;
38 | SELECT datname,
39 |        procpid as pid,
40 |        client_addr,
41 |        usename as user,
42 |        current_query,
43 |        CASE WHEN waiting = TRUE
44 | 	    THEN 'BLOCKED'
45 | 	    ELSE 'no'
46 | 	END as waiting,
47 |        query_start,
48 |        current_timestamp - query_start as duration
49 |   FROM pg_stat_activity
50 |  WHERE pg_backend_pid() <> procpid
51 | ORDER BY datname,
52 | 	 query_start;
53 | 
54 | 


--------------------------------------------------------------------------------
/queries/current_queries_blocked.sql:
--------------------------------------------------------------------------------
 1 | /* Use for PostgreSQL 9.2 or greater */
 2 | SELECT c.datname,
 3 |        c.pid as pid,
 4 |        c.client_addr,
 5 |        c.usename as user,
 6 |        c.query,
 7 |        CASE WHEN c.waiting = TRUE
 8 | 	    THEN 'BLOCKED'
 9 | 	    ELSE 'no'
10 | 	END as waiting,
11 |        l.pid as blocked_by,
12 |        current_timestamp - c.query_start as duration
13 |   FROM pg_stat_activity c
14 |   LEFT JOIN pg_locks l1 ON (c.pid = l1.pid and not l1.granted)
15 |   LEFT JOIN pg_locks l2 on (l1.relation = l2.relation and l2.granted)
16 |   LEFT JOIN pg_stat_activity l ON (l2.pid = l.pid)
17 |   LEFT JOIN pg_stat_user_tables t ON (l1.relation = t.relid)
18 |  WHERE pg_backend_pid() <> c.pid
19 | ORDER BY datname,
20 | 	 query_start;
21 | 
22 | /* Use for PostgreSQL 9.1 or less */
23 | /*
24 | SELECT
25 |  w.current_query as waiting_query,
26 |  w.procpid as w_pid,
27 |  w.usename as w_user,
28 |  l.current_query as locking_query,
29 |  l.procpid as l_pid,
30 |  l.usename as l_user,
31 |  t.schemaname || '.' || t.relname as tablename
32 |  FROM pg_stat_activity w
33 |  JOIN pg_locks l1 ON (w.procpid = l1.pid and not l1.granted)
34 |  JOIN pg_locks l2 on (l1.relation = l2.relation and l2.granted)
35 |  JOIN pg_stat_activity l ON (l2.pid = l.procpid)
36 |  JOIN pg_stat_user_tables t ON (l1.relation = t.relid)
37 |  WHERE w.waiting;
38 | */
39 | 


--------------------------------------------------------------------------------
/queries/database_info.sql:
--------------------------------------------------------------------------------
 1 | SELECT db.datname,
 2 |        au.rolname as datdba,
 3 |        pg_encoding_to_char(db.encoding) as encoding,
 4 |        db.datallowconn,
 5 |        db.datconnlimit,
 6 |        db.datfrozenxid,
 7 |        tb.spcname as tblspc,
 8 | --	 db.datconfig,
 9 |        db.datacl
10 |   FROM pg_database db
11 |   JOIN pg_authid au ON au.oid = db.datdba
12 |   JOIN pg_tablespace tb ON tb.oid = db.dattablespace
13 |  ORDER BY 1;
14 | 


--------------------------------------------------------------------------------
/queries/database_sizes.sql:
--------------------------------------------------------------------------------
 1 | SELECT datname,
 2 |        pg_size_pretty(pg_database_size(datname))as size_pretty,
 3 |        pg_database_size(datname) as size,
 4 |        (SELECT pg_size_pretty (SUM( pg_database_size(datname))::bigint)
 5 | 	  FROM pg_database)  AS total,
 6 |        ((pg_database_size(datname) / (SELECT SUM( pg_database_size(datname))
 7 | 				       FROM pg_database) ) * 100)::numeric(6,3) AS pct
 8 |   FROM pg_database
 9 |   ORDER BY datname;
10 | 


--------------------------------------------------------------------------------
/queries/distinct_data_types.sql:
--------------------------------------------------------------------------------
 1 | 
 2 | SELECT DISTINCT t.typname
 3 |   FROM pg_class c
 4 |   JOIN pg_attribute a ON ( a.attrelid = c.oid )
 5 |   JOIN pg_type t ON (t.oid = a.atttypid)
 6 |   JOIN pg_catalog.pg_namespace s ON (c.relnamespace = s.oid)
 7 | WHERE c.relname NOT LIKE 'pg_%'
 8 |   AND c.relname NOT LIKE 'information%'
 9 |   AND c.relname NOT LIKE 'sql_%'
10 |   AND c.relkind = 'r'
11 | ORDER BY t.typname;
12 | 


--------------------------------------------------------------------------------
/queries/enum_maint.sql:
--------------------------------------------------------------------------------
 1 | SELECT t.typname,
 2 |        e.enumlabel,
 3 |        e.enumsortorder,
 4 |        e.enumtypid
 5 |   FROM pg_type t
 6 |   JOIN pg_enum e ON e.enumtypid = t.oid
 7 |  WHERE t.typtype = 'e'
 8 |  ORDER BY 1, enumsortorder; 
 9 | 
10 | --DELETE FROM pg_enum
11 | --WHERE enumtypid = 9999999
12 | --  AND enumsortorder = 4;
13 | 
14 | --DELETE FROM pg_enum
15 | --WHERE enumtypid = 9999999
16 | --  AND enumlabel = 'medium';
17 | 
18 | --ALTER TYPE some_enum ADD VALUE 'medium' AFTER 'small';
19 | 


--------------------------------------------------------------------------------
/queries/enums.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        t.typname as enum,
 3 |        e.enumsortorder as order,
 4 |        e.enumlabel as value,
 5 |        t.oid as oid
 6 |   FROM pg_type t
 7 |   JOIN pg_namespace n ON ( n.oid = t.typnamespace )
 8 |   JOIN pg_enum e ON ( e.enumtypid = t.oid )
 9 |  WHERE typtype = 'e'
10 |  ORDER BY 1, 2, 3;
11 | 
12 | 


--------------------------------------------------------------------------------
/queries/filenames_and_tables.sql:
--------------------------------------------------------------------------------
 1 | SELECT (SELECT oid 
 2 |           FROM pg_database 
 3 |          WHERE datname = current_database()) AS database,
 4 |        c.relfilenode as filename,
 5 |        n.nspname as schema,
 6 |        c.relname as table
 7 |   FROM pg_class c
 8 |   JOIN pg_namespace n ON ( n.oid = c.relnamespace )
 9 | WHERE relname NOT LIKE 'pg_%' AND
10 |       relname NOT LIKE 'information%' AND
11 |       relname NOT LIKE 'sql_%' AND
12 |       relkind = 'r' 
13 | ORDER BY relfilenode;
14 | 
15 | 


--------------------------------------------------------------------------------
/queries/gen_create_indexes.sql:
--------------------------------------------------------------------------------
 1 | SELECT pg_get_indexdef(idx.indexrelid) || ';'
 2 |   FROM pg_stat_all_indexes i
 3 |   JOIN pg_class c ON (c.oid = i.relid)
 4 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 5 |   JOIN pg_index idx ON (idx.indexrelid =  i.indexrelid )
 6 |  WHERE NOT idx.indisprimary
 7 |    AND NOT idx.indisunique
 8 |    AND i.relname NOT LIKE 'pg_%'
 9 |    AND i.idx_scan = 0
10 |    ORDER BY n.nspname,
11 | 	  i.relname;
12 | 


--------------------------------------------------------------------------------
/queries/gen_drop_indexes.sql:
--------------------------------------------------------------------------------
1 | SELECT 'DROP INDEX IF EXISTS "' || n.nspname || '"' || '.' || '"' || i.indexrelname || '"' ||';'
2 |   FROM pg_stat_all_indexes i
3 |   JOIN pg_class c ON (c.oid = i.relid)
4 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
5 |   JOIN pg_index idx ON (idx.indexrelid =  i.indexrelid )
6 |  WHERE NOT idx.indisprimary
7 |    AND i.relname NOT LIKE 'pg_%'
8 |  ORDER BY i.indexrelname;
9 | 


--------------------------------------------------------------------------------
/queries/gen_get_seq_max.sql:
--------------------------------------------------------------------------------
1 | SELECT 'SELECT ''' || relname || ''' ,
2 |        (SELECT max_value FROM ' || relname || ');'
3 |   FROM pg_class
4 |  WHERE relkind = 'S';
5 | 


--------------------------------------------------------------------------------
/queries/gen_revoke_all.sql:
--------------------------------------------------------------------------------
1 | SELECT 'REVOKE ALL PRIVILEGES FROM TABLE public."' || relname || '"  FROM <some_user>;'
2 |   FROM pg_class
3 | WHERE relname NOT LIKE 'pg_%' AND
4 | relname NOT LIKE 'information%' AND
5 | relname NOT LIKE 'sql_%' AND
6 | relkind = 'r'
7 | ORDER BY relname;
8 | 


--------------------------------------------------------------------------------
/queries/gen_table_compare_counts.sql:
--------------------------------------------------------------------------------
 1 | SELECT 'SELECT ''' ||
 2 |        c.relname || ''' as table, ' ||
 3 |        c.reltuples::int4 || ' as rows, ' ||
 4 |        '(SELECT COUNT(*) FROM ' || s.nspname || '."' || c.relname || '") as cnt;'
 5 |   FROM pg_catalog.pg_class c
 6 |   JOIN pg_catalog.pg_namespace s ON (c.relnamespace = s.oid)
 7 |  WHERE nspname = 'public'
 8 |    AND relkind = 'r'
 9 |  ORDER BY c.reltuples::int4 DESC;
10 | 
11 | 


--------------------------------------------------------------------------------
/queries/get_slony_schemas.sql:
--------------------------------------------------------------------------------
1 | SELECT nspname AS "Schema Name"
2 |   FROM pg_namespace nsp
3 |   JOIN pg_proc pro ON pronamespace=nsp.oid AND proname = 'slonyversion'
4 |  ORDER BY nspname;
5 | 


--------------------------------------------------------------------------------
/queries/get_trans_min_cnt.sql:
--------------------------------------------------------------------------------
 1 | BEGIN;
 2 | 
 3 | DROP TABLE IF EXISTS tmp_trans_stats;
 4 | 
 5 | CREATE TEMP TABLE tmp_trans_stats AS
 6 | SELECT 'start_cnt'::varchar(10) AS taken,
 7 |        SUM(xact_commit + xact_rollback) AS cnt
 8 |   FROM pg_stat_database;
 9 | 
10 | COMMIT;
11 | 
12 | SELECT pg_sleep(60);
13 | 
14 | INSERT INTO tmp_trans_stats
15 | SELECT 'end_cnt'::varchar(10) AS taken,
16 |        SUM(xact_commit + xact_rollback) AS cnt
17 |   FROM pg_stat_database;
18 | 
19 | SELECT (
20 | 	(SELECT cnt
21 | 	  FROM tmp_trans_stats
22 | 	 WHERE taken = 'end_cnt')
23 |      - (SELECT cnt
24 | 	  FROM tmp_trans_stats
25 | 	 WHERE taken = 'start_cnt')
26 |        ) as tot_trans;
27 | 
28 | 


--------------------------------------------------------------------------------
/queries/groups_users.sql:
--------------------------------------------------------------------------------
 1 | SELECT g.rolname as group,
 2 |        u.rolname as user,
 3 |        r.admin_option as admin,
 4 |        g.rolsuper as g_super,
 5 |        u.rolsuper as u_super
 6 |   FROM pg_auth_members r
 7 |   JOIN pg_authid g ON (r.roleid = g.oid)
 8 |   JOIN pg_authid u ON (r.member = u.oid)
 9 |   WHERE u.rolsuper = TRUE
10 |      OR g.rolsuper = TRUE
11 |   ORDER BY 1, 2;
12 | 
13 | 


--------------------------------------------------------------------------------
/queries/inactive_tables.sql:
--------------------------------------------------------------------------------
 1 | SELECT schemaname as schema,
 2 |        relname as table,
 3 |        idx_tup_fetch + seq_tup_read as TotalReads
 4 |  FROM pg_stat_all_tables
 5 | WHERE idx_tup_fetch + seq_tup_read = 0
 6 |   AND schemaname NOT IN  ('pg_catalog', 'pg_toast' )
 7 | order by schemaname,
 8 | 	 relname;
 9 | 
10 | 


--------------------------------------------------------------------------------
/queries/index_bloat.sql:
--------------------------------------------------------------------------------
 1 | SELECT N.nspname,
 2 |        T.relname AS "table",
 3 |        C.relname AS idx_name,
 4 |        round(100 * pg_relation_size(indexrelid) / pg_relation_size(indrelid) ) / 100 AS "index_ratio %",
 5 |        pg_size_pretty(pg_relation_size(indexrelid) ) AS index_size,
 6 |        pg_size_pretty(pg_relation_size(indrelid) )   AS table_size_size
 7 |   FROM pg_index I
 8 |   LEFT JOIN pg_class C ON (c.oid = I.indexrelid)
 9 |   LEFT JOIN pg_class T ON (T.oid = I.indrelid)
10 |   LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
11 |  WHERE nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
12 |    AND c.relkind = 'i'
13 |    AND pg_relation_size(indrelid) > 0
14 |  ORDER BY 4 desc, 1;
15 | 
16 | 


--------------------------------------------------------------------------------
/queries/index_bloat2.sql:
--------------------------------------------------------------------------------
  1 | WITH btree_index_atts AS (
  2 | SELECT nspname, 
  3 |        relname, 
  4 |        reltuples, 
  5 |        relpages, 
  6 |        indrelid, 
  7 |        relam,
  8 |        regexp_split_to_table(indkey::text, ' ')::smallint AS attnum,
  9 |        indexrelid as index_oid
 10 |   FROM pg_index
 11 |   JOIN pg_class ON pg_class.oid=pg_index.indexrelid
 12 |   JOIN pg_namespace ON pg_namespace.oid = pg_class.relnamespace
 13 |   JOIN pg_am ON pg_class.relam = pg_am.oid
 14 |   WHERE pg_am.amname = 'btree'
 15 | ),
 16 | index_item_sizes AS (
 17 | SELECT i.nspname, 
 18 |        i.relname, 
 19 |        i.reltuples, 
 20 |        i.relpages, 
 21 |        i.relam,
 22 |        s.starelid, 
 23 |        a.attrelid AS table_oid, 
 24 |        index_oid,
 25 |        current_setting('block_size')::numeric AS bs,
 26 |        /* MAXALIGN: 4 on 32bits, 8 on 64bits (and mingw32 ?) */
 27 |        CASE WHEN version() ~ 'mingw32' OR version() ~ '64-bit' 
 28 |             THEN 8
 29 |             ELSE 4
 30 |         END AS maxalign,
 31 |        24 AS pagehdr,
 32 |        /* per tuple header: add index_attribute_bm if some cols are null-able */
 33 |        CASE WHEN max(coalesce(s.stanullfrac,0)) = 0
 34 |             THEN 2
 35 |             ELSE 6
 36 |         END AS index_tuple_hdr,
 37 |        /* data len: we remove null values save space using it fractionnal part from stats */
 38 |        sum( (1-coalesce(s.stanullfrac, 0)) * coalesce(s.stawidth, 2048) ) AS nulldatawidth
 39 |   FROM pg_attribute AS a
 40 |   JOIN pg_statistic AS s ON s.starelid=a.attrelid AND s.staattnum = a.attnum
 41 |   JOIN btree_index_atts AS i ON i.indrelid = a.attrelid AND a.attnum = i.attnum
 42 |  WHERE a.attnum > 0
 43 |  GROUP BY 1, 2, 3, 4, 5, 6, 7, 8, 9
 44 | ),
 45 | index_aligned AS (
 46 | SELECT maxalign, 
 47 |        bs, 
 48 |        nspname, 
 49 |        relname AS index_name, 
 50 |        reltuples,
 51 |        relpages, 
 52 |        relam, 
 53 |        table_oid, 
 54 |        index_oid,
 55 |        ( 2 + maxalign - 
 56 |        /* Add padding to the index tuple header to align on MAXALIGN */
 57 |        CASE WHEN index_tuple_hdr%maxalign = 0 
 58 |             THEN maxalign
 59 |             ELSE index_tuple_hdr%maxalign
 60 |         END
 61 |         + nulldatawidth + maxalign - 
 62 |         /* Add padding to the data to align on MAXALIGN */
 63 |         CASE WHEN nulldatawidth::integer%maxalign = 0 
 64 |              THEN maxalign
 65 |              ELSE nulldatawidth::integer%maxalign
 66 |          END
 67 |        )::numeric AS nulldatahdrwidth, 
 68 |        pagehdr
 69 |   FROM index_item_sizes AS s1
 70 | ),
 71 | otta_calc AS 
 72 | (
 73 | SELECT bs, 
 74 |        nspname, 
 75 |        table_oid, 
 76 |        index_oid, 
 77 |        index_name, 
 78 |        relpages, 
 79 |        coalesce( ceil((reltuples*(4+nulldatahdrwidth))/(bs-pagehdr::float)) +
 80 |        CASE WHEN am.amname IN ('hash','btree') 
 81 |             THEN 1 
 82 |             ELSE 0 
 83 |         END , 
 84 |         0 -- btree and hash have a metadata reserved block
 85 |                ) AS otta
 86 |   FROM index_aligned AS s2
 87 |   LEFT JOIN pg_am am ON s2.relam = am.oid
 88 | ),
 89 | raw_bloat AS 
 90 | (
 91 | SELECT current_database() as dbname, 
 92 |        nspname, c.relname AS table_name, 
 93 |        index_name,
 94 |        bs*(sub.relpages)::bigint AS totalbytes,
 95 |        CASE WHEN sub.relpages <= otta 
 96 |             THEN 0
 97 |             ELSE bs*(sub.relpages-otta)::bigint 
 98 |         END AS wastedbytes,
 99 |        CASE WHEN sub.relpages <= otta
100 |             THEN 0 
101 |             ELSE bs*(sub.relpages-otta)::bigint * 100 / (bs*(sub.relpages)::bigint) 
102 |         END AS realbloat,
103 |         pg_relation_size(sub.table_oid) as table_bytes,
104 |         stat.idx_scan as index_scans
105 |    FROM otta_calc AS sub
106 |    JOIN pg_class AS c ON c.oid=sub.table_oid
107 |    JOIN pg_stat_user_indexes AS stat ON sub.index_oid = stat.indexrelid
108 | )
109 | SELECT dbname as database_name, 
110 |        nspname as schema_name, 
111 |        table_name, 
112 |        index_name,
113 |        round(realbloat, 1) as bloat_pct,
114 |        wastedbytes as bloat_bytes, 
115 |        pg_size_pretty(wastedbytes::bigint) as bloat_size,
116 |        totalbytes as index_bytes, 
117 |        pg_size_pretty(totalbytes::bigint) as index_size,
118 |        table_bytes, 
119 |        pg_size_pretty(table_bytes) as table_size,
120 |        index_scans
121 |   FROM raw_bloat
122 |  WHERE ( realbloat > 50 and wastedbytes > 50000000 )
123 |  ORDER BY wastedbytes DESC;
124 | 


--------------------------------------------------------------------------------
/queries/index_comments.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        c.relname,
 3 |        d.description as comment
 4 |        FROM pg_class c
 5 |       LEFT JOIN pg_description d ON (d.objoid = c.oid)
 6 |       JOIN pg_namespace n ON (n.oid = c.relnamespace)
 7 |      WHERE n.nspname NOT LIKE 'information%'
 8 |        AND relname NOT LIKE 'pg_%'
 9 |        AND relname NOT LIKE 'information%'
10 |        AND relname NOT LIKE 'sql_%'
11 | --	 AND relname LIKE '%IDX%'
12 |        AND relkind = 'i'
13 |        AND d.description IS NOT NULL
14 |      ORDER BY 2;
15 | 


--------------------------------------------------------------------------------
/queries/index_sizes.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        c.relname as index,
 3 |        a.rolname as owner,
 4 |        c.relfilenode as filename,
 5 |        CASE WHEN indisprimary
 6 | 	    THEN 'pkey'
 7 | 	    WHEN indisunique
 8 | 	    THEN 'uidx'
 9 | 	    ELSE'idx'
10 | 	END as type,
11 |        pg_size_pretty(pg_total_relation_size(n.nspname|| '.' || c.relname)) as total_size,
12 |        pg_total_relation_size(n.nspname|| '.' || c.relname) as total_size_bytes
13 |   FROM pg_index i
14 |   JOIN pg_class c     ON (c.oid = i.indexrelid)
15 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
16 |   JOIN pg_authid a ON ( a.oid = c.relowner )
17 |   WHERE relname NOT LIKE 'pg_%' AND
18 | relname NOT LIKE 'information%' AND
19 | relname NOT LIKE 'sql_%' AND
20 | relkind IN ('i')
21 | ORDER BY 7 DESC, 1, 2;
22 | 


--------------------------------------------------------------------------------
/queries/index_tablespaces.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        c.relname as table,
 3 |        c.reltablespace,
 4 |        CASE WHEN c.reltablespace > 0 THEN (SELECT t.spcname
 5 | 					    FROM pg_tablespace
 6 | 					   WHERE oid = c.reltablespace)
 7 |        ELSE '' END
 8 |   FROM pg_class c
 9 |   JOIN pg_authid a ON ( a.OID = c.relowner )
10 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
11 |   JOIN pg_tablespace t ON ( CASE WHEN c.reltablespace > 0 THEN t.oid = c.reltablespace
12 | 				 ELSE NULL END)
13 | WHERE c.relname NOT LIKE 'pg_%'
14 |   AND n.nspname NOT LIKE 'information%'
15 |   AND n.nspname NOT LIKE 'sql_%'
16 |   AND c.relkind = 'i'
17 | --  AND n.nspname = '<target_schema>'
18 | --  AND c.relname = '<table_name>'
19 | ORDER BY n.nspname, c.relname;
20 | 
21 | 


--------------------------------------------------------------------------------
/queries/make_alter_index_spc.sql:
--------------------------------------------------------------------------------
1 | SELECT 'ALTER INDEX ' || i.indexrelname
2 | 	 || ' SET TABLESPACE <new_table_space>;'
3 |   FROM pg_stat_all_indexes i
4 |   JOIN pg_class c ON (c.oid = i.relid)
5 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
6 |   JOIN pg_index idx ON (idx.indexrelid =  i.indexrelid )
7 |  WHERE n.nspname = 'public'
8 |  ORDER BY 1;
9 | 


--------------------------------------------------------------------------------
/queries/make_alter_table_spc.sql:
--------------------------------------------------------------------------------
 1 | SELECT 'ALTER TABLE ' || c.relname || ' SET TABLESPACE <new_table_space>;'
 2 |   FROM pg_class c
 3 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 4 | WHERE relname NOT LIKE 'pg_%'
 5 |   AND relname NOT LIKE 'information%'
 6 |   AND relname NOT LIKE 'sql_%'
 7 |   AND n.nspname = 'public'
 8 |   AND relkind = 'r'
 9 | ORDER BY relname;
10 | 


--------------------------------------------------------------------------------
/queries/most_active_tables.sql:
--------------------------------------------------------------------------------
1 | SELECT schemaname,
2 |        relname,
3 |        idx_tup_fetch + seq_tup_read as TotalReads
4 |   FROM pg_stat_all_tables
5 | WHERE idx_tup_fetch + seq_tup_read != 0
6 |   AND schemaname NOT IN ( 'pg_catalog', 'pg_toast' )
7 | order by TotalReads desc
8 | LIMIT 10;
9 | 


--------------------------------------------------------------------------------
/queries/parent_and_children.sql:
--------------------------------------------------------------------------------
 1 | SELECT DISTINCT n1.nspname || '.' || p.relname AS parent, n2.nspname || '.' || c.relname AS child
 2 | --	 , cstr.conname
 3 |   FROM pg_class c
 4 |   JOIN pg_constraint cstr ON (cstr.conrelid = c.oid AND c.relkind = 'r' AND cstr.contype = 'f')
 5 |   JOIN pg_namespace n2 ON (n2.oid = c.relnamespace)
 6 |   JOIN pg_class p ON (p.oid = cstr.confrelid)
 7 |   JOIN pg_namespace n1 ON (n1.oid = p.relnamespace)
 8 |  WHERE p.relkind = 'r'
 9 | --   AND n1.nspname = '<schema_name>'
10 | --   AND p.relname = '<paren_table>'
11 |    AND p.relname NOT LIKE 'pg_%'
12 |    AND p.relname NOT LIKE 'sql_%'
13 |    AND p.oid IN (SELECT confrelid
14 | 		   FROM pg_constraint)
15 |  ORDER BY parent, child;
16 | 
17 | 


--------------------------------------------------------------------------------
/queries/pg_runtime.sql:
--------------------------------------------------------------------------------
1 | SELECT pg_postmaster_start_time() as pg_start,
2 |        current_timestamp - pg_postmaster_start_time() as runtime;
3 | 


--------------------------------------------------------------------------------
/queries/pg_stat_all_indexes.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        i.relname as table,
 3 |        i.indexrelname as index,
 4 |        i.idx_scan,
 5 |        i.idx_tup_read,
 6 |        i.idx_tup_fetch,
 7 |        CASE WHEN idx.indisprimary
 8 | 	    THEN 'pkey'
 9 | 	    WHEN idx.indisunique
10 | 	    THEN 'uidx'
11 | 	    ELSE 'idx'
12 | 	    END AS type,
13 | /*
14 |        pg_get_indexdef(idx.indexrelid, 1, FALSE) as idxcol1,
15 |        pg_get_indexdef(idx.indexrelid, 2, FALSE) as idxcol2,
16 |        pg_get_indexdef(idx.indexrelid, 3, FALSE) as idxcol3,
17 |        pg_get_indexdef(idx.indexrelid, 4, FALSE) as idxcol4,
18 | 
19 | */
20 |        CASE WHEN idx.indisvalid
21 | 	    THEN 'valid'
22 | 	    ELSE 'INVALID'
23 | 	    END as statusi,
24 |        pg_relation_size( quote_ident(n.nspname) || '.' || quote_ident(i.relname) ) as size_in_bytes,
25 |        pg_size_pretty(pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(i.relname) )) as size
26 |   FROM pg_stat_all_indexes i
27 |   JOIN pg_class c ON (c.oid = i.relid)
28 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
29 |   JOIN pg_index idx ON (idx.indexrelid =  i.indexrelid )
30 |  WHERE i.relname LIKE '%%'
31 |    AND n.nspname NOT LIKE 'pg_%'
32 | --   AND idx.indisunique = TRUE
33 | --   AND NOT idx.indisprimary
34 | --   AND i.indexrelname LIKE 'tmp%'
35 | --   AND idx.indisvalid IS false
36 | /*   AND NOT idx.indisprimary
37 |    AND NOT idx.indisunique
38 |    AND idx_scan = 0
39 | */ ORDER BY 1, 2, 3;
40 | 


--------------------------------------------------------------------------------
/queries/pg_stat_all_tables.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname,
 2 |        s.relname,
 3 |        c.reltuples::bigint,
 4 | --	 n_live_tup,
 5 |        n_tup_ins,
 6 |        n_tup_upd,
 7 |        n_tup_del,
 8 |        date_trunc('second', last_vacuum) as last_vacuum,
 9 |        date_trunc('second', last_autovacuum) as last_autovacuum,
10 |        date_trunc('second', last_analyze) as last_analyze,
11 |        date_trunc('second', last_autoanalyze) as last_autoanalyze
12 |        ,
13 |        round( current_setting('autovacuum_vacuum_threshold')::integer + current_setting('autovacuum_vacuum_scale_factor')::numeric * C.reltuples) AS av_threshold
14 | /*	 ,CASE WHEN reltuples > 0
15 | 	      THEN round(100.0 * n_dead_tup / (reltuples))
16 | 	    ELSE 0
17 |        END AS pct_dead,
18 |        CASE WHEN n_dead_tup > round( current_setting('autovacuum_vacuum_threshold')::integer + current_setting('autovacuum_vacuum_scale_factor')::numeric * C.reltuples)
19 | 	      THEN 'VACUUM'
20 | 	    ELSE 'ok'
21 | 	END AS "av_needed"
22 | */
23 |   FROM pg_stat_all_tables s
24 |   JOIN pg_class c ON c.oid = s.relid
25 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
26 |  WHERE s.relname NOT LIKE 'pg_%'
27 |    AND s.relname NOT LIKE 'sql_%'
28 | --   AND s.relname LIKE '%TBL%'
29 |  ORDER by 1, 2;
30 | 


--------------------------------------------------------------------------------
/queries/role_members.sql:
--------------------------------------------------------------------------------
 1 | SELECT a.rolname as role,
 2 |        u.rolname as member,
 3 |        CASE
 4 | 	 WHEN m.admin_option THEN
 5 | 	 'YES'
 6 | 	 ELSE
 7 | 	  'no'
 8 |        END as admin
 9 | FROM pg_auth_members m
10 | JOIN pg_authid a ON (a.oid = m.roleid)
11 | JOIN pg_authid u ON (u.oid = m.member)
12 | ORDER BY 1, 2
13 | 


--------------------------------------------------------------------------------
/queries/rules.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname,
 2 |        c.relname,
 3 |        r.rulename
 4 |   FROM pg_rewrite r
 5 |   JOIN pg_class c     ON (c.oid = ev_class)
 6 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 7 |  WHERE rulename <> '_RETURN'
 8 | --   AND n.nspname <> 'inv'
 9 |   ORDER BY 1, 2, 3;
10 | 
11 | 


--------------------------------------------------------------------------------
/queries/sequence_cols.sql:
--------------------------------------------------------------------------------
 1 | SELECT table_schema as schema,
 2 |        table_name as table,
 3 |        column_name as column,
 4 |        column_default,
 5 |        data_type
 6 |   FROM information_schema.columns
 7 |   WHERE column_default LIKE 'nextval%'
 8 |   ORDER BY 1, 2, 3;
 9 | 
10 | SELECT tbl.relname,
11 |        col.attname,
12 |        col.attnum
13 |   FROM pg_attrdef def
14 |   JOIN pg_class tbl ON tbl.oid = def.adrelid
15 |   JOIN pg_attribute col ON col.attrelid = tbl.oid
16 |  WHERE def.adsrc LIKE 'nextval%'
17 |    AND col.attnum = def.adnum
18 |  ORDER BY 1;
19 | 
20 | 
21 | 
22 | 


--------------------------------------------------------------------------------
/queries/show_dead_tuples.sql:
--------------------------------------------------------------------------------
 1 | SELECT *,
 2 |        n_dead_tup > av_threshold AS "av_needed",
 3 |        CASE WHEN reltuples > 0
 4 | 	      THEN round(100.0 * n_dead_tup / (reltuples))
 5 |        ELSE 0
 6 |        END AS pct_dead
 7 |  FROM (SELECT
 8 | 	 N.nspname || '.' || C.relname AS "relation",
 9 | 	 pg_stat_get_tuples_inserted(C.oid) AS n_tup_ins,
10 | 	 pg_stat_get_tuples_updated(C.oid) AS n_tup_upd,
11 | 	 pg_stat_get_tuples_deleted(C.oid) AS n_tup_del,
12 | 	 CASE WHEN pg_stat_get_tuples_updated(C.oid) > 0
13 | 		THEN pg_stat_get_tuples_hot_updated(C.oid)::real / pg_stat_get_tuples_updated(C.oid)
14 | 		ELSE 0
15 | 	  END AS HOT_update_ratio,
16 | 	 pg_stat_get_live_tuples(C.oid) AS n_live_tup,
17 | 	 pg_stat_get_dead_tuples(C.oid) AS n_dead_tup,
18 | 	 C.reltuples AS reltuples,
19 | 	 round( current_setting('autovacuum_vacuum_threshold')::integer + current_setting('autovacuum_vacuum_scale_factor')::numeric * C.reltuples) AS av_threshold,
20 | 	 date_trunc('minute',greatest(pg_stat_get_last_vacuum_time(C.oid),pg_stat_get_last_autovacuum_time(C.oid))) AS last_vacuum,
21 | 	 date_trunc('minute',greatest(pg_stat_get_last_analyze_time(C.oid),pg_stat_get_last_analyze_time(C.oid))) AS last_analyze
22 | 	 FROM pg_class C
23 | 	 LEFT JOIN pg_index I ON C.oid = I.indrelid
24 | 	 LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
25 | 	  WHERE C.relkind IN ('r', 't')
26 | 	    AND N.nspname NOT IN ('pg_catalog', 'information_schema')
27 | 	    AND N.nspname !~ '^pg_toast'
28 |        ) AS av
29 | ORDER BY av_needed DESC,
30 | 	 n_dead_tup DESC;
31 | 


--------------------------------------------------------------------------------
/queries/table_access.sql:
--------------------------------------------------------------------------------
 1 | --r=SELECT
 2 | --r=SELECT
 3 | --a=INSERT
 4 | --w=UPDATE
 5 | --d=DELETE
 6 | --x=REFERENCES
 7 | 
 8 | SELECT n.nspname as schema,
 9 |        c.relname,
10 |        array_to_string(c.relacl, '  ')
11 |   FROM pg_class c
12 |    JOIN pg_namespace n ON (n.oid = c.relnamespace)
13 |  WHERE c.relkind = 'r'
14 |    AND n.nspname = 'public'
15 |  ORDER BY c.relname;
16 | 
17 | 


--------------------------------------------------------------------------------
/queries/table_columns.sql:
--------------------------------------------------------------------------------
 1 | -- Returns all columns for a specified table
 2 | SELECT c.relname as table,
 3 |        a.attname as column
 4 |   FROM pg_class c
 5 |   JOIN pg_attribute a ON ( a.attrelid = c.oid )
 6 |  WHERE relname = '<table>'
 7 |    AND attnum > 0
 8 |    AND NOT attisdropped
 9 |  ORDER BY attnum;
10 | 


--------------------------------------------------------------------------------
/queries/table_comments.sql:
--------------------------------------------------------------------------------
 1 | SELECT DISTINCT ON (c.relname)
 2 |        n.nspname as schema,
 3 |        c.relname,
 4 |        a.rolname as owner,
 5 |        0 as col_seq,
 6 |        '' as column,
 7 |        d.description as comment
 8 |   FROM pg_class c
 9 | LEFT  JOIN pg_attribute col ON (col.attrelid = c.oid)
10 | LEFT  JOIN pg_description d ON (d.objoid = col.attrelid AND d.objsubid = 0)
11 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
12 |   JOIN pg_authid a ON ( a.OID = c.relowner )
13 |   WHERE n.nspname NOT LIKE 'information%'
14 |     AND relname NOT LIKE 'pg_%'
15 |     AND relname NOT LIKE 'information%'
16 |     AND relname NOT LIKE 'sql_%'
17 | --    AND relname LIKE '<TABLE>'
18 |     AND relkind = 'r'
19 | --    AND d.description IS NOT NULL
20 | UNION
21 | SELECT n.nspname as schema,
22 |        c.relname,
23 |        '' as owner,
24 |        col.attnum as col_seq,
25 |        col.attname as column,
26 |        d.description
27 |   FROM pg_class c
28 |   JOIN pg_attribute col ON (col.attrelid = c.oid)
29 |   LEFT JOIN pg_description d ON (d.objoid = col.attrelid AND d.objsubid = col.attnum)
30 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
31 |   JOIN pg_authid a ON ( a.OID = c.relowner )
32 | WHERE n.nspname NOT LIKE 'information%'
33 |   AND relname NOT LIKE 'pg_%'
34 |   AND relname NOT LIKE 'information%'
35 |   AND relname NOT LIKE 'sql_%'
36 | --  AND relname LIKE '<TABLE>'
37 |   AND relkind = 'r'
38 | --  AND d.description IS NOT NULL
39 |   AND col.attnum >= 0
40 | ORDER BY 1, 2, 4;
41 | 


--------------------------------------------------------------------------------
/queries/table_constraints.sql:
--------------------------------------------------------------------------------
 1 | SELECT rel.relname,
 2 |        con.conname,
 3 |        con.contype,
 4 |        con.consrc
 5 |   FROM pg_class rel
 6 |   JOIN pg_constraint con ON (con.conrelid = rel.oid)
 7 |  --WHERE contype = 'f'
 8 |  ORDER by relname,
 9 | 	  contype,
10 | 	  conname;
11 | 


--------------------------------------------------------------------------------
/queries/table_dependents.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        pa.relname as parent,
 3 |        ch.relname as dependent,
 4 |        cn.conname as constraint_name
 5 |   FROM pg_constraint cn
 6 |   JOIN pg_class pa ON (pa.oid = cn.confrelid)
 7 |   JOIN pg_class ch ON (ch.oid = cn.conrelid)
 8 |   JOIN pg_namespace n ON (n.oid = pa.relnamespace)
 9 |  WHERE pa.relname LIKE '%%'
10 |    AND contype = 'f'
11 |  ORDER BY 1, 2, 3;
12 | 


--------------------------------------------------------------------------------
/queries/table_grants.sql:
--------------------------------------------------------------------------------
1 | SELECT table_schema,
2 |        table_name,
3 |        grantee,
4 |        privilege_type
5 |   FROM information_schema.role_table_grants
6 |  WHERE table_schema NOT IN ('information_schema', 'pg_catalog')
7 |  ORDER BY table_schema, table_name, grantee;
8 | 


--------------------------------------------------------------------------------
/queries/table_in_function.sql:
--------------------------------------------------------------------------------
 1 | SELECT p.proname,
 2 |        CASE WHEN p.proretset = TRUE
 3 | 	    THEN 'SET OF '
 4 | 	    ELSE ''
 5 | 	END ||
 6 |        UPPER( (SELECT typname
 7 | 	  FROM pg_type
 8 | 	 WHERE oid = p.prorettype) ) AS return_type,
 9 |        proargnames as parameters
10 |   FROM pg_proc p
11 |  WHERE prosrc ILIKE ('%<TABLE/COLUMN>%')
12 |    AND proname NOT LIKE 'pg%'
13 |  ORDER BY p.proname;
14 | 


--------------------------------------------------------------------------------
/queries/table_in_schema.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname,
 2 |        c.relname,
 3 |        pg_size_pretty (pg_total_relation_size(c.oid)) as size
 4 |   FROM pg_class c
 5 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 6 | WHERE c.relname NOT LIKE 'pg_%'
 7 |   AND c.relname NOT LIKE 'information%'
 8 |   AND c.relname NOT LIKE 'sql_%'
 9 |   AND c.relkind = 'r'
10 |   AND n.nspname = '<schema_name>'
11 | ORDER BY n.nspname;
12 | 
13 | 


--------------------------------------------------------------------------------
/queries/table_in_trigger.sql:
--------------------------------------------------------------------------------
 1 | SELECT c.relname as table,
 2 |        t.tgname as tg_name,
 3 |        p.proname as tg_function
 4 |   FROM pg_proc p
 5 |   JOIN pg_trigger t ON (t.tgfoid = p.oid)
 6 |   JOIN pg_class c ON (c.oid = t.tgrelid)
 7 |  WHERE prosrc LIKE ('%<table>%')
 8 |  ORDER BY c.relname;
 9 | 
10 | 


--------------------------------------------------------------------------------
/queries/table_indexes.sql:
--------------------------------------------------------------------------------
1 | SELECT cc.relname as table,
2 |        ci.relname as index
3 |   FROM pg_index i
4 |   JOIN pg_class cc ON (cc.oid = i.indrelid)
5 |   JOIN pg_class ci ON (ci.oid = i.indexrelid)
6 |   WHERE ci.relname = 'idx_normal_distro_name'
7 | ORDER BY 1;
8 | 
9 | 


--------------------------------------------------------------------------------
/queries/table_row_counts.sql:
--------------------------------------------------------------------------------
1 | SELECT s.nspname, c.relname as table, c.reltuples::int4 as rows
2 |   FROM pg_catalog.pg_class c
3 |   JOIN pg_catalog.pg_namespace s ON (c.relnamespace = s.oid)
4 |  WHERE relkind = 'r'
5 |    AND c.reltuples::int4 > 0
6 |  ORDER BY rows DESC;
7 | 


--------------------------------------------------------------------------------
/queries/table_sizes.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        c.relname as table,
 3 |        a.rolname as owner,
 4 |        c.relfilenode as filename,
 5 |        c.reltuples,
 6 |        pg_size_pretty(pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(c.relname) )) as size,
 7 |        pg_size_pretty(pg_total_relation_size(quote_ident(n.nspname) || '.' || quote_ident(c.relname) )) as total_size,
 8 |        pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(c.relname) ) as size_bytes,
 9 |        pg_total_relation_size(quote_ident(n.nspname) || '.' || quote_ident(c.relname) ) as total_size_bytes,
10 |        CASE WHEN c.reltablespace = 0
11 | 	    THEN 'pg_default'
12 | 	    ELSE (SELECT t.spcname
13 | 		    FROM pg_tablespace t WHERE (t.oid = c.reltablespace) )
14 | 	END as tablespace
15 | FROM pg_class c
16 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
17 |   JOIN pg_authid a ON ( a.oid = c.relowner )
18 |   WHERE relname NOT LIKE 'pg_%'
19 |     AND relname NOT LIKE 'information%'
20 |     AND relname NOT LIKE 'sql_%'
21 |     AND relkind IN ('r')
22 | ORDER BY 7 DESC, 1, 2;
23 | 


--------------------------------------------------------------------------------
/queries/table_stats.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname,
 2 |        c.relname,
 3 |        pg_stat_get_last_vacuum_time(c.oid) as last_vacuum,
 4 |        pg_stat_get_tuples_inserted(c.oid) as inserted,
 5 |        pg_stat_get_tuples_updated(c.oid) as updated,
 6 |        pg_stat_get_tuples_deleted(c.oid) as deleted
 7 |   FROM pg_class c
 8 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 9 |  WHERE nspname NOT IN ('information_schema', 'pg_toast', 'pg_catalog')
10 |  ORDER BY 1, 2;
11 | 


--------------------------------------------------------------------------------
/queries/table_triggers.sql:
--------------------------------------------------------------------------------
 1 | /*
 2 | SELECT n.nspname as schema,
 3 |        c.relname as table,
 4 |        t.tgname as trigger,
 5 |        t.tgtype as "type"
 6 |   FROM pg_trigger t
 7 |   JOIN pg_class c ON (c.oid = t.tgrelid)
 8 |   JOIN pg_namespace n ON n.oid = c.relnamespace
 9 | ORDER BY 1, 2;
10 | */
11 | 
12 | SELECT n.nspname as schema,
13 |        r.relname,
14 |        t.tgname,
15 |        t.tgtype,
16 |        t.tgenabled
17 |   FROM pg_class r
18 |   JOIN pg_namespace n ON n.oid = r.relnamespace
19 |   JOIN pg_trigger t ON (t.tgrelid = r.oid)
20 | -- WHERE t.tgenabled = 'D' -- Show only DISABLED triggers
21 |  ORDER BY 1, 2;
22 | 
23 | 


--------------------------------------------------------------------------------
/queries/tables_and_comments.sql:
--------------------------------------------------------------------------------
 1 | SELECT DISTINCT ON (c.relname)
 2 |        n.nspname as schema,
 3 |        c.relname,
 4 |        a.rolname as owner,
 5 |        0 as col_seq,
 6 |        '' as column,
 7 |        d.description as comment
 8 | --	 c.oid
 9 |   FROM pg_class c
10 |   JOIN pg_attribute col ON (col.attrelid = c.oid)
11 |   JOIN pg_description d ON (d.objoid = col.attrelid AND d.objsubid = 0)
12 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
13 |   JOIN pg_authid a ON ( a.OID = c.relowner )
14 | UNION
15 | SELECT n.nspname as schema,
16 |        c.relname,
17 |        '' as owner,
18 |        col.attnum as col_seq,
19 |        col.attname as column,
20 |        d.description as comment
21 | --	 c.oid
22 |   FROM pg_class c
23 |   JOIN pg_attribute col ON (col.attrelid = c.oid)
24 |   JOIN pg_description d ON (d.objoid = col.attrelid AND d.objsubid = col.attnum)
25 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
26 |   JOIN pg_authid a ON ( a.OID = c.relowner )
27 | WHERE relname NOT LIKE 'pg_%'
28 |   AND relname NOT LIKE 'information%'
29 |   AND relname NOT LIKE 'sql_%'
30 |   AND relkind = 'r'
31 |   AND d.objsubid >= 0
32 |   AND col.attnum >= 0
33 | ORDER BY 1, 2, 4;
34 | 
35 | 


--------------------------------------------------------------------------------
/queries/tables_and_filenames.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname,
 2 |        c.relname as table,
 3 |        (SELECT oid FROM pg_database WHERE datname = current_database() ) as db_dir,
 4 |        c.relfilenode as filename
 5 |   FROM pg_class c
 6 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 7 | WHERE relname NOT LIKE 'pg_%' AND
 8 |       relname NOT LIKE 'information%' AND
 9 |       relname NOT LIKE 'sql_%' AND
10 |       relkind = 'r'
11 | ORDER BY 1, relname;
12 | 
13 | 
14 | 


--------------------------------------------------------------------------------
/queries/tables_and_owners.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        c.relname as table,
 3 |        a.rolname as owner,
 4 |        c.relacl as permits
 5 |   FROM pg_class c
 6 |   JOIN pg_namespace n ON ( n.oid = c.relnamespace )
 7 |   JOIN pg_authid a ON ( a.OID = c.relowner )
 8 | WHERE relname NOT LIKE 'pg_%'
 9 |   AND relname NOT LIKE 'information%'
10 |   AND relname NOT LIKE 'sql_%'
11 |   AND relkind = 'r'
12 |   --AND position('cp' in ARRAY_TO_STRING(c.relacl, '') )> 0
13 | ORDER BY n.nspname,
14 |          c.relname;
15 | 
16 | 


--------------------------------------------------------------------------------
/queries/tables_and_pkey.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |       t.relname as table, 
 3 |       c.conname as pk_name
 4 |   FROM pg_class t
 5 |   JOIN pg_namespace n ON ( n.oid = t.relnamespace )
 6 |   JOIN pg_constraint c ON ( c.conrelid = t.OID AND c.contype = 'p')
 7 |  WHERE relkind = 'r'
 8 |    AND t.relname NOT LIKE 'pg_%'
 9 |    AND t.relname NOT LIKE 'sql_%'
10 |    ORDER BY t.relname, c.conname;
11 | 


--------------------------------------------------------------------------------
/queries/tables_with_FKs.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        t.relname as table, 
 3 |        count(c.conname)
 4 |   FROM pg_class t
 5 |   JOIN pg_namespace n ON n.oid = t.relnamespace
 6 |   JOIN pg_constraint c ON ( c.conrelid = t.OID AND c.contype = 'f')
 7 |  WHERE relkind = 'r'
 8 |    AND t.relname NOT LIKE 'pg_%'
 9 |    AND t.relname NOT LIKE 'sql_%'
10 |    GROUP BY n.nspname, 
11 |             t.relname
12 |    ORDER BY count, n.nspname, t.relname;
13 | 
14 | 
15 | SELECT n.nspname as schema, 
16 |        t.relname as table, 
17 |        c.conname as fk_name
18 |   FROM pg_class t
19 |   JOIN pg_namespace n ON n.oid = t.relnamespace
20 |   JOIN pg_constraint c ON ( c.conrelid = t.OID AND c.contype = 'f')
21 |  WHERE relkind = 'r'
22 |    AND t.relname NOT LIKE 'pg_%'
23 |    AND t.relname NOT LIKE 'sql_%'
24 |    ORDER BY n.nspname, 
25 |             t.relname, 
26 |             c.conname;


--------------------------------------------------------------------------------
/queries/tables_with_column_name.sql:
--------------------------------------------------------------------------------
 1 | SELECT c.table_schema as schema,
 2 |        c.table_name as table,
 3 |        c.column_name as column,
 4 |        c.data_type as type,
 5 |        case when c.data_type LIKE '%char%'
 6 | 	      then COALESCE(character_maximum_length::text, 'N/A')
 7 | 	    when c.data_type LIKE '%numeric%'
 8 | 	      then  '(' || c.numeric_precision::text || ', ' || c.numeric_scale::text || ')'
 9 | 	    when c.data_type LIKE '%int%'
10 | 	      then  c.numeric_precision::text
11 | 	 else COALESCE(character_maximum_length::text, 'N/A')
12 |        end as size
13 |   FROM information_schema.columns c
14 | WHERE c.table_schema NOT LIKE 'pg_%'
15 |   AND c.table_schema NOT LIKE 'information%'
16 |   AND c.table_name NOT LIKE 'sql_%'
17 |   AND c.is_updatable = 'YES'
18 |   AND c.column_name LIKE '%<COLUMN_NAME>%'
19 | ORDER BY c.table_name, c.column_name;
20 | 
21 | 


--------------------------------------------------------------------------------
/queries/tables_with_large_index_size.sql:
--------------------------------------------------------------------------------
 1 | -- TABLES with_large_index_size
 2 | SELECT c.oid, s.nspname, 
 3 |        c.relname as table, 
 4 |        c.reltuples::int4 as rows, 
 5 |        c.relpages as pages,
 6 |        pg_size_pretty (pg_relation_size(c.oid)) as size,
 7 |        (SELECT pg_size_pretty (SUM (pg_relation_size(indexrelid) )::INT8)  
 8 |           FROM pg_index 
 9 |          WHERE indrelid = c.oid) as index_size,
10 |        pg_size_pretty (pg_total_relation_size(c.oid))
11 |   FROM pg_catalog.pg_class c
12 |   JOIN pg_catalog.pg_namespace s ON (relnamespace = s.oid) 
13 |  WHERE nspname = 'public'
14 |    AND relkind = 'r'
15 |  GROUP BY 1, 2, 3, 4, 5, 6
16 |  HAVING pg_relation_size(c.oid) < (SELECT SUM (pg_relation_size(indexrelid) )  
17 |                                      FROM pg_index 
18 |                                     WHERE indrelid = c.oid) 
19 | ORDER BY (SELECT SUM (pg_relation_size(indexrelid) )::INT8  FROM pg_index 
20 |          WHERE indrelid = c.oid) DESC                                   
21 | 
22 | 


--------------------------------------------------------------------------------
/queries/tables_with_no_FK.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        relname as table
 3 |   FROM pg_class c
 4 |   JOIN pg_namespace n ON ( n.oid = c.relnamespace )
 5 |  WHERE relkind = 'r'
 6 |    AND relname NOT LIKE 'pg_%'
 7 |    AND relname NOT LIKE 'sql_%'
 8 |    AND c.oid NOT IN
 9 |        (SELECT conrelid
10 |           FROM pg_constraint
11 |          WHERE contype = 'f'
12 |            AND contype <> 'p'
13 |            AND contype <> 'c')
14 |   ORDER BY n.nspname,
15 |            relname;
16 | 


--------------------------------------------------------------------------------
/queries/tables_with_no_pkey.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema, 
 2 |        c.relname as table
 3 |   FROM pg_class c
 4 |   JOIN pg_namespace n ON (n.oid =c.relnamespace )
 5 |  WHERE relkind = 'r' AND
 6 |        relname NOT LIKE 'pg_%' AND
 7 |        relname NOT LIKE 'sql_%' AND
 8 |        relhaspkey = FALSE
 9 | ORDER BY n.nspname, c.relname;
10 | 


--------------------------------------------------------------------------------
/queries/tables_with_no_public_grants.sql:
--------------------------------------------------------------------------------
1 | SELECT relname, array_to_string(ARRAY[relacl], '|') as permits
2 |   FROM pg_class
3 | WHERE relkind = 'r'
4 |   AND position('|=' in array_to_string(ARRAY[relacl], '|')) = 0
5 | ORDER BY 1;
6 | 


--------------------------------------------------------------------------------
/queries/tcp_settings.sql:
--------------------------------------------------------------------------------
1 | SELECT name, setting, short_desc
2 |   FROM pg_settings
3 |  WHERE name LIKE 'tcp%';
4 | 
5 | 


--------------------------------------------------------------------------------
/queries/triggers_and_constraints.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname        AS schema,
 2 |        c.relname,
 3 |        t.tgname,
 4 |        p.proname	AS function_called,
 5 | --       t.tgisconstraint AS is_constraint,
 6 | --       t.tgconstrname	AS constraint_nm,
 7 |        CASE WHEN t.tgconstrrelid > 0
 8 | 	    THEN (SELECT relname
 9 | 		   FROM pg_class
10 | 		  WHERE oid = t.tgconstrrelid)
11 | 	    ELSE ''
12 | 	END		AS constr_tbl,
13 |        t.tgenabled
14 |   FROM pg_trigger t
15 |   INNER JOIN pg_proc p	    ON ( p.oid = t.tgfoid)
16 |   INNER JOIN pg_class c     ON (c.oid = t.tgrelid)
17 |   INNER JOIN pg_namespace n ON  (n.oid = c.relnamespace)
18 |   WHERE tgname NOT LIKE 'pg_%'
19 |     AND tgname NOT LIKE 'RI_%'	-- < comment out to see constraints
20 | --    AND t.tgenabled = FALSE
21 |  ORDER BY 1;
22 | 


--------------------------------------------------------------------------------
/queries/useless_indexes.sql:
--------------------------------------------------------------------------------
 1 | SELECT idstat.schemaname AS schema,
 2 |        idstat.relname AS table_name,
 3 |        indexrelname AS index_name,
 4 |        idstat.idx_scan AS times_used,
 5 |        pg_size_pretty(pg_relation_size(quote_ident(idstat.schemaname) || '.' || quote_ident(idstat.relname))) AS table_size,
 6 |        pg_size_pretty(pg_relation_size(quote_ident(idstat.schemaname) || '.' || quote_ident(indexrelname))) AS index_size,
 7 |        n_tup_upd + n_tup_ins + n_tup_del as num_writes,
 8 |        indexdef AS definition
 9 | FROM pg_stat_user_indexes AS idstat
10 | JOIN pg_indexes ON indexrelname = indexname
11 | JOIN pg_stat_user_tables AS tabstat ON idstat.relname = tabstat.relname
12 | WHERE idstat.idx_scan < 200
13 |   AND indexdef !~* 'unique'
14 | ORDER BY idstat.schemaname,
15 | 	 idstat.relname,
16 | 	 indexrelname;
17 | 


--------------------------------------------------------------------------------
/queries/useless_indexes2.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname as schema,
 2 |        i.relname as table,
 3 |        i.indexrelname as index,
 4 |        i.idx_scan,
 5 |        i.idx_tup_read,
 6 |        i.idx_tup_fetch,
 7 |        pg_size_pretty(pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(i.relname))) AS table_size,
 8 |        pg_size_pretty(pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(i.indexrelname))) AS index_size,
 9 |        pg_get_indexdef(idx.indexrelid) as idx_definition
10 |   FROM pg_stat_all_indexes i
11 |   JOIN pg_class c ON (c.oid = i.relid)
12 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
13 |   JOIN pg_index idx ON (idx.indexrelid =  i.indexrelid )
14 |  WHERE i.idx_scan < 200
15 |    AND NOT idx.indisprimary
16 |    AND NOT idx.indisunique
17 |  ORDER BY 1, 2, 3;
18 | 
19 | 
20 | 


--------------------------------------------------------------------------------
/queries/user_table_access.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname,
 2 |        c.relname,
 3 |        array_to_string(ARRAY[c.relacl], '|') as permits,
 4 |        position('<USERNAME>' in array_to_string(ARRAY[relacl], '|'))
 5 |   FROM pg_class c
 6 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 7 | WHERE n.nspname not like 'pg_%'
 8 |   AND n.nspname not like 'inform_%'
 9 |   AND relkind = 'r'
10 |   AND (position('<USERNAME>' in array_to_string(ARRAY[relacl], '|')) > 0
11 |   OR  position( (SELECT g.rolname
12 | 		 FROM pg_auth_members r
13 | 		 JOIN pg_authid g ON (r.roleid = g.oid)
14 | 		 JOIN pg_authid u ON (r.member = u.oid)
15 | 		  AND u.rolname LIKE '%<USERNAME>%') in array_to_string(ARRAY[relacl], '|')) > 0 )
16 | ORDER BY 1;
17 | 


--------------------------------------------------------------------------------
/queries/user_table_access_detail.sql:
--------------------------------------------------------------------------------
 1 | SELECT n.nspname,
 2 |        c.relname,
 3 |        CASE WHEN has_table_privilege('<CKUSER>', n.nspname || '.' || c.relname, 'SELECT')
 4 | 	    THEN 'YES'
 5 | 	    ELSE 'no'
 6 | 	END AS select,
 7 |        CASE WHEN has_table_privilege('<CKUSER>', n.nspname || '.' || c.relname, 'INSERT')
 8 | 	    THEN 'YES'
 9 | 	    ELSE 'no'
10 | 	END AS insert,
11 |        CASE WHEN has_table_privilege('<CKUSER>', n.nspname || '.' || c.relname, 'UPDATE')
12 | 	    THEN 'YES'
13 | 	    ELSE 'no'
14 | 	END AS update,
15 |        CASE WHEN has_table_privilege('<CKUSER>', n.nspname || '.' || c.relname, 'DELETE')
16 | 	    THEN 'YES'
17 | 	    ELSE 'no'
18 | 	END AS delete,
19 |        array_to_string(ARRAY[c.relacl], '|') as permits
20 |   FROM pg_class c
21 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
22 | WHERE n.nspname not like 'pg_%'
23 |   AND n.nspname not like 'inform_%'
24 |   AND relkind = 'r'
25 | /*
26 |   AND (position('$CKUSER' in array_to_string(ARRAY[relacl], '|')) > 0
27 |   OR  position( (SELECT g.rolname
28 | 		 FROM pg_auth_members r
29 | 		 JOIN pg_authid g ON (r.roleid = g.oid)
30 | 		 JOIN pg_authid u ON (r.member = u.oid)
31 | 		  AND u.rolname LIKE '$CKUSER%') in array_to_string(ARRAY[relacl], '|')) > 0 )
32 | */
33 | ORDER BY 1, 2;
34 | 


--------------------------------------------------------------------------------
/queries/users.sql:
--------------------------------------------------------------------------------
 1 | SELECT rolname as user,
 2 |        CASE WHEN rolcanlogin THEN 'user'
 3 | 	    ELSE 'group'
 4 |        END,
 5 |        CASE WHEN rolsuper THEN 'SUPERUSER'
 6 | 	    ELSE 'normal'
 7 | 	END AS super
 8 |   FROM pg_authid
 9 | ORDER BY rolcanlogin ,
10 | 	 rolname;
11 | 


--------------------------------------------------------------------------------
/queries/wasted_index_space.sql:
--------------------------------------------------------------------------------
 1 | /* Requires PostgreSQL 8.4 or greater */
 2 | WITH s AS(
 3 |   SELECT SUM(pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(c.relname))::bigint) AS table_size,
 4 |        pg_size_pretty(SUM(pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(c.relname))::bigint)::bigint) AS table_size_pretty
 5 |   FROM pg_class c
 6 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
 7 |    WHERE c.relkind = 'r'
 8 |    AND c.relname NOT LIKE 'pg_%'
 9 |    AND c.relname NOT LIKE 'sql%'
10 | )
11 | SELECT s.table_size,
12 |        s.table_size_pretty,
13 |        SUM(pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(i.indexrelname))::bigint) AS unused_idx_size,
14 |        pg_size_pretty(SUM(pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(i.indexrelname))::bigint)::bigint) AS unused_idx_size_pretty,
15 |            pg_database_size(current_database()) as db_size,
16 |            pg_size_pretty(pg_database_size(current_database()))as db_size_pretty,
17 |            pg_size_pretty(pg_database_size(current_database()) -  SUM(pg_relation_size(quote_ident(n.nspname) || '.' || quote_ident(i.indexrelname))::bigint)::bigint) as db_minus_wasted_space
18 | 
19 |   FROM s, pg_stat_all_indexes i
20 |   JOIN pg_class c ON (c.oid = i.relid)
21 |   JOIN pg_namespace n ON (n.oid = c.relnamespace)
22 |   JOIN pg_index idx ON (idx.indexrelid =  i.indexrelid )
23 |  WHERE i.idx_scan = 0
24 |    AND NOT idx.indisprimary
25 |    AND NOT idx.indisunique
26 |       GROUP BY table_size, table_size_pretty;
27 | 


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