public void Can_use_relational_model_with_functions()
{
var modelBuilder = CreateConventionModelBuilder();
modelBuilder.Entity <Order>(
cb =>
{
cb.ToFunction("GetOrders");
cb.Ignore(c => c.Customer);
cb.Ignore(c => c.Details);
cb.Ignore(c => c.DateDetails);
cb.Property(c => c.AlternateId).HasColumnName("SomeName");
cb.HasNoKey();
});
modelBuilder.HasDbFunction(
typeof(RelationalModelTest).GetMethod(
nameof(GetOrdersForCustomer), BindingFlags.NonPublic | BindingFlags.Static));
var model = modelBuilder.FinalizeModel().GetRelationalModel();
Assert.Single(model.Model.GetEntityTypes());
Assert.Equal(2, model.Functions.Count());
Assert.Empty(model.Views);
Assert.Empty(model.Tables);
var orderType = model.Model.FindEntityType(typeof(Order));
Assert.Null(orderType.FindPrimaryKey());
Assert.Equal(2, orderType.GetFunctionMappings().Count());
var orderMapping = orderType.GetFunctionMappings().First();
Assert.True(orderMapping.IsSharedTablePrincipal);
Assert.True(orderMapping.IsSplitEntityTypePrincipal);
Assert.True(orderMapping.IsDefaultFunctionMapping);
var tvfMapping = orderType.GetFunctionMappings().Last();
Assert.True(tvfMapping.IsSharedTablePrincipal);
Assert.True(tvfMapping.IsSplitEntityTypePrincipal);
Assert.False(tvfMapping.IsDefaultFunctionMapping);
Assert.True(orderMapping.IncludesDerivedTypes);
Assert.Equal(
new[] { nameof(Order.AlternateId), nameof(Order.CustomerId), nameof(Order.Id), nameof(Order.OrderDate) },
orderMapping.ColumnMappings.Select(m => m.Property.Name));
var ordersFunction = orderMapping.StoreFunction;
Assert.Same(ordersFunction, model.FindFunction(ordersFunction.Name, ordersFunction.Schema, new string[0]));
Assert.Equal(
new[] { orderType },
ordersFunction.EntityTypeMappings.Select(m => m.EntityType));
Assert.Equal(
new[] { nameof(Order.CustomerId), nameof(Order.Id), nameof(Order.OrderDate), "SomeName" },
ordersFunction.Columns.Select(m => m.Name));
Assert.Equal("GetOrders", ordersFunction.Name);
Assert.Null(ordersFunction.Schema);
Assert.False(ordersFunction.IsBuiltIn);
Assert.False(ordersFunction.IsShared);
Assert.Null(ordersFunction.ReturnType);
var orderDate = orderType.FindProperty(nameof(Order.OrderDate));
Assert.Equal(2, orderDate.GetFunctionColumnMappings().Count());
var orderDateMapping = orderMapping.ColumnMappings.Single(m => m.Property == orderDate);
Assert.NotNull(orderDateMapping.TypeMapping);
Assert.Equal("default_datetime_mapping", orderDateMapping.TypeMapping.StoreType);
Assert.Same(orderMapping, orderDateMapping.FunctionMapping);
var orderDateColumn = orderDateMapping.Column;
Assert.Same(orderDateColumn, ordersFunction.FindColumn(nameof(Order.OrderDate)));
Assert.Same(orderDateColumn, orderDate.FindColumn(StoreObjectIdentifier.DbFunction(ordersFunction.Name)));
Assert.Same(orderDateColumn, ordersFunction.FindColumn(orderDate));
Assert.Equal(new[] { orderDate }, orderDateColumn.PropertyMappings.Select(m => m.Property));
Assert.Equal(nameof(Order.OrderDate), orderDateColumn.Name);
Assert.Equal("default_datetime_mapping", orderDateColumn.StoreType);
Assert.False(orderDateColumn.IsNullable);
Assert.Same(ordersFunction, orderDateColumn.Function);
Assert.Same(orderMapping, ordersFunction.EntityTypeMappings.Single());
var tvfFunction = tvfMapping.StoreFunction;
Assert.Same(tvfMapping, tvfFunction.EntityTypeMappings.Single());
Assert.Same(tvfFunction, model.FindFunction(tvfFunction.Name, tvfFunction.Schema, new[] { "default_int_mapping" }));
Assert.Equal(nameof(GetOrdersForCustomer), tvfFunction.Name);
Assert.Null(tvfFunction.Schema);
Assert.False(tvfFunction.IsBuiltIn);
Assert.False(tvfFunction.IsShared);
Assert.Null(tvfFunction.ReturnType);
var tvfDbFunction = tvfFunction.DbFunctions.Single();
Assert.Same(tvfFunction, tvfDbFunction.StoreFunction);
Assert.Same(model.Model.GetDbFunctions().Single(f => f.Parameters.Count() == 1), tvfDbFunction);
Assert.Same(tvfFunction.Parameters.Single(), tvfDbFunction.Parameters.Single().StoreFunctionParameter);
Assert.Same(tvfDbFunction.Parameters.Single(), tvfFunction.Parameters.Single().DbFunctionParameters.Single());
}
private static void AssertTables(IRelationalModel model, Mapping mapping)
{
var orderType = model.Model.FindEntityType(typeof(Order));
var orderMapping = orderType.GetTableMappings().Single();
Assert.True(orderMapping.IncludesDerivedTypes);
Assert.Equal(
new[] { nameof(Order.Id), nameof(Order.AlternateId), nameof(Order.CustomerId), nameof(Order.OrderDate) },
orderMapping.ColumnMappings.Select(m => m.Property.Name));
var ordersTable = orderMapping.Table;
Assert.Same(ordersTable, model.FindTable(ordersTable.Name, ordersTable.Schema));
Assert.Equal(
new[]
{
nameof(Order), "OrderDetails.BillingAddress#Address", "OrderDetails.ShippingAddress#Address", nameof(OrderDetails)
},
ordersTable.EntityTypeMappings.Select(m => m.EntityType.DisplayName()));
Assert.Equal(
new[]
{
nameof(Order.Id),
nameof(Order.AlternateId),
nameof(Order.CustomerId),
"Details_BillingAddress_City",
"Details_BillingAddress_Street",
"Details_ShippingAddress_City",
"Details_ShippingAddress_Street",
nameof(Order.OrderDate)
},
ordersTable.Columns.Select(m => m.Name));
Assert.Equal("Order", ordersTable.Name);
Assert.Null(ordersTable.Schema);
Assert.False(ordersTable.IsExcludedFromMigrations);
Assert.True(ordersTable.IsShared);
var orderDate = orderType.FindProperty(nameof(Order.OrderDate));
var orderDateMapping = orderDate.GetTableColumnMappings().Single();
Assert.NotNull(orderDateMapping.TypeMapping);
Assert.Equal("default_datetime_mapping", orderDateMapping.TypeMapping.StoreType);
Assert.Same(orderMapping, orderDateMapping.TableMapping);
var orderDateColumn = orderDateMapping.Column;
Assert.Same(orderDateColumn, ordersTable.FindColumn("OrderDate"));
Assert.Same(orderDateColumn, orderDate.FindColumn(StoreObjectIdentifier.Table(ordersTable.Name, ordersTable.Schema)));
Assert.Same(orderDateColumn, ordersTable.FindColumn(orderDate));
Assert.Equal("OrderDate", orderDateColumn.Name);
Assert.Equal("default_datetime_mapping", orderDateColumn.StoreType);
Assert.False(orderDateColumn.IsNullable);
Assert.Same(ordersTable, orderDateColumn.Table);
var orderPk = orderType.FindPrimaryKey();
var orderPkConstraint = orderPk.GetMappedConstraints().Single();
Assert.Equal("PK_Order", orderPkConstraint.Name);
Assert.Equal(nameof(Order.Id), orderPkConstraint.Columns.Single().Name);
Assert.Same(ordersTable, orderPkConstraint.Table);
Assert.True(orderPkConstraint.GetIsPrimaryKey());
Assert.Same(orderPkConstraint, ordersTable.UniqueConstraints.Last());
Assert.Same(orderPkConstraint, ordersTable.PrimaryKey);
var orderAk = orderType.GetKeys().Single(k => k != orderPk);
var orderAkConstraint = orderAk.GetMappedConstraints().Single();
Assert.Equal("AK_AlternateId", orderAkConstraint.Name);
Assert.Equal(nameof(Order.AlternateId), orderAkConstraint.Columns.Single().Name);
Assert.Same(ordersTable, orderAkConstraint.Table);
Assert.False(orderAkConstraint.GetIsPrimaryKey());
Assert.Same(orderAkConstraint, ordersTable.UniqueConstraints.First());
var orderDateIndex = orderType.GetIndexes().Single(i => i.Properties.Any(p => p.Name == nameof(Order.OrderDate)));
var orderDateTableIndex = orderDateIndex.GetMappedTableIndexes().Single();
Assert.Equal("IX_OrderDate", orderDateTableIndex.Name);
Assert.Equal(nameof(Order.OrderDate), orderDateTableIndex.Columns.Single().Name);
Assert.Same(ordersTable, orderDateTableIndex.Table);
Assert.True(orderDateTableIndex.IsUnique);
Assert.Null(orderDateTableIndex.Filter);
Assert.Equal(orderDateTableIndex, ordersTable.Indexes.Last());
var orderCustomerIndex = orderType.GetIndexes().Single(i => i.Properties.Any(p => p.Name == nameof(Order.CustomerId)));
var orderTableIndex = orderCustomerIndex.GetMappedTableIndexes().Single();
Assert.Equal("IX_Order_CustomerId", orderTableIndex.Name);
Assert.Equal(nameof(Order.CustomerId), orderTableIndex.Columns.Single().Name);
Assert.Same(ordersTable, orderTableIndex.Table);
Assert.False(orderTableIndex.IsUnique);
Assert.Null(orderTableIndex.Filter);
Assert.Equal(orderCustomerIndex, orderTableIndex.MappedIndexes.Single());
Assert.Same(orderTableIndex, ordersTable.Indexes.First());
var orderDateFk = orderType.GetForeignKeys().Single(fk => fk.PrincipalEntityType.ClrType == typeof(DateDetails));
var orderDateFkConstraint = orderDateFk.GetMappedConstraints().Single();
Assert.Equal("FK_DateDetails", orderDateFkConstraint.Name);
Assert.Equal(nameof(Order.OrderDate), orderDateFkConstraint.Columns.Single().Name);
Assert.Equal(nameof(DateDetails.Date), orderDateFkConstraint.PrincipalColumns.Single().Name);
Assert.Equal("DateDetails", orderDateFkConstraint.PrincipalTable.Name);
var orderCustomerFk = orderType.GetForeignKeys().Single(fk => fk.PrincipalEntityType.ClrType == typeof(Customer));
var orderCustomerFkConstraint = orderCustomerFk.GetMappedConstraints().Single();
Assert.Equal("FK_Order_Customer_CustomerId", orderCustomerFkConstraint.Name);
Assert.Equal(nameof(Order.CustomerId), orderCustomerFkConstraint.Columns.Single().Name);
Assert.Equal(nameof(Customer.Id), orderCustomerFkConstraint.PrincipalColumns.Single().Name);
Assert.Same(ordersTable, orderCustomerFkConstraint.Table);
Assert.Equal("Customer", orderCustomerFkConstraint.PrincipalTable.Name);
Assert.Equal(ReferentialAction.Cascade, orderCustomerFkConstraint.OnDeleteAction);
Assert.Equal(orderCustomerFk, orderCustomerFkConstraint.MappedForeignKeys.Single());
Assert.Equal(new[] { orderDateFkConstraint, orderCustomerFkConstraint }, ordersTable.ForeignKeyConstraints);
var specialCustomerType = model.Model.FindEntityType(typeof(SpecialCustomer));
var orderDetailsOwnership = orderType.FindNavigation(nameof(Order.Details)).ForeignKey;
var orderDetailsType = orderDetailsOwnership.DeclaringEntityType;
Assert.Same(ordersTable, orderDetailsType.GetTableMappings().Single().Table);
Assert.Equal(
ordersTable.GetReferencingRowInternalForeignKeys(orderType), ordersTable.GetRowInternalForeignKeys(orderDetailsType));
Assert.Equal(
RelationalStrings.TableNotMappedEntityType(nameof(SpecialCustomer), ordersTable.Name),
Assert.Throws <InvalidOperationException>(
() =>
ordersTable.GetReferencingRowInternalForeignKeys(specialCustomerType)).Message);
Assert.Equal(
RelationalStrings.TableNotMappedEntityType(nameof(SpecialCustomer), ordersTable.Name),
Assert.Throws <InvalidOperationException>(
() =>
ordersTable.GetRowInternalForeignKeys(specialCustomerType)).Message);
Assert.False(ordersTable.IsOptional(orderType));
Assert.True(ordersTable.IsOptional(orderDetailsType));
Assert.Equal(
RelationalStrings.TableNotMappedEntityType(nameof(SpecialCustomer), ordersTable.Name),
Assert.Throws <InvalidOperationException>(
() =>
ordersTable.IsOptional(specialCustomerType)).Message);
Assert.Empty(orderDetailsOwnership.GetMappedConstraints());
Assert.Equal(2, orderDetailsType.GetForeignKeys().Count());
var orderDetailsDateIndex = orderDetailsType.GetIndexes().Single(i => i.Properties.Any(p => p.Name == nameof(Order.OrderDate)));
var orderDetailsDateTableIndex = orderDetailsDateIndex.GetMappedTableIndexes().Single();
Assert.Same(orderDateTableIndex, orderDetailsDateTableIndex);
Assert.Equal(new[] { orderDateIndex, orderDetailsDateIndex }, orderDateTableIndex.MappedIndexes);
var orderDetailsPk = orderDetailsType.FindPrimaryKey();
Assert.Same(orderPkConstraint, orderDetailsPk.GetMappedConstraints().Single());
var orderDetailsPkProperty = orderDetailsPk.Properties.Single();
#pragma warning disable CS0618 // Type or member is obsolete
Assert.Equal("Id", orderDetailsPkProperty.GetColumnName());
#pragma warning restore CS0618 // Type or member is obsolete
Assert.Equal("OrderId", orderDetailsPkProperty.GetColumnBaseName());
var billingAddressOwnership = orderDetailsType.FindNavigation(nameof(OrderDetails.BillingAddress)).ForeignKey;
var billingAddressType = billingAddressOwnership.DeclaringEntityType;
var shippingAddressOwnership = orderDetailsType.FindNavigation(nameof(OrderDetails.ShippingAddress)).ForeignKey;
var shippingAddressType = shippingAddressOwnership.DeclaringEntityType;
Assert.Equal(
new[] { orderPk, billingAddressType.FindPrimaryKey(), shippingAddressType.FindPrimaryKey(), orderDetailsPk },
orderPkConstraint.MappedKeys);
var orderDetailsDate = orderDetailsType.FindProperty(nameof(OrderDetails.OrderDate));
Assert.Equal(new[] { orderDate, orderDetailsDate }, orderDateColumn.PropertyMappings.Select(m => m.Property));
var orderDetailsAk = orderDetailsType.GetKeys().Single(k => k != orderDetailsPk);
var orderDetailsAkConstraint = orderDetailsAk.GetMappedConstraints().Single();
Assert.Same(orderAkConstraint, orderDetailsAkConstraint);
Assert.Equal(new[] { orderAk, orderDetailsAk }, orderAkConstraint.MappedKeys);
var orderDetailsDateFk = orderDetailsType.GetForeignKeys().Single(fk => fk.PrincipalEntityType.ClrType == typeof(DateDetails));
var orderDetailsDateFkConstraint = orderDateFk.GetMappedConstraints().Single();
Assert.Same(orderDateFkConstraint, orderDetailsDateFkConstraint);
Assert.Equal(new[] { orderDateFk, orderDetailsDateFk }, orderDateFkConstraint.MappedForeignKeys);
Assert.Equal("FK_DateDetails", orderDateFkConstraint.Name);
var customerType = model.Model.FindEntityType(typeof(Customer));
var customerTable = customerType.GetTableMappings().Single().Table;
Assert.Equal("Customer", customerTable.Name);
var customerPk = specialCustomerType.FindPrimaryKey();
if (mapping == Mapping.TPT)
{
Assert.Equal(2, specialCustomerType.GetTableMappings().Count());
Assert.True(specialCustomerType.GetTableMappings().First().IsSplitEntityTypePrincipal);
Assert.False(specialCustomerType.GetTableMappings().First().IncludesDerivedTypes);
Assert.True(specialCustomerType.GetTableMappings().Last().IsSplitEntityTypePrincipal);
Assert.True(specialCustomerType.GetTableMappings().Last().IncludesDerivedTypes);
var specialCustomerTable =
specialCustomerType.GetTableMappings().Select(t => t.Table).First(t => t.Name == "SpecialCustomer");
Assert.Equal("SpecialSchema", specialCustomerTable.Schema);
Assert.Equal(4, specialCustomerTable.Columns.Count());
Assert.True(specialCustomerTable.EntityTypeMappings.Single().IsSharedTablePrincipal);
var specialityColumn = specialCustomerTable.Columns.Single(c => c.Name == nameof(SpecialCustomer.Speciality));
Assert.False(specialityColumn.IsNullable);
Assert.Equal(2, customerPk.GetMappedConstraints().Count());
var specialCustomerPkConstraint = specialCustomerTable.PrimaryKey;
Assert.Equal("PK_SpecialCustomer", specialCustomerPkConstraint.Name);
Assert.Same(specialCustomerPkConstraint.MappedKeys.Single(), customerPk);
var idProperty = customerPk.Properties.Single();
Assert.Equal(3, idProperty.GetTableColumnMappings().Count());
Assert.Empty(customerTable.ForeignKeyConstraints);
var specialCustomerUniqueConstraint = customerTable.UniqueConstraints.Single(c => !c.GetIsPrimaryKey());
Assert.Equal("AK_Customer_SpecialityAk", specialCustomerUniqueConstraint.Name);
Assert.NotNull(specialCustomerUniqueConstraint.MappedKeys.Single());
var foreignKeys = specialCustomerTable.ForeignKeyConstraints.ToArray();
var specialCustomerTptFkConstraint = foreignKeys[0];
Assert.Equal("FK_SpecialCustomer_Customer_Id", specialCustomerTptFkConstraint.Name);
Assert.NotNull(specialCustomerTptFkConstraint.MappedForeignKeys.Single());
Assert.Same(customerTable, specialCustomerTptFkConstraint.PrincipalTable);
var specialCustomerFkConstraint = foreignKeys[1];
Assert.Equal("FK_SpecialCustomer_Customer_RelatedCustomerSpeciality", specialCustomerFkConstraint.Name);
Assert.NotNull(specialCustomerFkConstraint.MappedForeignKeys.Single());
Assert.Same(customerTable, specialCustomerFkConstraint.PrincipalTable);
var anotherSpecialCustomerFkConstraint = foreignKeys[2];
Assert.Equal("FK_SpecialCustomer_SpecialCustomer_AnotherRelatedCustomerId", anotherSpecialCustomerFkConstraint.Name);
Assert.NotNull(anotherSpecialCustomerFkConstraint.MappedForeignKeys.Single());
Assert.Same(specialCustomerTable, anotherSpecialCustomerFkConstraint.PrincipalTable);
var specialCustomerDbIndex = specialCustomerTable.Indexes.Last();
Assert.Equal("IX_SpecialCustomer_RelatedCustomerSpeciality", specialCustomerDbIndex.Name);
Assert.NotNull(specialCustomerDbIndex.MappedIndexes.Single());
var anotherSpecialCustomerDbIndex = specialCustomerTable.Indexes.First();
Assert.Equal("IX_SpecialCustomer_AnotherRelatedCustomerId", anotherSpecialCustomerDbIndex.Name);
Assert.NotNull(anotherSpecialCustomerDbIndex.MappedIndexes.Single());
Assert.Null(customerType.GetDiscriminatorProperty());
Assert.Null(customerType.GetDiscriminatorValue());
Assert.Null(specialCustomerType.GetDiscriminatorProperty());
Assert.Null(specialCustomerType.GetDiscriminatorValue());
}
else
{
var specialCustomerTypeMapping = specialCustomerType.GetTableMappings().Single();
Assert.True(specialCustomerTypeMapping.IsSplitEntityTypePrincipal);
Assert.True(specialCustomerTypeMapping.IncludesDerivedTypes);
var specialCustomerTable = specialCustomerTypeMapping.Table;
Assert.Same(customerTable, specialCustomerTable);
Assert.Equal(2, specialCustomerTable.EntityTypeMappings.Count());
Assert.True(specialCustomerTable.EntityTypeMappings.First().IsSharedTablePrincipal);
Assert.False(specialCustomerTable.EntityTypeMappings.Last().IsSharedTablePrincipal);
var specialityColumn = specialCustomerTable.Columns.Single(c => c.Name == nameof(SpecialCustomer.Speciality));
Assert.True(specialityColumn.IsNullable);
var specialCustomerPkConstraint = specialCustomerTable.PrimaryKey;
Assert.Equal("PK_Customer", specialCustomerPkConstraint.Name);
Assert.Same(specialCustomerPkConstraint.MappedKeys.Single(), customerPk);
var idProperty = customerPk.Properties.Single();
Assert.Equal(2, idProperty.GetTableColumnMappings().Count());
var specialCustomerUniqueConstraint = specialCustomerTable.UniqueConstraints.Single(c => !c.GetIsPrimaryKey());
Assert.Equal("AK_Customer_SpecialityAk", specialCustomerUniqueConstraint.Name);
Assert.NotNull(specialCustomerUniqueConstraint.MappedKeys.Single());
var specialCustomerFkConstraint = specialCustomerTable.ForeignKeyConstraints.Last();
Assert.Equal("FK_Customer_Customer_RelatedCustomerSpeciality", specialCustomerFkConstraint.Name);
Assert.NotNull(specialCustomerFkConstraint.MappedForeignKeys.Single());
var anotherSpecialCustomerFkConstraint = specialCustomerTable.ForeignKeyConstraints.First();
Assert.Equal("FK_Customer_Customer_AnotherRelatedCustomerId", anotherSpecialCustomerFkConstraint.Name);
Assert.NotNull(anotherSpecialCustomerFkConstraint.MappedForeignKeys.Single());
var specialCustomerDbIndex = specialCustomerTable.Indexes.Last();
Assert.Equal("IX_Customer_RelatedCustomerSpeciality", specialCustomerDbIndex.Name);
Assert.NotNull(specialCustomerDbIndex.MappedIndexes.Single());
var anotherSpecialCustomerDbIndex = specialCustomerTable.Indexes.First();
Assert.Equal("IX_Customer_AnotherRelatedCustomerId", anotherSpecialCustomerDbIndex.Name);
Assert.NotNull(specialCustomerDbIndex.MappedIndexes.Single());
}
}
public void Can_use_relational_model_with_SQL_queries()
{
var modelBuilder = CreateConventionModelBuilder();
modelBuilder.Entity <Order>(
cb =>
{
cb.ToSqlQuery("GetOrders()");
cb.Ignore(c => c.Customer);
cb.Ignore(c => c.Details);
cb.Ignore(c => c.DateDetails);
cb.Property(c => c.AlternateId).HasColumnName("SomeName");
cb.HasNoKey();
});
var model = modelBuilder.FinalizeModel().GetRelationalModel();
Assert.Single(model.Model.GetEntityTypes());
Assert.Single(model.Queries);
Assert.Empty(model.Views);
Assert.Empty(model.Tables);
Assert.Empty(model.Functions);
var orderType = model.Model.FindEntityType(typeof(Order));
Assert.Null(orderType.FindPrimaryKey());
var orderMapping = orderType.GetSqlQueryMappings().Single();
Assert.True(orderMapping.IsSharedTablePrincipal);
Assert.True(orderMapping.IsSplitEntityTypePrincipal);
Assert.True(orderMapping.IncludesDerivedTypes);
Assert.Equal(
new[] { nameof(Order.AlternateId), nameof(Order.CustomerId), nameof(Order.Id), nameof(Order.OrderDate) },
orderMapping.ColumnMappings.Select(m => m.Property.Name));
var ordersQuery = orderMapping.SqlQuery;
Assert.Equal(
new[] { orderType },
ordersQuery.EntityTypeMappings.Select(m => m.EntityType));
Assert.Equal(
new[] { nameof(Order.CustomerId), nameof(Order.Id), nameof(Order.OrderDate), "SomeName" },
ordersQuery.Columns.Select(m => m.Name));
Assert.Equal("Microsoft.EntityFrameworkCore.Metadata.RelationalModelTest+Order.MappedSqlQuery", ordersQuery.Name);
Assert.Null(ordersQuery.Schema);
Assert.Equal("GetOrders()", ordersQuery.Sql);
Assert.False(ordersQuery.IsShared);
var orderDate = orderType.FindProperty(nameof(Order.OrderDate));
Assert.Single(orderDate.GetSqlQueryColumnMappings());
var orderDateMapping = orderMapping.ColumnMappings.Single(m => m.Property == orderDate);
Assert.NotNull(orderDateMapping.TypeMapping);
Assert.Equal("default_datetime_mapping", orderDateMapping.TypeMapping.StoreType);
Assert.Same(orderMapping, orderDateMapping.SqlQueryMapping);
var orderDateColumn = orderDateMapping.Column;
Assert.Same(orderDateColumn, ordersQuery.FindColumn(nameof(Order.OrderDate)));
Assert.Same(orderDateColumn, orderDate.FindColumn(StoreObjectIdentifier.SqlQuery(orderType)));
Assert.Same(orderDateColumn, ordersQuery.FindColumn(orderDate));
Assert.Equal(new[] { orderDate }, orderDateColumn.PropertyMappings.Select(m => m.Property));
Assert.Equal(nameof(Order.OrderDate), orderDateColumn.Name);
Assert.Equal("default_datetime_mapping", orderDateColumn.StoreType);
Assert.False(orderDateColumn.IsNullable);
Assert.Same(ordersQuery, orderDateColumn.SqlQuery);
Assert.Same(orderMapping, ordersQuery.EntityTypeMappings.Single());
}
private static void AssertViews(IRelationalModel model, Mapping mapping)
{
var orderType = model.Model.FindEntityType(typeof(Order));
var orderMapping = orderType.GetViewMappings().Single();
Assert.Same(orderType.GetViewMappings(), orderType.GetViewOrTableMappings());
Assert.True(orderMapping.IncludesDerivedTypes);
Assert.Equal(
new[] { nameof(Order.Id), nameof(Order.AlternateId), nameof(Order.CustomerId), nameof(Order.OrderDate) },
orderMapping.ColumnMappings.Select(m => m.Property.Name));
var ordersView = orderMapping.View;
Assert.Same(ordersView, model.FindView(ordersView.Name, ordersView.Schema));
Assert.Equal(
new[]
{
nameof(Order), "OrderDetails.BillingAddress#Address", "OrderDetails.ShippingAddress#Address", nameof(OrderDetails)
},
ordersView.EntityTypeMappings.Select(m => m.EntityType.DisplayName()));
Assert.Equal(
new[]
{
nameof(Order.AlternateId),
nameof(Order.CustomerId),
"Details_BillingAddress_City",
"Details_BillingAddress_Street",
"Details_ShippingAddress_City",
"Details_ShippingAddress_Street",
nameof(Order.Id),
"OrderDate"
},
ordersView.Columns.Select(m => m.Name));
Assert.Equal("OrderView", ordersView.Name);
Assert.Equal("viewSchema", ordersView.Schema);
Assert.Null(ordersView.ViewDefinitionSql);
var orderDate = orderType.FindProperty(nameof(Order.OrderDate));
var orderDateMapping = orderDate.GetViewColumnMappings().Single();
Assert.NotNull(orderDateMapping.TypeMapping);
Assert.Equal("default_datetime_mapping", orderDateMapping.TypeMapping.StoreType);
Assert.Same(orderMapping, orderDateMapping.ViewMapping);
var orderDetailsOwnership = orderType.FindNavigation(nameof(Order.Details)).ForeignKey;
var orderDetailsType = orderDetailsOwnership.DeclaringEntityType;
Assert.Same(ordersView, orderDetailsType.GetViewMappings().Single().View);
Assert.Equal(
ordersView.GetReferencingRowInternalForeignKeys(orderType), ordersView.GetRowInternalForeignKeys(orderDetailsType));
Assert.False(ordersView.IsOptional(orderType));
Assert.True(ordersView.IsOptional(orderDetailsType));
var orderDetailsDate = orderDetailsType.FindProperty(nameof(OrderDetails.OrderDate));
var orderDateColumn = orderDateMapping.Column;
Assert.Same(orderDateColumn, ordersView.FindColumn("OrderDate"));
Assert.Same(orderDateColumn, orderDate.FindColumn(StoreObjectIdentifier.View(ordersView.Name, ordersView.Schema)));
Assert.Same(orderDateColumn, ordersView.FindColumn(orderDate));
Assert.Equal(new[] { orderDate, orderDetailsDate }, orderDateColumn.PropertyMappings.Select(m => m.Property));
Assert.Equal("OrderDate", orderDateColumn.Name);
Assert.Equal("default_datetime_mapping", orderDateColumn.StoreType);
Assert.False(orderDateColumn.IsNullable);
Assert.Same(ordersView, orderDateColumn.Table);
var customerType = model.Model.FindEntityType(typeof(Customer));
var customerView = customerType.GetViewMappings().Single().View;
Assert.Equal("CustomerView", customerView.Name);
Assert.Equal("viewSchema", customerView.Schema);
var specialCustomerType = model.Model.FindEntityType(typeof(SpecialCustomer));
var customerPk = specialCustomerType.FindPrimaryKey();
if (mapping == Mapping.TPT)
{
Assert.Equal(2, specialCustomerType.GetViewMappings().Count());
Assert.True(specialCustomerType.GetViewMappings().First().IsSplitEntityTypePrincipal);
Assert.False(specialCustomerType.GetViewMappings().First().IncludesDerivedTypes);
Assert.True(specialCustomerType.GetViewMappings().Last().IsSplitEntityTypePrincipal);
Assert.True(specialCustomerType.GetViewMappings().Last().IncludesDerivedTypes);
var specialCustomerView = specialCustomerType.GetViewMappings().Select(t => t.Table)
.First(t => t.Name == "SpecialCustomerView");
Assert.Null(specialCustomerView.Schema);
Assert.Equal(4, specialCustomerView.Columns.Count());
Assert.True(specialCustomerView.EntityTypeMappings.Single().IsSharedTablePrincipal);
var specialityColumn = specialCustomerView.Columns.Single(c => c.Name == nameof(SpecialCustomer.Speciality));
Assert.False(specialityColumn.IsNullable);
Assert.Null(customerType.GetDiscriminatorProperty());
Assert.Null(customerType.GetDiscriminatorValue());
Assert.Null(specialCustomerType.GetDiscriminatorProperty());
Assert.Null(specialCustomerType.GetDiscriminatorValue());
}
else
{
var specialCustomerViewMapping = specialCustomerType.GetViewMappings().Single();
Assert.True(specialCustomerViewMapping.IsSplitEntityTypePrincipal);
Assert.True(specialCustomerViewMapping.IncludesDerivedTypes);
var specialCustomerView = specialCustomerViewMapping.View;
Assert.Same(customerView, specialCustomerView);
Assert.Equal(2, specialCustomerView.EntityTypeMappings.Count());
Assert.True(specialCustomerView.EntityTypeMappings.First().IsSharedTablePrincipal);
Assert.False(specialCustomerView.EntityTypeMappings.Last().IsSharedTablePrincipal);
var specialityColumn = specialCustomerView.Columns.Single(c => c.Name == nameof(SpecialCustomer.Speciality));
Assert.True(specialityColumn.IsNullable);
}
}
