Extending the Entity Framework Provider Model to support DDL
As part of the first previews of Code-Only we shared some code to create a database:
// Create a context using code-only
using (var mycontext = builder.Create(dbConnection))
// Create the database if it doesn’t already exist
// Standard EF code goes here.
But in the first preview of Code-Only this code only worked against SQL Server.
The problem is that our public Provider Model (i.e. DbProviderServices) has no Database Definition Language or DDL features.
Provider Model Changes
To support DDL features across different databases, we plan to extend DbProviderServices, with DDL specific services.
These services will be accessed through these public methods:
public string CreateDatabaseScript(
public void CreateDatabase(
public bool DatabaseExists(
public void DeleteDatabase(
Now internally those methods will call through to the following ‘protected virtual’ methods which will do the actual work:
protected virtual string DbCreateDatabaseScript(
protected virtual void DbCreateDatabase(
protected virtual bool DbDatabaseExists(
protected virtual void DbDeleteDatabase(
And the base implementations of these methods in DbProviderServices will simply throw ProviderIncompatibleExceptions.
Which means the provider writers job will be to override these ‘protected virtual’ methods with an implementation that makes sense for their backend database.
The key is to understand that the StoreItemCollection (aka the SSDL or StorageModel part of the EDMX) represents the intended shape of the database.
This means the provider writer will need to iterate over the EntitySets (tables) and the corresponding EntityTypes (table structures) in the StoreItemCollection and create / drop / script the database and tables as required.
Provider writers will be expected to override these functions so that:
- DbCreateDatabaseScript: creates a native text command to create the tables and foreign key constraints defined in the StoreItemCollection. I.e. for SqlClient this would be the contents of a .sql DDL file.
- DbCreateDatabase: is similar to DbCreateDatabaseScript except it should actually goes ahead and create the database, tables and foreign key constraints.
- DbDatabaseExists: checks to see if the database exists. The SqlClient provider will simply check that the database itself exists, but custom provider writers could get more fancy and check to see if every table / foreign key constraint is found too.
- DbDeleteDatabase: should go ahead and delete the database, or if the database server has a single database model (like Oracle) the provider writer should delete just the tables defined in the StoreItemCollection.
Simplifying Wrapping Providers
We are also planning something to simplify writing Wrapping Providers. A wrapping provider is just a provider that wraps an existing provider (i.e. SqlClient) and adds additional services (i.e. Auditing, Logging, Caching etc).
Jarek has some some sample wrapping providers if you are interested.
Today writing a wrapping provider is a little tricky, in fact one ‘protected’ method is impossible to wrap without reflection. So to help we plan to add one public wrapper method:
public DbCommandDefinition CreateCommandDefinition(
One of the reasons we plan on doing this, is we think people might take a ‘basic’ provider that has no DDL support and wrap it to add DDL support.
End User API
Now so far we’ve been looking at the planned extensions to Provider Services, but Provider Services is a very low level API that few developers will ever program against.
Most people will work directly against the ObjectContext, to which we plan to add these methods:
public void CreateDatabase()
public void DeleteDatabase();
public bool DatabaseExists();
public String CreateDatabaseScript();
This little snippet shows how easy it will be to script, create, check and delete a database:
MyContext ctx = new MyContext();
String sql = ctx.CreateDatabaseScript();
As you it could hardly be easier to use.
While Code-Only provides the catalyst to add DDL support to the Entity Framework’s Provider model, this feature is about more than just Code-Only.
In fact we think this feature will add significantly to the usability of the Entity Framework.
But as always we are keen to hear what you think.
Program Manager, Entity Framework Team, Microsoft.
This post is part of the transparent design exercise in the Entity Framework Team. To understand how it works and how your feedback will be used please look at this post .