public static ITable GetPrimaryTable(Entity entity) { var mappedTables = entity.MappedTables().ToList(); if (mappedTables.Count == 0) { return null; //string msg = string.Format( // "Entity {0} does not have a mapped table. It should not be included in the entities to be processed by the HBM file template", // entity.Name); //Log.Error(msg); //throw new Exception(msg); } if (mappedTables.Count == 1) { return mappedTables[0]; } foreach (ITable table in mappedTables) { // ReSharper disable AccessToModifiedClosure if (table.DirectedRelationships.All(r => r.FromTable == table)) // ReSharper restore AccessToModifiedClosure return table; } return mappedTables[0]; }
public static bool IsEntityMappedToTables(Entity entity) { if (entity.MappedTables().Count() > 0) return true; // Skip if the entity has no mapped tables; if (!entity.HasParent && !entity.HasChildren) return false; if (entity.HasParent) { if (EntityImpl.DetermineInheritanceTypeWithParent(entity) == EntityImpl.InheritanceType.TablePerClassHierarchy) return entity.Parent.MappedTables().Count() > 0; else return false; } else if (entity.IsAbstract && entity.HasChildren) return true; return false; // Entity has children //if (entity.IsAbstract) }
public @class ProcessEntity(Entity entity) { Log.DebugFormat("Processing entity {0}", entity.Name); var newClass = new @class { name = entity.Name }; IList<ITable> mappedTables = entity.MappedTables().ToList(); // One Entity to one or more tables ITable table = GetPrimaryTable(entity); if (table != null && !string.IsNullOrEmpty(table.Name)) newClass.table = table.Name.BackTick(); if (table != null && !string.IsNullOrEmpty(table.Schema)) newClass.schema = table.Schema.BackTick(); var entityDefaultLazy = entity.GetEntityLazy(); if (entity.GetEntityLazy() == Interfaces.NHibernateEnums.EntityLazyTypes.inherit_default) newClass.lazy = ArchAngel.Interfaces.SharedData.CurrentProject.GetProjectDefaultLazy(); else newClass.lazy = entityDefaultLazy == Interfaces.NHibernateEnums.EntityLazyTypes.@true; newClass.lazySpecified = !newClass.lazy; newClass.batchsize = entity.GetEntityBatchSize(); newClass.batchsizeSpecified = entity.GetEntityBatchSize() != 1; if (entity.GetEntityDynamicInsert()) newClass.dynamicinsert = true; if (entity.GetEntityDynamicUpdate()) newClass.dynamicupdate = true; newClass.@abstract = entity.IsAbstract; if (entity.IsAbstract) newClass.abstractSpecified = true; newClass.mutable = entity.GetEntityMutable(); newClass.optimisticlock = (optimisticLockMode)Enum.Parse(typeof(optimisticLockMode), entity.GetEntityOptimisticLock().ToString(), true); newClass.selectbeforeupdate = entity.GetEntitySelectBeforeUpdate(); if (entity.Cache.Usage != Cache.UsageTypes.None) { newClass.cache = new cache() { include = (cacheInclude)Enum.Parse(typeof(cacheInclude), entity.Cache.Include.ToString().Replace("_", ""), true), region = entity.Cache.Region }; switch (entity.Cache.Usage) { case Cache.UsageTypes.NonStrict_Read_Write: newClass.cache.usage = cacheUsage.nonstrictreadwrite; break; case Cache.UsageTypes.Read_Only: newClass.cache.usage = cacheUsage.@readonly; break; case Cache.UsageTypes.Read_Write: newClass.cache.usage = cacheUsage.readwrite; break; case Cache.UsageTypes.Transactional: newClass.cache.usage = cacheUsage.transactional; break; default: throw new NotImplementedException("This cache type not implemented yet: " + entity.Cache.Usage.ToString()); } } if (entity.GetEntityBatchSize() != 1) newClass.batchsize = entity.GetEntityBatchSize(); if (!string.IsNullOrWhiteSpace(entity.GetEntityProxy())) newClass.proxy = entity.GetEntityProxy(); if (!string.IsNullOrWhiteSpace(entity.GetEntityPersister())) newClass.persister = entity.GetEntityPersister(); string sqlWhere = entity.GetEntitySqlWhereClause(); if (!string.IsNullOrEmpty(sqlWhere)) newClass.where = sqlWhere; // bool isSingleColumnPK = false; if (entity.IsAbstract) { // This is an abstract class in Table Per Concrete Class inheritance. The child entities // should have properties of the same name. Entity firstChild = entity.Children.FirstOrDefault(); while (firstChild != null && firstChild.IsAbstract) firstChild = firstChild.Children.FirstOrDefault(); if (firstChild != null) { ITable childTable = GetPrimaryTable(firstChild); ProcessEntityKey(firstChild, newClass, childTable); // isSingleColumnPK = childTable.ColumnsInPrimaryKey.Count() == 1; foreach (var property in entity.Properties.OrderBy(p => p.Name)) { if (firstChild.PropertiesHiddenByAbstractParent.Single(p => p.Name == property.Name).IsKeyProperty) continue; var mappedColumn = firstChild.PropertiesHiddenByAbstractParent.Single(p => p.Name == property.Name).MappedColumn(); property prop = new property { name = property.Name, column = mappedColumn.Name.BackTick() }; //AddExtraInfoToProperty(prop, property); newClass.AddProperty(prop); } } foreach (Entity child in entity.Children) { Entity theChild = child; while (theChild != null && theChild.IsAbstract) theChild = theChild.Children.FirstOrDefault(); ITable mappedTable = theChild.MappedTables().First(); unionsubclass union = new unionsubclass() { name = theChild.Name, table = mappedTable.Name.BackTick() }; newClass.AddItem1(union); List<property> unionProperties = new List<property>(); foreach (Property prop in theChild.ConcreteProperties) { if (prop.IsKeyProperty) continue; unionProperties.Add( new property() { name = prop.Name, column = prop.MappedColumn().Name.BackTick() }); //AddExtraInfoToProperty(prop, property); } union.Items = unionProperties.ToArray(); } } else { ProcessEntityKey(entity, newClass, table); // isSingleColumnPK = table.ColumnsInPrimaryKey.Count() == 1; } var propertiesAlreadyHandled = new List<Property>(); foreach (ITable joinedTable in mappedTables.OrderBy(t => t.Name)) { if (joinedTable == table) continue; join joinNode = new join(); joinNode.table = joinedTable.Name.BackTick(); joinNode.schema = joinedTable.Schema.BackTick(); int numPrimaryKeyColumns = joinedTable.ColumnsInPrimaryKey.Count(); if (numPrimaryKeyColumns > 0) { key keyNode = GetKeyNode(joinedTable); joinNode.key = keyNode; } foreach (var property in entity.Properties.OrderBy(p => p.Name)) { var mappedColumn = property.MappedColumn(); if (mappedColumn == null || mappedColumn.Parent != joinedTable) continue; property prop = new property { name = property.Name, column = mappedColumn.Name.BackTick() }; AddExtraInfoToProperty(prop, property); joinNode.AddProperty(prop); propertiesAlreadyHandled.Add(property); } newClass.AddItem1(joinNode); } var versionProperty = entity.Properties.FirstOrDefault(p => p.GetPropertyIsVersion()); if (versionProperty != null) { version versionNode = new version(); versionNode.column1 = versionProperty.MappedColumn().Name.BackTick(); versionNode.name = versionProperty.Name; versionNode.type = versionProperty.NHibernateType; // AddExtraInfoToProperty(prop, property); newClass.SetVersion(versionNode); propertiesAlreadyHandled.Add(versionProperty); } //foreach (var prop in ProcessProperties(entity.Properties.Except(propertiesAlreadyHandled).Except(entity.ForeignKeyPropertiesToExclude), isSingleColumnPK).OrderBy(p => p.name)) foreach (var prop in ProcessProperties(entity.Properties.Except(propertiesAlreadyHandled).Except(entity.ForeignKeyPropertiesToExclude)).OrderBy(p => p.name)) newClass.AddProperty(prop); // Process components, skip component used as Key. foreach (var component in ProcessComponent(entity.Components.Except(new[] { entity.Key.Component })).OrderBy(c => c.name)) newClass.AddComponent(component); ProcessInheritance(entity, newClass); var referenceMapper = new ReferenceMapper(); referenceMapper.ProcessReferences(entity, item => newClass.AddItem(item)); return newClass; }
private void ProcessJoinedSubclasses(MappingSet mappingSet, IDatabase database, EntitySet entities, Entity newEntity, IEnumerable<joinedsubclass> joinedsubclasses, ParseResults results, string unqualifiedNamespace) { if (joinedsubclasses == null) return; ITable parentTable = null; if (newEntity.MappedTables().Count() > 0) parentTable = newEntity.MappedTables().ElementAt(0); foreach (joinedsubclass hSubclass in joinedsubclasses) { Entity childEntity; string @namespace; string name; if (IsNameFullyQualified(hSubclass.name, out @namespace, out name)) { childEntity = new EntityImpl(name); string currentNamespace = ArchAngel.Interfaces.SharedData.CurrentProject.GetUserOption("ProjectNamespace") == null ? "" : ArchAngel.Interfaces.SharedData.CurrentProject.GetUserOption("ProjectNamespace").ToString(); if (string.IsNullOrWhiteSpace(currentNamespace)) ArchAngel.Interfaces.SharedData.CurrentProject.SetUserOption("ProjectNamespace", @namespace); unqualifiedNamespace = @namespace; } else childEntity = new EntityImpl(hSubclass.name); childEntity.SetEntityLazy(hSubclass.lazy); newEntity.AddChild(childEntity); var childTableMapping = new MappingImpl(); ITable subClassTable; if (!string.IsNullOrEmpty(hSubclass.table)) { string schema = ""; if (!string.IsNullOrEmpty(hSubclass.schema)) schema = hSubclass.schema; else if (parentTable != null) schema = parentTable.Schema; subClassTable = database.GetTable(hSubclass.table.UnBackTick(), schema.UnBackTick()); subClassTable.Database = database; } else subClassTable = parentTable; childTableMapping.FromTable = subClassTable; childTableMapping.ToEntity = childEntity; foreach (var hProperty in hSubclass.Properties()) { var property = CreateProperty(childEntity, childTableMapping, hProperty); SetPropertyInfoFromParsedCode(property, results, unqualifiedNamespace, childTableMapping.FromTable.Schema, hSubclass.name); } if (hSubclass.key != null) { string keyColumnName; if (!string.IsNullOrEmpty(hSubclass.key.column1)) keyColumnName = hSubclass.key.column1; else //if (hSubclass.key.column != null && hSubclass.key.column.Count() > 0) keyColumnName = hSubclass.key.column[0].name; Property keyProp = childEntity.Properties.FirstOrDefault(p => p.MappedColumn() != null && p.MappedColumn().Name == keyColumnName); if (keyProp == null) { keyProp = CreateProperty(childEntity, childTableMapping, hSubclass.key, subClassTable); SetPropertyInfoFromParsedCode(keyProp, results, unqualifiedNamespace, childTableMapping.FromTable.Schema, childEntity.Name); keyProp.IsHiddenByAbstractParent = true; } keyProp.IsKeyProperty = true; } entities.AddEntity(childEntity); mappingSet.AddMapping(childTableMapping); ProcessJoinedSubclasses(mappingSet, database, entities, childEntity, hSubclass.joinedsubclass1, results, unqualifiedNamespace); } }
public void RemoveChild(Entity entity) { if (!children.Contains(entity)) return; children.Remove(entity); entity.Parent = null; // Add the ID property back to the child entity for (int i = entity.Key.Properties.ToList().Count - 1; i >= 0; i--) { if (entity.Properties.Count(p => p == entity.Key.Properties.ElementAt(i)) == 0) entity.AddProperty(entity.Key.Properties.ElementAt(i)); } // Add any hidden properties back to the child foreach (var hiddenProperty in entity.PropertiesHiddenByAbstractParent) hiddenProperty.IsHiddenByAbstractParent = false; foreach (var hiddenProperty in entity.PropertiesInHiddenKey) hiddenProperty.IsPartOfHiddenKey = false; // Add references back between removed child and its parent, which was removed when creating the inheritance structure. if (entity.MappedTables().Count() > 0 && this.MappedTables().Count() > 0 && entity.DirectedReferences.Count(d => d.ToEntity == this) == 0) { var thisTable = this.MappedTables().ElementAt(0); var childTable = entity.MappedTables().ElementAt(0); foreach (Relationship rel in thisTable.Relationships.Where(r => (r.ForeignTable == thisTable && r.PrimaryTable == childTable) || (r.ForeignTable == childTable && r.PrimaryTable == thisTable))) ArchAngel.Providers.EntityModel.Controller.MappingLayer.MappingProcessor.ProcessRelationshipInternal(entity.EntitySet.MappingSet, rel, new ArchAngel.Providers.EntityModel.Controller.MappingLayer.OneToOneEntityProcessor()); } ChildrenChanged.RaiseDeletionEventEx(this, entity); }
public static InheritanceType DetermineInheritanceTypeWithParent(Entity entity) { if (entity.Parent == null) return InheritanceType.None; else { List<ITable> parentMappedTables = entity.Parent.MappedTables().ToList(); List<ITable> childMappedTables = entity.MappedTables().ToList(); if (childMappedTables.Count == 1 && entity.Parent.IsAbstract && parentMappedTables.Count == 0) return InheritanceType.TablePerConcreteClass; else if (childMappedTables.Count == 1 && parentMappedTables.Count == 1 && childMappedTables[0] == parentMappedTables[0]) { return InheritanceType.TablePerClassHierarchy; } else return InheritanceType.TablePerSubClass; //return DetermineInheritanceTypeWithChildren(entity.Parent); } }
public static InheritanceType DetermineInheritanceTypeWithChildren(Entity entity) { int numChildren = entity.Children.Count(); IList<ITable> mappedTables = entity.MappedTables().ToList(); if (numChildren > 0) { if (mappedTables.Count == 1) { if (entity.Children.All(e => e.MappedTables().Count() == 1 && e.MappedTables().First() == mappedTables[0])) { // All children mapped to the same table. return InheritanceType.TablePerClassHierarchy; } return InheritanceType.TablePerSubClass; } if (mappedTables.Count == 0) { // No mapping for parent class. return InheritanceType.TablePerConcreteClass; } return InheritanceType.Unsupported; } return InheritanceType.None; }
private void PostProcessEntity(MappingSet set, Entity entity) { if (entity.HasParent == false) return; var childTable = entity.MappedTables().First(); var parentTable = entity.Parent.MappedTables().First(); // Create foreign key for parent relationship // This code makes a major assumption: That the primary key of the child has the same columns // as the primary key of the parent. var name = GetNextKeyName("FK_" + parentTable.Name + "_" + childTable.Name, set); var foreignKey = new Key(name, DatabaseKeyType.Foreign); var primaryKey = parentTable.FirstPrimaryKey; var childPrimaryKey = childTable.FirstPrimaryKey; foreignKey.ReferencedKey = primaryKey; childTable.AddKey(foreignKey); foreach (var column in childPrimaryKey.Columns) { foreignKey.AddColumn(column.Name); } }
private bool IsSelectionValidForEntityRequestor(Entity selectedEntity) { List<ITable> selectedEntitiesTables = selectedEntity.MappedTables().ToList(); List<Relationship> validRelationships = new List<Relationship>(); List<ITable> validAssociationTables = new List<ITable>(); if (selectedEntitiesTables.Count == 1 && Entity.MappedTables().Count() == 1 && selectedEntitiesTables[0] == Entity.MappedTables().ElementAt(0)) { // Table Per Hierarchy inheritance return true; } if (RequestorType == RequestorTypes.Entity_Select_Parent && selectedEntitiesTables.Count == 0) { bool isOk = true; foreach (Property property in selectedEntity.Properties) { if (Entity.Properties.Count(p => p.Name == property.Name && p.Type == property.Type) == 0) { isOk = false; break; } } // This is OK for Table Per Concrete Class inheritance - the Base is totally virtual and doesn't have // a mapped table in the database, and all of it's properties exist in the child class. if (isOk) return true; } else if (RequestorType == RequestorTypes.Entity_Select_Child && selectedEntitiesTables.Count > 0) { bool isOk = true; foreach (Property property in Entity.Properties) { if (selectedEntity.Properties.Count(p => p.Name == property.Name && p.Type == property.Type) == 0) { isOk = false; break; } } // This is OK for Table Per Concrete Class inheritance - the Base is totally virtual and doesn't have // a mapped table in the database, and all of it's properties exist in the child class. if (isOk) return true; } if (SelectedRelationship != null) return true; // Check that a relationship or association table exists between the entity and the new selected entity foreach (ITable table in Entity.MappedTables()) { foreach (Relationship relationship in table.Relationships) { if (selectedEntitiesTables.Contains(relationship.PrimaryTable) || selectedEntitiesTables.Contains(relationship.ForeignTable)) { validRelationships.Add(relationship); SelectedRelationship = relationship; if (table == relationship.PrimaryTable) { CardinalityPrimary = relationship.PrimaryCardinality; CardinalityForeign = relationship.ForeignCardinality; } else { CardinalityPrimary = relationship.ForeignCardinality; CardinalityForeign = relationship.PrimaryCardinality; } break; } } if (SelectedRelationship != null) break; } IKey primaryKey = null; IKey foreignKey = null; ITable associationTable = null; if (validRelationships.Count == 0) associationTable = Entity.GetAssociationTable(selectedEntity, out CardinalityPrimary, out CardinalityForeign, out primaryKey, out foreignKey); if (validRelationships.Count == 0 && associationTable == null) { //MessageBox.Show(this, string.Format("No relationships or association tables exist between {0} and {1}.{2}You need to add a relationship (or association table) between the tables in the database, or add a virtual relationship between these tables in the table-diagrammer.", // Entity.Name, // selectedEntity.Name, // Environment.NewLine), "No valid relationships", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); //Close(); //return; return false; } if (associationTable != null) AssociationTable = associationTable; return true; }