Question

I would like to approach database versioning and automated upgrades in NHibernate from a different direction than most of the strategies proposed out there.

As each object is defined by an XML mapping, I would like to take size and checksum for each mapping file/ configuration and store that in a document database (raven or something) along with a potential custom update script. If no script is found, use the NHibernate DDL generator to update the object schema. This way I can detect changes, and if I need to make DML changes in addition to DDL, or perform a carefully ordered transformation, I can theoretically do so in a controlled, testable manner. This should also maintain a certain level of persistence-layer agnosticism, although I’d imagine the scripts would still necessarily be database system-specific.

The trick would be, generating the “old” mapping files from the database and comparing them to the current mapping files. I don’t know if this is possible. I also don’t know if I’m missing anything else that would make this strategy prohibitively impractical.

My question, then: how practical is this strategy, and why?

Answer 1

what i did to solve just that problem

1. version the database in a table called SchemaVersion
2. query the table to see if schema is up to date (required version stored in DAL), if yes goto 6.
3. get updatescript with version == versionFromBb from resources/webservices/…
4. run the script which also alters the schemaversion to the new version
5. goto 2.
6. run app

to generate the scripts i have used 2 options

1. support one rdbms: run SchemaUpdate to export into file and add DML statements manually
2. support multiple rdbms: use Nhibernate class Table to generate at runtime ddl to add/alter/delete tables and code which uses a session DML

Update:

"what method did you use to store the current version"

small example

something like this

public static class Constants
{
    public static readonly Version DatabaseSchemaVersion = new Version(1, 2, 3, 4);
}

public class DBMigration
{
    private IDictionary<Version, Action> _updates = new Dictionary<Version, Action>();
    private Configuration _config;
    private Dialect _dialect;
    private IList<Action<ISession>> _actions = new List<Action<ISession>>(16);
    private string _defaultCatalog;
    private string _defaultSchema;

    private void CreateTable(string name, Action<Table> configuretable)
    {
        var table = new Table(name);
        configuretable(table);

        string createTable = table.SqlCreateString(_dialect, _config.BuildMapping(), _defaultCatalog, _defaultSchema);
        _actions.Add(session => session.CreateSQLQuery(createTable).ExecuteUpdate());
    }

    private void UpdateVersionTo(Version version)
    {
        _actions.Add(session => { session.Get<SchemaVersion>(1).Value = version; session.Flush(); });
    }

    private void WithSession(Action<session> action)
    {
        _actions.Add(action);
    }

    public void Execute(Configuration config)
    {
        _actions.Clear();
        _defaultCatalog = config.Properties[NH.Environment.DefaultCatalog];
        _defaultSchema = config.Properties[NH.Environment.DefaultSchema];
        _config = config;
        _dialect = Dialect.GetDialect(config.Properties);

        using (var sf = _config.BuildSessionFactory())
        using (var session = sf.OpenSession())
        using (var tx = session.BeginTransaction())
        {
            Version dbVersion = session.Get<SchemaVersion>(1).Value;
            while (dbVersion < Constants.DatabaseSchemaVersion)
            {
                _actions.Clear();
                _updates[dbVersion].Invoke(); // init migration, TODO: error handling
                foreach (var action in _actions)
                {
                    action.Invoke(session);
                }
                tx.Commit();
                session.Clear();
                dbVersion = session.Get<SchemaVersion>(1).Value;
            }
        }
    }

    public DBMigration()
    {
        _updates.Add(new Version(1, 0, 0, 0), UpdateFromVersion1);
        _updates.Add(new Version(1, 0, 1, 0), UpdateFromVersion1);
        ...
    }

    private void UpdateFromVersion1()
    {
        AddTable("Users", table => table.AddColumn(...));
        WithSession(session => session.CreateSqlQuery("INSERT INTO ..."));
        UpdateVersionTo(new Version(1,0,1,0));
    }

    ...
}