In Derby (an embedded database written in Java which is mostly used for testing or prototyping) there are "freeze" and "unfreeze" commands which can be used during an online backup. "Freeze" simply causes all database accesses to block until "unfreeze" is called. This is useful for backing up using an external program, which you might do if the external program is much faster than using Derby's internal backup solution. For my use case, I can take a snapshot almost instantaneously using some built-in filesystem utilities, so it is a constant-time operation (not O(length of DB files)).
I'm migrating an application which has outgrown Derby to PostgreSQL, and I was wondering if there's anything comparable there which I can use to quiesce all connections. Also, I'd prefer to know what my serialization point is from inside my application so that I don't get caught in some awkward state, so being able to pause/resume all other accesses is really nice-to-have for me.
Since PostgreSQL has a transaction log, I could just take a snapshot without "freeze"ing, but the snapshot would need to be run through PostgreSQL's recovery mechanism before I can use it because otherwise what's stored on disk would be the same as if I pulled the plug on a normal filesystem. This solution is not ideal.
EDIT I learned that pg_start_backup() is close, but it doesn't cause incoming transactions to block until a matching call to pg_stop_backup(), forcing me to do a point-in-time-recovery back to the transaction id pg_start_backup() returns from a filesystem snapshot. It would be nice not to have to actually shutdown PostgreSQL to get this (perhaps there is a pseudo-shutdown command that keeps connections open?).
Best Answer
There's no exact equivalent to what you want. Options include:
Atomic file-system snapshot
If you're using an atomic file system snapshot you don't need to freeze the database. It might make recovery a little faster if you force a
CHECKPOINTfirst, but that's about it. When you take a filesystem snapshot and copy it, then start the copy, to PostgreSQL it's as if it crashed and is starting back up. That's perfectly fine, it's crash safe and designed to work that way.This approach is only valid if the snapshot is atomic - it's all at the same virtual instant. You can't get an atomic snapshot across multiple file systems (on Linux, at least), so if your DB is split across multiple tablespaces or WAL is on a separate disk to the heap you cannot use this approach.
pg_start_backup/pg_stop_backupIf you can't do an atomic snapshot you can enable WAL archiving, run
pg_start_backup, copy the DB, runpg_stop_backupand capture the last WAL archives generated.It's a bit more complicated, but it gives you a consistent backup without stopping writes and without needing file-system level atomic snapshots.
pg_basebackupAn alternative to using
pg_start_backupandpg_stop_backupis to usepg_basebackupto do a streaming copy of the DB over the PostgreSQL replication protocol with--xlog-method=stream. This requires only a PostgreSQL replication connection, doesn't require the DB to be stopped, and is pretty seamless.--xlog-method=streamwas only added in pretty recent versions, andpg_basebackupits self is fairly new.pg_dumpI didn't initially mention it because you were looking for external tools, but there's always
pg_dump, which gets aSERIALIZABLEsnapshot of the database and dumps it. The DB keeps running like normal (it can still accept writes) and the dump is entirely internally consistent from the time you started the dump.Write quiescence
Stopping all incoming transactions won't stop PostgreSQL writing. It'll still have
VACUUMwork to do with autovacuum, checkpoints to perform, stats to write, etc.There's no feature in Pg to stop all writes at this point. It might be nice to add, but I'm not aware of anyone working on it.
Some file systems, like XFS, support write freezing at the file system level; this causes all writes to block until the freeze is released. It's safe to freeze all file systems then copy all file systems.