private IModel CreateModel() { var model = new Model(); var builder = new ModelBuilder(model); builder.Entity<ClrPoco>() .PartitionAndRowKey(s => s.PartitionKey, s => s.RowKey) .Timestamp(s => s.Timestamp); builder.Entity("ShadowEntity", pb => { pb.Property<object>("PartitionKey", true); pb.Property<object>("RowKey", true); pb.Property<object>("Timestamp", true); pb.Property<object>("SomeProperty", true); pb.Key("PartitionKey", "RowKey"); }); builder.Entity<GuidKeysPoco>() .PartitionAndRowKey(s => s.PartitionGuid, s => s.RowGuid) .Timestamp("Timestamp", true); builder.Entity<IntKeysPoco>() .PartitionAndRowKey(s => s.PartitionID, s => s.RowID); builder.Entity<ClrPocoWithProp>(pb => { pb.PartitionAndRowKey(s => s.PartitionKey, s => s.RowKey); pb.Property(s => s.Timestamp); pb.Property(s => s.StringProp); pb.Property(s => s.IntProp); }); return model; }
public void Get_generation_property_returns_generation_property_from_foreign_key_tree() { var model = new Model(); var leftType = new EntityType("Left", model); var leftId = leftType.AddProperty("Id", typeof(int), true); var leftKey = leftType.AddKey(leftId); var rightType = new EntityType("Right", model); var rightId1 = rightType.AddProperty("Id1", typeof(int), true); var rightId2 = rightType.AddProperty("Id2", typeof(int), true); var rightKey = rightType.AddKey(new[] { rightId1, rightId2 }); var middleType = new EntityType("Middle", model); var middleProperty1 = middleType.AddProperty("FK1", typeof(int), true); var middleProperty2 = middleType.AddProperty("FK2", typeof(int), true); var middleKey1 = middleType.AddKey(middleProperty1); var middleFK1 = middleType.AddForeignKey(middleProperty1, leftKey, leftType); var middleFK2 = middleType.AddForeignKey(new[] { middleProperty2, middleProperty1 }, rightKey, rightType); var endType = new EntityType("End", model); var endProperty = endType.AddProperty("FK", typeof(int), true); var endFK = endType.AddForeignKey(endProperty, middleKey1, middleType); rightId2.RequiresValueGenerator = true; Assert.Equal(rightId2, endProperty.GetGenerationProperty()); }
public virtual void Finds_existing_navigation_to_principal_and_uses_associated_FK() { var model = new Model(); var modelBuilder = CreateModelBuilder(model); modelBuilder.Entity<Customer>(); modelBuilder .Entity<Order>().HasOne(o => o.Customer).WithMany() .ForeignKey(c => c.CustomerId); modelBuilder.Ignore<OrderDetails>(); modelBuilder.Ignore<CustomerDetails>(); var dependentType = model.GetEntityType(typeof(Order)); var principalType = model.GetEntityType(typeof(Customer)); var principalKey = principalType.GetKeys().Single(); var dependentKey = dependentType.GetKeys().Single(); modelBuilder.Entity<Order>().HasOne(e => e.Customer).WithMany(e => e.Orders); var newFk = dependentType.Navigations.Single().ForeignKey; Assert.Equal(nameof(Order.CustomerId), newFk.Properties.Single().Name); Assert.Same(newFk, principalType.Navigations.Single().ForeignKey); Assert.Empty(principalType.GetForeignKeys()); Assert.Same(principalKey, principalType.GetKeys().Single()); Assert.Same(dependentKey, dependentType.GetKeys().Single()); Assert.Same(principalKey, principalType.GetPrimaryKey()); Assert.Same(dependentKey, dependentType.GetPrimaryKey()); }
public virtual void Replaces_existing_navigation_to_principal() { var model = new Model(); var modelBuilder = CreateModelBuilder(model); modelBuilder.Entity<CustomerDetails>().Reference(c => c.Customer).InverseReference(); modelBuilder.Ignore<Order>(); var dependentType = model.GetEntityType(typeof(CustomerDetails)); var principalType = model.GetEntityType(typeof(Customer)); var expectedPrincipalProperties = principalType.Properties.ToList(); var expectedDependentProperties = dependentType.Properties.ToList(); var principalKey = principalType.GetKeys().Single(); var dependentKey = dependentType.GetKeys().Single(); modelBuilder.Entity<Customer>().Reference(e => e.Details).InverseReference(e => e.Customer); var fk = dependentType.GetForeignKeys().Single(); Assert.Same(fk.DependentToPrincipal, dependentType.Navigations.Single()); Assert.Same(fk.PrincipalToDependent, principalType.Navigations.Single()); AssertEqual(expectedPrincipalProperties, principalType.Properties); AssertEqual(expectedDependentProperties, dependentType.Properties); Assert.Empty(principalType.GetForeignKeys()); Assert.Same(principalKey, principalType.GetKeys().Single()); Assert.Same(dependentKey, dependentType.GetKeys().Single()); Assert.Same(principalKey, principalType.GetPrimaryKey()); Assert.Same(dependentKey, dependentType.GetPrimaryKey()); }
protected virtual IModel CreateModel( [NotNull] DbContext context, [CanBeNull] IConventionSetBuilder conventionSetBuilder, [NotNull] IModelValidator validator) { Check.NotNull(context, nameof(context)); Check.NotNull(validator, nameof(validator)); var conventionSet = CreateConventionSet(conventionSetBuilder); var model = new Model(); model.SetProductVersion(ProductInfo.GetVersion()); var modelBuilder = new ModelBuilder(conventionSet, model); FindSets(modelBuilder, context); OnModelCreating(context, modelBuilder); modelBuilder.Validate(); validator.Validate(model); return model; }
public virtual void Finds_existing_navigations_and_uses_associated_FK() { var model = new Model(); var modelBuilder = CreateModelBuilder(model); modelBuilder.Entity<Customer>(); modelBuilder .Entity<CustomerDetails>().HasOne(d => d.Customer).WithOne(c => c.Details) .ForeignKey<CustomerDetails>(c => c.Id); modelBuilder.Ignore<Order>(); var dependentType = model.GetEntityType(typeof(CustomerDetails)); var principalType = model.GetEntityType(typeof(Customer)); var fk = dependentType.GetForeignKeys().Single(); var navToPrincipal = dependentType.GetNavigation(nameof(CustomerDetails.Customer)); var navToDependent = principalType.GetNavigation(nameof(Customer.Details)); var principalKey = principalType.GetKeys().Single(); var dependentKey = dependentType.GetKeys().Single(); modelBuilder.Entity<Customer>().HasOne(e => e.Details).WithOne(e => e.Customer); Assert.Equal(1, dependentType.GetForeignKeys().Count()); Assert.Same(navToPrincipal, dependentType.Navigations.Single()); Assert.Same(navToDependent, principalType.Navigations.Single()); Assert.Same(fk.PrincipalKey, principalType.Navigations.Single().ForeignKey.PrincipalKey); AssertEqual(new[] { "AlternateKey", principalKey.Properties.Single().Name, Customer.NameProperty.Name }, principalType.Properties.Select(p => p.Name)); AssertEqual(new[] { dependentKey.Properties.Single().Name }, dependentType.Properties.Select(p => p.Name)); Assert.Empty(principalType.GetForeignKeys()); Assert.Same(principalKey, principalType.GetKeys().Single()); Assert.Same(dependentKey, dependentType.GetKeys().Single()); Assert.Same(principalKey, principalType.GetPrimaryKey()); Assert.Same(dependentKey, dependentType.GetPrimaryKey()); }
public virtual void Detects_shadow_entities() { var model = new Model(); model.AddEntityType("A"); VerifyError(CoreStrings.ShadowEntity("A"), model); }
protected virtual IModel CreateModel( [NotNull] DbContext context, [CanBeNull] IConventionSetBuilder conventionSetBuilder, [NotNull] IModelValidator validator) { Check.NotNull(context, nameof(context)); Check.NotNull(validator, nameof(validator)); var conventionSet = CreateConventionSet(conventionSetBuilder); var model = new Model(); var productVersion = typeof(ModelSource).GetTypeInfo().Assembly .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion; model[CoreAnnotationNames.ProductVersionAnnotation] = productVersion; var modelBuilder = new ModelBuilder(conventionSet, model); FindSets(modelBuilder, context); OnModelCreating(context, modelBuilder); modelBuilder.Validate(); validator.Validate(model); return model; }
public virtual void Finds_existing_navigation_to_principal_and_uses_associated_FK() { var model = new Model(); var modelBuilder = CreateModelBuilder(model); modelBuilder.Entity<Customer>(); modelBuilder .Entity<Order>().Reference(c => c.Customer).InverseCollection() .ForeignKey(c => c.CustomerId); modelBuilder.Ignore<OrderDetails>(); modelBuilder.Ignore<CustomerDetails>(); var dependentType = model.GetEntityType(typeof(Order)); var principalType = model.GetEntityType(typeof(Customer)); var fk = dependentType.GetForeignKeys().Single(); var navigation = dependentType.GetNavigation("Customer"); var principalKey = principalType.GetKeys().Single(); var dependentKey = dependentType.GetKeys().Single(); modelBuilder.Entity<Customer>().Collection(e => e.Orders).InverseReference(e => e.Customer); Assert.Equal(1, dependentType.GetForeignKeys().Count()); Assert.Equal("Orders", principalType.Navigations.Single().Name); Assert.Same(fk.PrincipalKey, principalType.Navigations.Single().ForeignKey.PrincipalKey); AssertEqual(new[] { "AlternateKey", principalKey.Properties.Single().Name, Customer.NameProperty.Name }, principalType.Properties.Select(p => p.Name)); AssertEqual(new[] { "AnotherCustomerId", fk.Properties.Single().Name, dependentKey.Properties.Single().Name }, dependentType.Properties.Select(p => p.Name)); Assert.Empty(principalType.GetForeignKeys()); Assert.Same(principalKey, principalType.GetKeys().Single()); Assert.Same(dependentKey, dependentType.GetKeys().Single()); Assert.Same(principalKey, principalType.GetPrimaryKey()); Assert.Same(dependentKey, dependentType.GetPrimaryKey()); }
protected Model CreateModel() { var model = new Model(); var modelBuilder = new BasicModelBuilder(model); modelBuilder.Entity<MappingQueryTestBase.MappedCustomer>(e => { e.Key(c => c.CustomerID); e.Property(c => c.CompanyName2).Metadata.Relational().Column = "Broken"; e.Metadata.Relational().Table = "Broken"; e.Metadata.Relational().Schema = "wrong"; }); modelBuilder.Entity<MappingQueryTestBase.MappedEmployee>(e => { e.Key(em => em.EmployeeID); e.Property(em => em.City2).Metadata.Relational().Column = "City"; e.Metadata.Relational().Table = "Employees"; e.Metadata.Relational().Schema = "dbo"; }); modelBuilder.Entity<MappingQueryTestBase.MappedOrder>(e => { e.Key(o => o.OrderID); e.Property(em => em.ShipVia2).Metadata.Relational().Column = "ShipVia"; e.Metadata.Relational().Table = "Orders"; e.Metadata.Relational().Schema = "dbo"; }); OnModelCreating(modelBuilder); return model; }
public void Model_can_be_set_explicitly_in_options() { var model = new Model(); var optionsBuilder = new DbContextOptionsBuilder().UseModel(model); Assert.Same(model, optionsBuilder.Options.FindExtension<CoreOptionsExtension>().Model); }
private ForeignKey CreateForeignKey() { var model = new Model(); var entityType = model.AddEntityType("E"); var property = entityType.AddProperty("p", typeof(int), shadowProperty: true); var key = entityType.SetPrimaryKey(property); return new ForeignKey(new[] { property }, key); }
public virtual void ForeignKeyAttribute_does_not_set_foreign_key_properties_when_applied_on_properties_for_composite_foreign_key() { var model = new Model(); var modelBuilder = CreateModelBuilder(model); modelBuilder.Entity<PostDetails>(); Assert.Equal("AuthorId", model.GetEntityType(typeof(PostDetails)).FindNavigation("Author").ForeignKey.Properties.First().Name); }
public virtual void ForeignKeyAttribute_does_not_set_foreign_key_properties_when_names_on_property_and_navigation_do_not_match() { var model = new Model(); var modelBuilder = CreateModelBuilder(model); modelBuilder.Entity<Author>(); Assert.Equal("AuthorId", model.GetEntityType(typeof(AuthorDetails)).FindNavigation("Author").ForeignKey.Properties.First().Name); }
public virtual void Detects_a_null_primary_key() { var model = new Model(); var entityType = model.AddEntityType(typeof(A)); var property = entityType.AddProperty("Id", typeof(int)); VerifyError(CoreStrings.EntityRequiresKey(typeof(A).FullName), model); }
public void Can_set_model() { var sequence = new Sequence("Foo"); var model = new Model(); sequence.Model = model; Assert.Same(model, sequence.Model); }
public void Get_generation_property_returns_null_for_property_without_generator() { var model = new Model(); var entityType = new EntityType("Entity", model); var property = entityType.AddProperty("Property", typeof(int), true); Assert.Null(property.GetGenerationProperty()); }
private static void AddNavigationToPrincipal(Microsoft.Data.Entity.Metadata.Model model, Type type, string fk, string navigation) { model.GetEntityType(type) .AddNavigation( navigation, model.GetEntityType(type).ForeignKeys.Single( f => f.Properties.Count == 1 && f.Properties.Single().Name == fk), pointsToPrincipal: true); }
private ForeignKey CreateForeignKey() { var model = new Model(); var entityType = model.AddEntityType("E"); var idProperty = entityType.AddProperty("id", typeof(int)); var key = entityType.SetPrimaryKey(idProperty); var fkProperty = entityType.AddProperty("p", typeof(int)); return entityType.AddForeignKey(fkProperty, key, entityType); }
public virtual void Detects_a_non_shadow_property_that_doesnt_match_the_CLR_property_type() { var model = new Model(); var entityType = model.AddEntityType(typeof(A)); var property = entityType.AddProperty("P0", typeof(string)); property.IsShadowProperty = false; VerifyError(Strings.PropertyWrongClrType("P0", typeof(A).FullName), model); }
public virtual void Detects_shadow_keys() { var model = new Model(); var entityType = model.AddEntityType("E"); var keyProperty = entityType.AddProperty("Id", typeof(int), shadowProperty: true); entityType.AddKey(keyProperty); VerifyWarning(Strings.ShadowKey("{'Id'}", "E", "{'Id'}"), model); }
public void Constructor_validates_properties_from_same_entity() { var property1 = new Model().AddEntityType(typeof(Customer)).GetOrAddProperty(Customer.IdProperty); var property2 = new Model().AddEntityType(typeof(Order)).GetOrAddProperty(Order.IdProperty); Assert.Equal(CoreStrings.InconsistentEntityType("properties"), Assert.Throws<ArgumentException>( () => new Index(new[] { property1, property2 })).Message); }
public virtual void Detects_a_non_shadow_property_that_doesnt_match_a_CLR_property() { var model = new Model(); var entityType = model.AddEntityType(typeof(A)); var property = entityType.AddProperty("Id1", typeof(int)); property.IsShadowProperty = false; entityType.SetPrimaryKey(property); VerifyError(CoreStrings.NoClrProperty("Id1", typeof(A).FullName), model); }
public virtual void NotMappedAttribute_removes_ambiguity_in_conventional_relationship_building() { var model = new Model(); var modelBuilder = CreateModelBuilder(model); modelBuilder.Entity<Book>(); Assert.Contains("Details", model.GetEntityType(typeof(Book)).Navigations.Select(nav => nav.Name)); Assert.Contains("AnotherBook", model.GetEntityType(typeof(BookDetails)).Navigations.Select(nav => nav.Name)); Assert.DoesNotContain("Book", model.GetEntityType(typeof(BookDetails)).Navigations.Select(nav => nav.Name)); }
public virtual void Detects_shadow_keys() { var model = new Model(); var entityType = model.AddEntityType(typeof(A)); SetPrimaryKey(entityType); var keyProperty = entityType.AddProperty("Key", typeof(int)); entityType.AddKey(keyProperty); VerifyWarning(CoreStrings.ShadowKey("{'Key'}", typeof(A).FullName, "{'Key'}"), model); }
public virtual void Can_get_entity_builder_for_clr_type() { var model = new Model(); var modelBuilder = CreateModelBuilder(model); var entityBuilder = modelBuilder.Entity<Customer>(); Assert.NotNull(entityBuilder); Assert.Equal(typeof(Customer).FullName, model.GetEntityType(typeof(Customer)).Name); }
public virtual void Detects_self_referencing_properties() { var model = new Model(); var entityA = model.AddEntityType(typeof(A)); var keyA = CreateKey(entityA); CreateForeignKey(keyA, keyA); VerifyError(Strings.CircularDependency("'A' {'P0'} -> 'A' {'P0'}"), model); }
public void Can_get_entity_builder_for_entity_type_name() { var model = new Model(); var modelBuilder = new ModelBuilder(model); var entityBuilder = modelBuilder.Entity("Customer"); Assert.NotNull(entityBuilder); Assert.NotNull(model.TryGetEntityType("Customer")); }
public void Can_create_key_from_properties() { var entityType = new Model().AddEntityType(typeof(Customer)); var property1 = entityType.GetOrAddProperty(Customer.IdProperty); var property2 = entityType.GetOrAddProperty(Customer.NameProperty); var key = new Key(new[] { property1, property2 }); Assert.True(new[] { property1, property2 }.SequenceEqual(key.Properties)); }
private static Model CreateModel(bool generateValues = true) { var model = new Model(); var entityType = model.AddEntityType("Led"); entityType.AddProperty("Zeppelin", typeof(Guid)); entityType.AddProperty("Stairway", typeof(Guid)).RequiresValueGenerator = generateValues; return model; }
private static void AddNavigationToDependent(Microsoft.Data.Entity.Metadata.Model model, Type type, Type dependentType, string fk1, string fk2, string navigation) { model.GetEntityType(type) .AddNavigation( navigation, model.GetEntityType(dependentType).ForeignKeys.Single( f => f.Properties.Count == 2 && f.Properties.Any(p => p.Name == fk1) && f.Properties.Any(p => p.Name == fk2)), pointsToPrincipal: false); }
public void Can_set_ClrType() { var entityType = new Model().AddEntityType(typeof(object)); var property = entityType.AddProperty("Kake"); Assert.Null(property.ClrType); Assert.Equal(typeof(string), ((IProperty)property).ClrType); property.ClrType = typeof(int); Assert.Equal(typeof(int), property.ClrType); }
public virtual IModel ConstructRelationalModel() { var relationalModel = new Microsoft.Data.Entity.Metadata.Model(); foreach (var table in _tables.Values) { relationalModel.AddEntityType(table.Id); } foreach (var tc in _tableColumns.Values) { var entityType = relationalModel.FindEntityType(tc.TableId); if (entityType == null) { _logger.LogWarning( Strings.CannotFindTableForColumn(tc.Id, tc.TableId)); continue; } // IModel will not allow Properties to be created without a Type, so map to CLR type here. // This means if we come across a column with a SQL Server type which we can't map we will ignore it. // Note: foreign key properties appear just like any other property in the relational model. Type clrPropertyType; if (!SqlServerTypeMapping._sqlTypeToClrTypeMap.TryGetValue(tc.DataType, out clrPropertyType)) { _logger.LogWarning( Strings.CannotFindTypeMappingForColumn(tc.Id, tc.DataType)); continue; } if (tc.IsNullable) { clrPropertyType = clrPropertyType.MakeNullable(); } var relationalProperty = entityType.AddProperty(tc.Id, clrPropertyType, shadowProperty: true); _relationalColumnIdToRelationalPropertyMap[tc.Id] = relationalProperty; } return(relationalModel); }
public virtual IModel ConstructCodeGenModel( [NotNull] IModel relationalModel, [NotNull] SqlServerNameMapper nameMapper) { Check.NotNull(relationalModel, nameof(relationalModel)); Check.NotNull(nameMapper, nameof(nameMapper)); var codeGenModel = new Microsoft.Data.Entity.Metadata.Model(); foreach (var relationalEntityType in relationalModel.EntityTypes.Cast<EntityType>()) { var codeGenEntityType = codeGenModel .AddEntityType(nameMapper.EntityTypeToClassNameMap[relationalEntityType]); _relationalEntityTypeToCodeGenEntityTypeMap[relationalEntityType] = codeGenEntityType; codeGenEntityType.Relational().Table = _tables[relationalEntityType.Name].TableName; codeGenEntityType.Relational().Schema = _tables[relationalEntityType.Name].SchemaName; // Loop over relational properties constructing a matching property in the // codeGenModel. Also accumulate: // a) primary key properties // b) constraint properties var primaryKeyProperties = new List<Property>(); var constraints = new Dictionary<string, List<Property>>(); _relationalEntityTypeToForeignKeyConstraintsMap[relationalEntityType] = constraints; foreach (var relationalProperty in relationalEntityType.Properties) { int primaryKeyOrdinal; if (_primaryKeyOrdinals.TryGetValue(relationalProperty.Name, out primaryKeyOrdinal)) { // add _relational_ property so we can order on the ordinal later primaryKeyProperties.Add(relationalProperty); } Dictionary<string, int> foreignKeyConstraintIdOrdinalMap; if (_foreignKeyOrdinals.TryGetValue(relationalProperty.Name, out foreignKeyConstraintIdOrdinalMap)) { // relationalProperty represents (part of) a foreign key foreach (var constraintId in foreignKeyConstraintIdOrdinalMap.Keys) { List<Property> constraintProperties; if (!constraints.TryGetValue(constraintId, out constraintProperties)) { constraintProperties = new List<Property>(); constraints.Add(constraintId, constraintProperties); } constraintProperties.Add(relationalProperty); } } var codeGenProperty = codeGenEntityType.AddProperty( nameMapper.PropertyToPropertyNameMap[relationalProperty], relationalProperty.ClrType, shadowProperty: true); _relationalPropertyToCodeGenPropertyMap[relationalProperty] = codeGenProperty; ApplyPropertyProperties(codeGenProperty, _tableColumns[relationalProperty.Name]); } // end of loop over all relational properties for given EntityType if (primaryKeyProperties.Count() > 0) { // order the relational properties by their primaryKeyOrdinal, then return a list // of the codeGen properties mapped to each relational property in that order codeGenEntityType.SetPrimaryKey( primaryKeyProperties .OrderBy(p => _primaryKeyOrdinals[p.Name]) // note: for relational property p.Name is its columnId .Select(p => _relationalPropertyToCodeGenPropertyMap[p]) .ToList()); } else { var errorMessage = Strings.NoPrimaryKeyColumns( codeGenEntityType.Name, _tables[relationalEntityType.Name].SchemaName, _tables[relationalEntityType.Name].TableName); codeGenEntityType.AddAnnotation(AnnotationNameEntityTypeError, errorMessage); _logger.LogWarning(Strings.CannotGenerateEntityType(codeGenEntityType.Name, errorMessage)); } } // end of loop over all relational EntityTypes AddForeignKeysToCodeGenModel(codeGenModel); return codeGenModel; }