public void Initialize_should_initialize_ends() { var associationSetMapping = new DbAssociationSetMapping().Initialize(); Assert.NotNull(associationSetMapping.SourceEndMapping); Assert.NotNull(associationSetMapping.TargetEndMapping); }
public void Configure_should_split_key_constraint_when_to_table_configuration() { var database = new DbDatabaseMetadata().Initialize(); var sourceTable = database.AddTable("Source"); var fkColumn = sourceTable.AddColumn("Fk"); var foreignKeyConstraint = new DbForeignKeyConstraintMetadata(); foreignKeyConstraint.DependentColumns.Add(fkColumn); sourceTable.ForeignKeyConstraints.Add(foreignKeyConstraint); var targetTable = database.AddTable("Split"); var associationSetMapping = new DbAssociationSetMapping().Initialize(); associationSetMapping.Table = sourceTable; associationSetMapping.SourceEndMapping.PropertyMappings.Add(new DbEdmPropertyMapping { Column = fkColumn }); var independentAssociationMappingConfiguration = new ForeignKeyAssociationMappingConfiguration(); independentAssociationMappingConfiguration.ToTable("Split"); independentAssociationMappingConfiguration.Configure(associationSetMapping, database); Assert.True(targetTable.Columns.Contains(fkColumn)); Assert.True(targetTable.ForeignKeyConstraints.Contains(foreignKeyConstraint)); Assert.False(sourceTable.Columns.Contains(fkColumn)); Assert.False(sourceTable.ForeignKeyConstraints.Contains(foreignKeyConstraint)); Assert.Same(targetTable, associationSetMapping.Table); }
public void Can_get_and_set_configuration_annotation() { var associationSetMapping = new DbAssociationSetMapping(); associationSetMapping.SetConfiguration(42); Assert.Equal(42, associationSetMapping.GetConfiguration()); }
public void Configure_should_throw_when_incorrect_number_of_columns_configured() { var database = new DbDatabaseMetadata().Initialize(); var associationSetMapping = new DbAssociationSetMapping().Initialize(); var manyToManyAssociationMappingConfiguration = new ManyToManyAssociationMappingConfiguration(); manyToManyAssociationMappingConfiguration.MapLeftKey("Id1", "Id2"); Assert.Equal(Strings.IncorrectColumnCount("Id1, Id2"), Assert.Throws<InvalidOperationException>(() => manyToManyAssociationMappingConfiguration.Configure(associationSetMapping, database)).Message); }
public void Configure_should_throw_when_configured_table_not_found() { var independentAssociationMappingConfiguration = new ForeignKeyAssociationMappingConfiguration(); independentAssociationMappingConfiguration.ToTable("Split"); var associationSetMapping = new DbAssociationSetMapping().Initialize(); var database = new DbDatabaseMetadata().Initialize(); Assert.Equal(Strings.TableNotFound("Split"), Assert.Throws<InvalidOperationException>(() => independentAssociationMappingConfiguration.Configure(associationSetMapping, database)).Message); }
public void Configure_should_rename_columns_when_right_keys_configured() { var database = new DbDatabaseMetadata().Initialize(); var associationSetMapping = new DbAssociationSetMapping().Initialize(); var column = new DbTableColumnMetadata(); associationSetMapping.TargetEndMapping.PropertyMappings.Add(new DbEdmPropertyMapping { Column = column }); var manyToManyAssociationMappingConfiguration = new ManyToManyAssociationMappingConfiguration(); manyToManyAssociationMappingConfiguration.MapRightKey("NewName"); manyToManyAssociationMappingConfiguration.Configure(associationSetMapping, database); Assert.Equal("NewName", column.Name); }
public void Configure_should_rename_table_when_table_configured() { var database = new DbDatabaseMetadata().Initialize(); var table = database.AddTable("OriginalName"); var associationSetMapping = new DbAssociationSetMapping().Initialize(); associationSetMapping.Table = table; var manyToManyAssociationMappingConfiguration = new ManyToManyAssociationMappingConfiguration(); manyToManyAssociationMappingConfiguration.ToTable("NewName"); manyToManyAssociationMappingConfiguration.Configure(associationSetMapping, database); Assert.Equal("NewName", table.GetTableName().Name); Assert.Same(manyToManyAssociationMappingConfiguration, table.GetConfiguration()); }
private void WriteAssociationSetMappingElement(DbAssociationSetMapping set) { _xmlWriter.WriteStartElement(MslConstants.Element_AssociationSetMapping); _xmlWriter.WriteAttributeString(MslConstants.Attribute_Name, set.AssociationSet.Name); _xmlWriter.WriteAttributeString( MslConstants.Attribute_TypeName, _entityTypeNamespace + "." + set.AssociationSet.ElementType.Name); _xmlWriter.WriteAttributeString(MslConstants.Attribute_StoreEntitySet, set.Table.Name); WriteAssociationEndMappingElement(set.SourceEndMapping); WriteAssociationEndMappingElement(set.TargetEndMapping); foreach (var conditionColumn in set.ColumnConditions) { WriteConditionElement(conditionColumn); } _xmlWriter.WriteEndElement(); }
internal override void Configure(DbAssociationSetMapping associationSetMapping, DbDatabaseMetadata database) { // By convention source end contains the dependent column mappings var propertyMappings = associationSetMapping.SourceEndMapping.PropertyMappings; if (_tableName != null) { var targetTable = ((from t in database.Schemas.Single().Tables let n = t.GetTableName() where (n != null && n.Equals(_tableName)) select t) .SingleOrDefault()) ?? database.Schemas.Single().Tables .SingleOrDefault( t => string.Equals(t.DatabaseIdentifier, _tableName.Name, StringComparison.Ordinal)); if (targetTable == null) { throw Error.TableNotFound(_tableName); } var sourceTable = associationSetMapping.Table; if (sourceTable != targetTable) { var foreignKeyConstraint = sourceTable.ForeignKeyConstraints .Single(fk => fk.DependentColumns.SequenceEqual(propertyMappings.Select(pm => pm.Column))); sourceTable.ForeignKeyConstraints.Remove(foreignKeyConstraint); targetTable.ForeignKeyConstraints.Add(foreignKeyConstraint); foreignKeyConstraint.DependentColumns .Each( c => { sourceTable.Columns.Remove(c); targetTable.Columns.Add(c); }); associationSetMapping.Table = targetTable; } } if ((_keyColumnNames.Count > 0) && (_keyColumnNames.Count != propertyMappings.Count)) { throw Error.IncorrectColumnCount(string.Join(", ", _keyColumnNames)); } _keyColumnNames.Each((n, i) => propertyMappings[i].Column.Name = n); }
internal static DbAssociationSetMapping AddAssociationSetMapping( this DbDatabaseMapping databaseMapping, EdmAssociationSet associationSet) { Contract.Requires(databaseMapping != null); Contract.Requires(associationSet != null); var associationSetMapping = new DbAssociationSetMapping { AssociationSet = associationSet }.Initialize(); databaseMapping .EntityContainerMappings .Single() .AssociationSetMappings .Add(associationSetMapping); return associationSetMapping; }
private void GenerateIndependentForeignKeyColumns( EdmEntityType principalEntityType, EdmEntityType dependentEntityType, DbAssociationSetMapping associationSetMapping, DbAssociationEndMapping associationEndMapping, DbTableMetadata dependentTable, DbForeignKeyConstraintMetadata foreignKeyConstraint, bool isPrimaryKeyColumn, EdmNavigationProperty principalNavigationProperty) { //Contract.Requires(principalEntityType != null); //Contract.Requires(associationEndMapping != null); //Contract.Requires(dependentTable != null); //Contract.Requires(foreignKeyConstraint != null); foreach (var property in principalEntityType.KeyProperties()) { var foreignKeyColumn = dependentTable.AddColumn( ((principalNavigationProperty != null) ? principalNavigationProperty.Name : principalEntityType.Name) + "_" + property.Name); MapTableColumn(property, foreignKeyColumn, false, isPrimaryKeyColumn); foreignKeyColumn.IsNullable = (associationEndMapping.AssociationEnd.IsOptional() || (associationEndMapping.AssociationEnd.IsRequired() && dependentEntityType.BaseType != null)); foreignKeyColumn.StoreGeneratedPattern = DbStoreGeneratedPattern.None; foreignKeyConstraint.DependentColumns.Add(foreignKeyColumn); associationEndMapping.PropertyMappings.Add( new DbEdmPropertyMapping { Column = foreignKeyColumn, PropertyPath = new[] { property } }); if (foreignKeyColumn.IsNullable) { associationSetMapping.ColumnConditions.Add( new DbColumnCondition { Column = foreignKeyColumn, IsNull = false }); } } }
internal override void Configure(DbAssociationSetMapping associationSetMapping, DbDatabaseMetadata database) { var table = associationSetMapping.Table; if (_tableName != null) { table.SetTableName(_tableName); table.SetConfiguration(this); } ConfigureColumnNames(_leftKeyColumnNames, associationSetMapping.SourceEndMapping.PropertyMappings); ConfigureColumnNames(_rightKeyColumnNames, associationSetMapping.TargetEndMapping.PropertyMappings); }
internal override void Configure(DbAssociationSetMapping associationSetMapping, DbDatabaseMetadata database) { Contract.Requires(associationSetMapping != null); Contract.Requires(database != null); }
internal abstract void Configure(DbAssociationSetMapping associationSetMapping, DbDatabaseMetadata database);
private static void MoveAssociationSetMappingDependents( DbAssociationSetMapping associationSetMapping, DbAssociationEndMapping dependentMapping, DbTableMetadata toTable, bool useExistingColumns) { Contract.Requires(associationSetMapping != null); Contract.Requires(dependentMapping != null); Contract.Requires(toTable != null); dependentMapping.PropertyMappings.Each( pm => { var oldColumn = pm.Column; pm.Column = TableOperations.MoveColumnAndAnyConstraints( associationSetMapping.Table, toTable, oldColumn, useExistingColumns); associationSetMapping.ColumnConditions.Where(cc => cc.Column == oldColumn).Each( cc => cc.Column = pm.Column); }); associationSetMapping.Table = toTable; }
internal void Configure(DbAssociationSetMapping associationSetMapping, DbDatabaseMapping databaseMapping) { //Contract.Requires(associationSetMapping != null); //Contract.Requires(databaseMapping != null); // We may apply configuration twice from two different NavigationPropertyConfiguration objects, // but that should be okay since they were validated as consistent above. // We still apply twice because each object may have different pieces of the full configuration. if (AssociationMappingConfiguration != null) { // This may replace a configuration previously set, but that's okay since we validated // consistency when processing the configuration above. associationSetMapping.SetConfiguration(this); AssociationMappingConfiguration.Configure(associationSetMapping, databaseMapping.Database); } }
private void GenerateIndependentForeignKeyConstraint( DbDatabaseMapping databaseMapping, EdmEntityType principalEntityType, EdmEntityType dependentEntityType, DbTableMetadata dependentTable, DbAssociationSetMapping associationSetMapping, DbAssociationEndMapping associationEndMapping, string name, EdmAssociationEnd principalEnd, bool isPrimaryKeyColumn = false) { //Contract.Requires(databaseMapping != null); //Contract.Requires(principalEntityType != null); //Contract.Requires(dependentTable != null); //Contract.Requires(associationEndMapping != null); //Contract.Requires(!string.IsNullOrWhiteSpace(name)); var principalTable = GetEntityTypeMappingInHierarchy(databaseMapping, principalEntityType) .TypeMappingFragments .Single() .Table; var foreignKeyConstraint = new DbForeignKeyConstraintMetadata { Name = name, PrincipalTable = principalTable, DeleteAction = associationEndMapping.AssociationEnd.DeleteAction.HasValue ? (DbOperationAction) associationEndMapping.AssociationEnd.DeleteAction. Value : DbOperationAction.None }; var principalNavigationProperty = databaseMapping.Model.GetEntityTypes() .SelectMany(e => e.DeclaredNavigationProperties) .SingleOrDefault(n => n.ResultEnd == principalEnd); GenerateIndependentForeignKeyColumns( principalEntityType, dependentEntityType, associationSetMapping, associationEndMapping, dependentTable, foreignKeyConstraint, isPrimaryKeyColumn, principalNavigationProperty); dependentTable.ForeignKeyConstraints.Add(foreignKeyConstraint); }