Have an Entity Framework field reference one of several derived tables via a discriminator (Using TPT) - sql

Question

I'm trying to find a way to create this relationship from Entity Framework 5's Code First.
In the example below, I have some Stock which can either belong to a Warehouse or a Row.
Stock Table
'Id', 'SerialNo', 'Discriminator', 'LocationId'
345, ABC123, Warehouse, 4
123, ABC124, Row, 12
Warehouse Table
'Id', 'Name'
4, WH-One
8, WH-Two
Row Table
'Id', 'Name'
6, RowA
12, RowB
The Discriminator column on the table Stock determines which of the related tables the LocationId is referring to. For example:
Stock with Id '345' has a reference to row with Id: 4 (WH-One) on the Warehouse table
Can this type of relationship be mapped with EF Code First? It's certainly no trouble to query against this structure in SQL Server.
SELECT Stock.SerialNo, COALESCE(Warehouse.Name, Row.Name) AS Name
FROM Stock
LEFT OUTER JOIN Warehouse ON Stock.Id = Warehouse.Id AND Stock.Discriminator = 'Warehouse'
LEFT OUTER JOIN Row ON Stock.Id = Row.Id AND Stock.Discriminator = 'Row'
Which should return:
SerialNo, Name
ABC123, WH-One
ABC124, RowB
Ideally, I'd like to have either an interface or abstract base class which Warehouse and Row and derive from. And a navigation property called Location that would refer to either table cast to the abstract/interface.
Alternatively, I'd like to know if anyone has a better suggestion to describe a relationship in EF Code First that allows one entity to reference one of several other similar entities.

Answer 1

It's Code First so I would do this:
First - create the classes I want in code:
public abstract class Location
{
public int ID { get; set; }
public string Name { get; set; }
public ICollection<Stock> StockItems { get; set; }
}
public class Warehouse : Location
{
public int NumberOfLoadingDocks { get; set; }
}
public class Row : Location
{
public int NumberOfShelves { get; set; }
}
public class Stock
{
public int ID { get; set; }
public string SerialNo { get; set; }
public int LocationID { get; set; }
}
Then add them to the context:
public partial class MyContext : DbContext
{
public DbSet<Location> Locations { get; set; }
public DbSet<Warehouse> Warehouses { get; set; }
public DbSet<Row> Rows { get; set; }
public DbSet<Stock> Stocks { get; set; }
}
Then in Package-Manager console:
Add-Migration "Locations"
Update-Database -Script
That lets me see the tables Entity Framework would create:
CREATE TABLE [dbo].[Stocks] (
[ID] [int] NOT NULL IDENTITY,
[SerialNo] [nvarchar](max),
[LocationID] [int] NOT NULL,
CONSTRAINT [PK_dbo.Stocks] PRIMARY KEY ([ID])
)
CREATE INDEX [IX_LocationID] ON [dbo].[Stocks]([LocationID])
CREATE TABLE [dbo].[Locations] (
[ID] [int] NOT NULL IDENTITY,
[Name] [nvarchar](max),
[NumberOfShelves] [int],
[NumberOfLoadingDocks] [int],
[Discriminator] [nvarchar](128) NOT NULL,
CONSTRAINT [PK_dbo.Locations] PRIMARY KEY ([ID])
)
ALTER TABLE [dbo].[Stocks] ADD CONSTRAINT [FK_dbo.Stocks_dbo.Locations_LocationID] FOREIGN KEY ([LocationID]) REFERENCES [dbo].[Locations] ([ID])
INSERT [dbo].[__MigrationHistory]([MigrationId], [ContextKey], [Model], [ProductVersion])
VALUES (N'201309120832257_Locations'....
Not the same tables that you have. This is Table-per-Hierarchy inheritance. If you are not happy with that then you need to look at Table Per Type inheritance
EDIT
To get TPT inheritance you can add the Table attribute to the inherited classes like this:
[System.ComponentModel.DataAnnotations.Schema.Table("Warehouses")]
public class Warehouse : Location
{
public int NumberOfLoadingDocks { get; set; }
}
[System.ComponentModel.DataAnnotations.Schema.Table("Rows")]
public class Row : Location
{
public int NumberOfShelves { get; set; }
}
And now you get separate tables for each type:
CREATE TABLE [dbo].[Locations] (
[ID] [int] NOT NULL IDENTITY,
[Name] [nvarchar](max),
CONSTRAINT [PK_dbo.Locations] PRIMARY KEY ([ID])
)
CREATE TABLE [dbo].[Rows] (
[ID] [int] NOT NULL,
[NumberOfShelves] [int] NOT NULL,
CONSTRAINT [PK_dbo.Rows] PRIMARY KEY ([ID])
)
CREATE INDEX [IX_ID] ON [dbo].[Rows]([ID])
CREATE TABLE [dbo].[Warehouses] (
[ID] [int] NOT NULL,
[NumberOfLoadingDocks] [int] NOT NULL,
CONSTRAINT [PK_dbo.Warehouses] PRIMARY KEY ([ID])
)
CREATE INDEX [IX_ID] ON [dbo].[Warehouses]([ID])
ALTER TABLE [dbo].[Stocks] ADD CONSTRAINT [FK_dbo.Stocks_dbo.Locations_LocationID] FOREIGN KEY ([LocationID]) REFERENCES [dbo].[Locations] ([ID])
ALTER TABLE [dbo].[Rows] ADD CONSTRAINT [FK_dbo.Rows_dbo.Locations_ID] FOREIGN KEY ([ID]) REFERENCES [dbo].[Locations] ([ID])
ALTER TABLE [dbo].[Warehouses] ADD CONSTRAINT [FK_dbo.Warehouses_dbo.Locations_ID] FOREIGN KEY ([ID]) REFERENCES [dbo].[Locations] ([ID])
And if you are not happy with that you should look at Table Per Concrete Type Inheritance...