Recently, I’ve been writing lots of raw SQL code that is either a complex
VIEW, or a
FUNCTION. Much of the time these will be used as the “source” for a Django model, but not always. Sometimes, there are complex functions that need to be run as a trigger in Postgres, or even a rule to execute when attempting a write operation on a view.
Anyway, these definitions are all code, and should be stored within the project they belong to. Using Django’s migrations you can apply them at the appropriate time, using a
Hovewer, you don’t really want to have the raw SQL in the migration file. Depending upon the text editor, it may not syntax highlight correctly, and finding the correct definition can be difficult.
Similarly, you don’t want to just have a single file, because to recreate the database migration sequence, it needs to apply the correct version at the correct time (otherwise, other migrations may fail to apply).
Some time ago, I adopted a policy of manually versioning these files. I have a pattern of naming, that seemed to be working well:
special_app/ migrations/ __init__.py 0001_initial.py 0002_update_functions.py sql/ foo.function.0001.sql foo.function.0002.sql foo.trigger.0001.sql bar.view.0001.sql
The contents of the SQL files are irrelevant, and the migrations mostly so. There is a custom migration operation I wrote that loads the content from a file:
LoadSQLScript('special_app', 'foo.function', 1)
The mechanics of how it works are not important.
So, this had been working well for several months, but I had a nagging feeling that the workflow was not ideal. This came to a head in my mind when I recognised that doing code review on database function/view changes was next to impossible.
See, the problem is that there is a completely new file each time you create a new version of a definition.
Instead, I’ve come up with a similar, but different solution. You still need to have versioned scripts for the purpose of historical migrations, but the key difference is that you don’t actually write these. Instead, you have something that notices that the “current” version of a definition is different to the latest version snapshot. You then also have a tool that copies the current version to a new snapshot, and creates a migration.
You can still modify a snapshot (for instance, if you’ve already created one, but it’s only in your current development tree), but mostly you don’t need to.
$ ./manage.py check System check identified some issues: WARNINGS: ?: (sql_helpers.W002) The versioned migration file for core: iso8601.function.sql is out of date, and needs to be updated or a new version created.
Oh, thanks for that. Checking the file, I see that it does indeed need a new version:
$ ./manage.py make_sql_migrations core ... Copied <project>/core/sql/iso8601.function.sql to version 0002
You still need to ensure that any dependencies between SQL files are dealt with appropriately (for instance, a function that relies on a newly added column to a view needs to have that view’s definition updated before the function can be updated). But this is a much smaller problem, and something that your database should complain about when you try to apply the migrations.
I haven’t packaged this up yet, it’s currently only an internal app, as I want to use it a bit for the next little while and see what else shakes out. I was pretty sure the way I was doing it before was “the best way” just after I thought that up, so we’ll see what happens.