Take the 2-minute tour ×
Database Administrators Stack Exchange is a question and answer site for database professionals who wish to improve their database skills and learn from others in the community. It's 100% free, no registration required.

How do most "popular" (MySQL, Postgres...) database system handle altering tables on live production databases (like adding, deleting or changing the type of colums)?

I know the correct way is to backup everything schedule downtime and do then do the changes.

But... does any current database system support doing these things "on-line" without stopping anything? (maybe just delaying the queries that reference a column that is just being changed/deleted)

And what does it happen when I just do an ALTER TABLE... on a live running database? Does everything stop when this happens? Can data get corrupted? etc.

Again, I'm mostly referring to Postgres or MySQL as these are what I encounter.

(And, yes, anytime I had to do this before I did it "the right way", backing things up, scheduling downtine etc. ...but I just want to know if it's possible to do this sort and things "quick and dirty" or if there is any DB system that actually has support for "quick, live and dirty" schema changes)


Someone just suggested Online Schema Change for MySQL from Facebook script (with a tutorial here and source here)... seems like a nice way to automate a the set of "hacky" ways to do it... has anyone ever used it in something resemblig production?

share|improve this question
1  
Note: the "correct way" specificified is relative to MySQL and not to PostgreSQL. The "correct way" in PostgreSQL is typically very easy, though it can be involved. Use of pg_reorg can help with the more difficult scenarios. –  Sean Oct 19 '12 at 5:17
add comment

migrated from stackoverflow.com Oct 18 '12 at 13:11

This question came from our site for professional and enthusiast programmers.

5 Answers

up vote 8 down vote accepted

When you issue an ALTER TABLE in PostgreSQL it will take an ACCESS EXCLUSIVE lock that blocks everything including SELECT. However, this lock can be quite brief if the table doesn't require re-writing, no new UNIQUE, CHECK or FOREIGN KEY constraints need expensive full-table scans to verify, etc.

If in doubt, you can generally just try it! All DDL in PostgreSQL is transactional, so it's quite fine to cancel an ALTER TABLE if it takes too long and starts holding up other queries. The lock levels required by various commands are documented in the locking page.

Some normally-slow operations can be sped up to be safe to perform without downtime. For example, if you have table t and you want to change column customercode integer NOT NULL to text because the customer has decided all customer codes must now begin with an X, you could write:

ALTER TABLE t ALTER COLUMN customercode TYPE text USING ( 'X'||customercode::text );

... but that would lock the whole table for the re-write. So does adding a column with a DEFAULT. It can be done in a couple of steps to avoid the long lock, but applications must be able to cope with the temporary duplication:

ALTER TABLE t ADD COLUMN customercode_new text;
BEGIN;
LOCK TABLE t IN EXCLUSIVE MODE;
UPDATE t SET customercode_new = 'X'||customercode::text;
ALTER TABLE t DROP COLUMN customercode;
ALTER TABLE t RENAME COLUMN customercode_new TO customercode;
COMMIT;

This will only prevent writes to t during the process; the lock name EXCLUSIVE is somewhat deceptive in that it excludes everything except SELECT; the ACCESS EXCLUSIVE mode is the only one that excludes absolutely everyting. See lock modes. There's a risk that this operation could deadlock-rollback due to the lock upgrade required by the ALTER TABLE, but at worst you'll just have to do it again.

You can even avoid that lock and do the whole thing live by creating a trigger function on t that whenever an INSERT or UPDATE comes in, automatically populates customercode_new from customercode.

There are also built-in tools like CREATE INDEX CONCURRENTLY and ALTER TABLE ... ADD table_constraint_using_index that're designed to allow DBAs to reduce exclusive locking durations by doing work more slowly in a concurrency-friendly way.

The pg_reorg tool or its successor pg_repack can be used for some table restructuring operations as well.

share|improve this answer
    
The key thing in what @Craig said was, "if it oesn't require re-writing." Using an ALTER TABLE t ADD COLUMN i INT is a fast operation (typically <1ms) once the lock is acquired. Acquiring the lock can queue up connections, however, so it's not "free" ... though it's world's better than what you have to do in MySQL. Adding a NOT NULL constraint is more difficult and not for the feignt of heart. –  Sean Oct 19 '12 at 5:16
    
It seems to be consensus that pg_repack is the improved successor of pg_reorg. –  Erwin Brandstetter Apr 9 '13 at 23:47
    
@ErwinBrandstetter Thanks, amended –  Craig Ringer Apr 9 '13 at 23:58
add comment

Shutting the system down and doing all changes at once may be very risky. If something goes wrong, and frequently it does, there is no easy way back.

As an Agile developer, I sometimes need to refactor tables without any downtime at all, as those tables are being modified and read from.

The following approach has low risk, because the change is done in several low-risk steps that are very easy to roll back:

  • Make sure that all the modules accessing the table are well covered with automated tests.
  • Create a new table. Alter all procedures that modify the old table, so that they modify both old and new tables.
  • Migrate existing data into new structure. Do it in smallish batches, so that it does not seriously impact the overall performance on the server.
  • Verify that the migration of data succeeded.
  • Redirect some of the selecting procedures from the old table to the new ones. Use automated tests to make sure that the changed modules are still correct. Make sure their performance is acceptable. Deploy the altered procedures.
  • Repeat the previous step until all the reports use the new table.
  • Change the procedures that modify the tables, so that they only access the new table.
  • Archive the old table and remove it from the system.

We have used this approach many times to change large live production tables without downtime, with no issues at all.

share|improve this answer
2  
great... but that's exactly the type of "pain" that I'm looking to avoid :) –  NeuronQ Oct 18 '12 at 16:14
add comment

Percona has comes up with its own tool for performing online schema changes

The tool is called pt-online-schema-change

It involves triggers, so please read the documentation carefully.

According to the Documentation, the major operations done are

  • Sanity checks
  • Chunking
  • Online schema change
    • Create and alter temporary table
    • Capture changes from the table to the temporary table
    • Copy rows from the table to the temporary table
    • Synchronize the table and the temporary table
    • Swap/rename the table and the temporary table
    • Cleanup
share|improve this answer
    
thanks, seems like a "soldified" version of Facebook's approach that I could trust more... –  NeuronQ Oct 18 '12 at 16:12
add comment

Yes, many modern databases will allow you to just add a column or change the characteristics of a column, like adding or removing nullable.

If you drop a column, data will be lost, but there is not much fear of corruption.

share|improve this answer
add comment

To address the question about what happens with an ALTER TABLE statement, it depends on the extent of your changes. In specific cases, if you add a new column, at least in MS SQL Server, the engine will create a temporary copy of the table, while it creates the new table definition, and then inserts the data back in there. For the duration of the change, the table thus would be inaccessible to users.

An example of the specific operations for MSSQL server is here: http://support.microsoft.com/kb/956176/en-us

I would assume that other RMDBs have similar methods, though the exact implementation would be something you would have to verify with the vendor documentation.

share|improve this answer
    
-1 This is completely wrong for SQL Server: "If you add a new column, at least in MS SQL Server, the engine will create a temporary copy of the table, while it creates the new table definition, and then inserts the data back in there" –  AlexKuznetsov Oct 18 '12 at 14:09
    
@AlexKuznetsov - I figured the preceding line, as well as the link with some of the cases listed would clarify this does not always happen. I amended the sentence to better reflect this. –  SchmitzIT Oct 18 '12 at 14:17
1  
You are mentioning the behavior of the GUI, SSMS, not the behavior of SQL Server itself. Following your link, the advice is to use T-SQL directly to make DDL changes. SSMS is not a very good tool for changing DDL. –  AlexKuznetsov Oct 18 '12 at 15:05
    
@AlexKuznetsov - I read the article as saying that there's risks involved, but not as a discouragement. Anyway, I didn't link the article for the GUI bit, but as an indication of some of the operations that lead to an ALTER statement leading to the creation of a temporary table due to changes in the underlying data structure. I haven't tested whether the exact same thing applies when issuing the statement directly from T-SQL, but I would think the process is pretty similar and that SL Server does the legwork behind the scenes. –  SchmitzIT Oct 18 '12 at 16:18
    
You can start Profiler, execute ALTER TABLE statement directly, and see what is happening. Then you can alter a table via a dialog box, and see for yourself the commands being executed. –  AlexKuznetsov Oct 19 '12 at 1:54
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.