What do you get with Print?

Instant access to your digital copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Redeem a companion digital copy on all Print orders

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

AI Assistant (beta) to help accelerate your learning

This chapter consists of several recipes to c. We shall start this chapter with recipes that show some of the utilities available for creating and dropping databases. We will see how a database and a table can be located on a file system and then see how a schema can be created. We shall also understand the advantages of using schemas, along with the steps involved in assigning the ownership of a schema to a user. We'll then move on to discuss the methods involved in looking at the size of a table and an index in PostgreSQL.

Over a period of time, database activity may cause objects to grow huge in size. This is the time when we wish to move tables and indexes across different tablespaces to distribute the IOPS across multiple disks. Additionally, you may wish to create archive tables to store old data that is not heavily accessed but only kept for satisfying compliances. For this purpose, we shall discuss the steps involved in creating a tablespace and how to move a table to a tablespace.

We will then move on to user management in PostgreSQL, where we will see how to create and drop a user, how to assign and revoke a privilege from a user, and how to properly manage the segregation of privileges using roles.

Finally, we will end the chapter by discussing how the MVCC implementation is different in PostgreSQL, along with an introduction to VACUUM.

The following are the recipes that will be discussed in this chapter:

Creating and dropping databases
Locating a database and a table
Creating a schema
Checking table and index sizes
Creating tablespaces
Moving tables to a different tablespace

Creating a user
Dropping a user
Assigning and revoking privileges
Creating a group role for role-based segregation
MVCC implementation and VACUUM

So far, we have seen how to install PostgreSQL, initialize a PostgreSQL cluster, and start and stop a cluster. In this recipe, we shall discuss how to create or drop a database using the createdb and dropdb utilities.

There are multiple ways to create and drop a database in PostgreSQL. Upon successful installation of PostgreSQL, you have two utilities, called createdb and dropdb, that can be used to create and drop databases in PostgreSQL. The same can also be done using the psql utility.

Let's look at this in detail in these recipes.

Getting ready

In order to create or drop databases, we must either be a superuser or have the role CREATEDB. Also, the user who is dropping the database should either be a superuser or the OWNER of the database.

How to do it...

The following are the steps involved in creating and dropping a database using the createdb and dropdb utilities:

We will use help to list all the arguments for the createdb utility:

$ createdb --help
createdb creates a PostgreSQL database.

Usage:
  createdb [OPTION]... [DBNAME] [DESCRIPTION]

Options:
  -D, --tablespace=TABLESPACE  default tablespace for the database
  -e, --echo                   show the commands being sent to the server
  -E, --encoding=ENCODING      encoding for the database
  -l, --locale=LOCALE          locale settings for the database
      --lc-collate=LOCALE      LC_COLLATE setting for the database
      --lc-ctype=LOCALE        LC_CTYPE setting for the database
  -O, --owner=OWNER            database user to own the new database
  -T, --template=TEMPLATE      template database to copy
  -V, --version                output version information, then exit
  -?, --help                   show this help, then exit

Connection options:
  -h, --host=HOSTNAME          database server host or socket directory
  -p, --port=PORT              database server port
  -U, --username=USERNAME      user name to connect as
  -w, --no-password            never prompt for password
  -W, --password               force password prompt
  --maintenance-db=DBNAME      alternate maintenance database
By default, a database with the same name as the current user is created.Report bugs to <pgsql-bugs@postgresql.org>.

We will run the following command to create a database using createdb:

$ createdb -e pgtest -O user1
SELECT pg_catalog.set_config('search_path', '', false)
CREATE DATABASE pgtest OWNER user1;

We will then create a database using a template as follows:

$ createdb -e pgtest -O user1 -T percona
SELECT pg_catalog.set_config('search_path', '', false)
CREATE DATABASE pgtest OWNER user1 TEMPLATE pg11;

We will use help to list all the arguments for the dropdb utility:

$ dropdb --help
dropdb removes a PostgreSQL database.

Usage:
  dropdb [OPTION]... DBNAME

Options:
  -e, --echo                show the commands being sent to the server
  -i, --interactive         prompt before deleting anything
  -V, --version             output version information, then exit
  --if-exists               don't report error if database doesn't exist
  -?, --help                show this help, then exit

Connection options:
  -h, --host=HOSTNAME       database server host or socket directory
  -p, --port=PORT           database server port
  -U, --username=USERNAME   user name to connect as
  -w, --no-password         never prompt for password
  -W, --password            force password prompt
  --maintenance-db=DBNAME   alternate maintenance database
Report bugs to <pgsql-bugs@postgresql.org>.

We will now drop a database using dropdb:

$ dropdb -i pgtest
Database "pgtest" will be permanently removed.
Are you sure? (y/n) y

How it works

The best way to understand the options that can be passed to any utility is through --help. As seen in Step 1 and Step 4, we could list all the possible arguments we could pass to the createdb and dropdb utilities.

As seen in the options available with createdb in Step 1, we can use -e to print the commands sent to the server and -O to assign the ownership of the database to a user. Using -e does not stop it from running createdb but just prints the commands executed through createdb. As seen in Step 2, using -e and -O has created the database.

Another option available in PostgreSQL is creating a database using a template. Sometimes, we may create a template and wish to apply the same template to future databases. So, everything maintained inside the template database specified is copied to the database being created. As seen in step 3, we are creating a database named pgtest using a template database: percona.

When you wish to drop a database you have created, you could use the command seen in Step 5. It uses the dropdb utility to drop the database.

When you create a database or drop a database using any of the aforementioned utilities, you could simply use psql to list the databases you have created. We could either use the psql shortcut discussed in the previous recipe or query the catalog table: pg_database.

$ psql -c "\l"
 List of databases
 Name | Owner | Encoding | Collate | Ctype | Access privileges 
-----------+----------+----------+-------------+-------------+-----------------------
 pgtest | user1 | UTF8 | en_US.UTF-8 | en_US.UTF-8 | 
 postgres | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | 
 template0 | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =c/postgres +
 | | | | | postgres=CTc/postgres
 template1 | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =c/postgres +
 | | | | | postgres=CTc/postgres
(4 rows)

$ psql -c "select oid, datname from pg_database"
 oid | datname 
-------+-----------
 13881 | postgres
 16385 | pgtest
 1 | template1
 13880 | template0
(4 rows)

There's more

We have seen how to create and drop a database using the createdb and dropdb utilities. The same can also be achieved using psql through CREATE and DROP commands. It is of course very simple to run a simple CREATE DATABASE or DROP DATABASE command. But, when you need to combine that with several parameters such as owner, encoding, tablespace, and connection limit, you may need to find the correct syntax. In order to do that, you could use \help as seen in the following example:

$ psql
psql (13.1)
Type "help" for help.

postgres=# \help CREATE DATABASE
Command: CREATE DATABASE
Description: create a new database
Syntax:
CREATE DATABASE name
    [ [ WITH ] [ OWNER [=] user_name ]
           [ TEMPLATE [=] template ]
           [ ENCODING [=] encoding ]
           [ LC_COLLATE [=] lc_collate ]
           [ LC_CTYPE [=] lc_ctype ]
           [ TABLESPACE [=] tablespace_name ]
           [ ALLOW_CONNECTIONS [=] allowconn ]
           [ CONNECTION LIMIT [=] connlimit ]
           [ IS_TEMPLATE [=] istemplate ] ]

postgres=# \help DROP DATABASE
Command: DROP DATABASE
Description: remove a database
Syntax:
DROP DATABASE [ IF EXISTS ] name

So, the command to create a database that is owned by user2 with a connection limit of 200 should be as follows:

postgres=# CREATE DATABASE mydb WITH OWNER user2 CONNECTION LIMIT 200;
CREATE DATABASE


postgres=# \l+ mydb
                                              List of databases
 Name | Owner | Encoding | Collate | Ctype | Access privileges | Size | Tablespace | Description 
------+-------+----------+-------------+-------------+-------------------+---------+------------+-------------
 mydb | user2 | UTF8 | en_US.UTF-8 | en_US.UTF-8 | | 7809 kB | pg_default | 
(1 row)

Similarly, the command to drop a database, mydb, is as follows:

postgres=# DROP DATABASE mydb ;
DROP DATABASE


postgres=# \l+ mydb
                                        List of databases
 Name | Owner | Encoding | Collate | Ctype | Access privileges | Size | Tablespace | Description 
------+-------+----------+---------+-------+-------------------+------+------------+-------------
(0 rows)

Key benefits

Implement PostgreSQL 13 features to perform end-to-end modern database management

Design, manage, and build enterprise database solutions using a unique recipe-based approach

Solve common and not-so-common challenges faced while working to achieve optimal database performance

Description

PostgreSQL has become the most advanced open source database on the market. This book follows a step-by-step approach, guiding you effectively in deploying PostgreSQL in production environments. The book starts with an introduction to PostgreSQL and its architecture. You’ll cover common and not-so-common challenges faced while designing and managing the database. Next, the book focuses on backup and recovery strategies to ensure your database is steady and achieves optimal performance. Throughout the book, you’ll address key challenges such as maintaining reliability, data integrity, a fault-tolerant environment, a robust feature set, extensibility, consistency, and authentication. Moving ahead, you’ll learn how to manage a PostgreSQL cluster and explore replication features for high availability. Later chapters will assist you in building a secure PostgreSQL server, along with covering recipes for encrypting data in motion and data at rest. Finally, you’ll not only discover how to tune your database for optimal performance but also understand ways to monitor and manage maintenance activities, before learning how to perform PostgreSQL upgrades during downtime. By the end of this book, you’ll be well-versed with the essential PostgreSQL 13 features to build enterprise relational databases.

What you will learn

Understand logical and physical backups in Postgres

Demonstrate the different types of replication methods possible with PostgreSQL today

Set up a high availability cluster that provides seamless automatic failover for applications

Secure a PostgreSQL encryption through authentication, authorization, and auditing

Analyze the live and historic activity of a PostgreSQL server

Understand how to monitor critical services in Postgres 13

Manage maintenance activities and performance tuning of a PostgreSQL cluster

What do you get with Print?

Instant access to your digital copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Redeem a companion digital copy on all Print orders

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

AI Assistant (beta) to help accelerate your learning

Frequently bought together

$43.99

Developing Modern Database Applications with PostgreSQL

$48.99

$43.99

Total $ 136.97

Filter reviews by

All

Amazon verified reviews

Andrey Apr 18, 2021

Covers all the area. Very good book! Highly recommended!That’s exactly what you need to run a secure, fault tolerant and fast database!

Amazon Verified review

filippos Apr 08, 2021

According to the books description it provides recipes to build high-performance and fault-tolerant solutions. I could not agree more that this is exactly what it does. It's a rather compact book of 300 pages but manages to accumulate 120 recipes that are useful for the day to day work of a postgresql engineer. It could be a scheduled task like upgrading a cluster or setting up monitoring but also a sudden issue that requires immediate attention like identifying slow queries, getting query plans and finding the culprit. In all cases, this book provides solutions. Not worrying too much about the theoretical struggle but focusing on the solutions. However, i particularly enjoyed the MVCC part, which even though theoretical, was short and efficient, exactly as is should be. I also liked the structure of the chapters, i.e chapter 3 refers to taking a backup, chapter 4 uses parts of chapter 3 when creating a slave and chapter 5 uses the slave from chapter 4 to create a highly available system. Prometheus in monitoring and pg_repack, pg_prewarm and pg_stat_statements in the extensions were also parts that are not very often found in such books but can help immensely an engineer in his work. If I could add a recommendation I would suggest that in some cases I would prefer to have a little more information on the problem the is solved rather than just having the solution. For example when running pg_repack to rebuild tables, maybe there could be some more info on how someone identified the specific table needs to be rebuilt and what process led to this conclusion. Overall it's a great book, highly recommended to all postgresql professionals who want to have a point of reference they can use daily.

Konstantin Kondakov Jun 07, 2021

I have read dozens of PostgreSQL books - this one by far the best one. The level of technical details and best practices is truly amazing. if you need great "cheat sheet" on PostgreSQL with over 120 recipes how to make the best out of the PG engine

Cameron S May 24, 2021

If you're a DBA experienced with another RDBMS who is coming up to speed on PostgreSQL, or similarly in a DevOps role for PostgreSQL, this book is filled excellent "recipes" to help you clearly see the path to get the job done.I don't mean to imply this is a beginner's book -- far from that. The first chapter dives into cluster configuration and management. So it does assume at least an awareness of the needs of setting up a modern RDBMS environment.For every task identified, an overview is provided, followed by the specific statements necessary to set up the related configuration. Related variation, features and options are all explained clearly.As another reviewer commented, this is the book you want to have from the start of your ops career with Postgres.

Amazon Customer Jun 01, 2021

This book gives you what you need to build a good PostgreSQL server by walking you through each step needed to build a professional setup. That setup covers installation, streaming replications, auto failover, security, backups, restoration, basic tuning, and monitoring.While this books covers the pure PostgreSQL solutions, it also covers many 3rd party solutions such as pgBackRest, pgBouncer, Patroni, pgBadger, Prometheus, Grafana, pg_repack, pgAudit, etc. I use most of these 3rd party software’s myself or I use a competing one that are just as good, for example I use Collectd/Graphite/Grafana instead of node_exporter/Prometheus/Grafana, but that is because I am do not need to monitor Docker/Kubernetes clusters. Both are excellent solutions. The outcome is the same, I have the results of the monitoring displayed in Grafana.This book covers all the same topics that I teach at PostgreSQL User Group meetings and present as a PostgreSQL speaker at conferences and I would recommend it to all new database administrators or people who are upgrading from an older version of PostgreSQL to PostgreSQL 13.While I do agree with KS's review about adding more to the book, that would also make the book too thick to read. This is a good general book and if you need more details on each subject then you need to get a book specific to that subject, such as SQL language, etc. No one book can cover everything, otherwise it would just be too thick to read and too expensive to buy. This book is not for learning PostgreSQL's SQL language or for high performance tuning of PostgreSQL. If you want to learn PostgreSQL's SQL language, then you will want to start with Learn PostgreSQL, for the basics, and then move on to Mastering PostgreSQL 13 for the advanced SQL. To tune PostgreSQL for high performance, I personally use PostgreSQL 10 High Performance by Gregory Smith.The one issue that I found with this book, is that there were a few editing mistakes, but that is to be expected with a book over 300 pages. When the book was updated from PostgreSQL 12 to PostgreSQL 13 a few of the reference's still reference PostgreSQL 12 when they should now reference PostgreSQL 13. This is easy enough for the reader to catch and type correctly.This book, like all others, only covers the basics of monitoring, this is because they are trade secrets of each database administrator and the companies that sell monitoring solutions. If you make yourself familiar with the system tables, views, and functions, then you can write your own queries for monitoring PostgreSQL, just like I have personally done. It is not hard; it just takes patience.Please Note: This physical copy of PostgreSQL 13 Cookbook was donated to me by Packt Publishing, but the views are mine alone based on being a PostgreSQL Database Administrator for the last 20 years aka 2001. I also already had access to this book through my personally paid for Packt Publishing subscription which included this book electronically and I have also previously purchased many PostgreSQL books from Packt Publishing.

PostgreSQL 13 Cookbook: Over 120 recipes to build high-performance and fault-tolerant PostgreSQL database solutions

What do you get with Print?