public static void AddProperty(this component theComponent, property property) { if (theComponent.Items == null) theComponent.Items = new object[0]; object[] items = theComponent.Items; Array.Resize(ref items, theComponent.Items.Length + 1); items[items.Length - 1] = property; theComponent.Items = items; }
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 property ProcessProperty(Property property, IColumn mappedColumn) { var propertyNode = new property { column = mappedColumn.Name.BackTick(), name = property.Name, type1 = property.NHibernateType }; var options = property.ValidationOptions; if (options.MaximumLength.HasValue && options.MaximumLength > 0 && options.MaximumLength != int.MaxValue) propertyNode.length = options.MaximumLength.Value.ToString(CultureInfo.InvariantCulture); AddExtraInfoToProperty(propertyNode, property); return propertyNode; }
private IEnumerable<component> ProcessComponent(IEnumerable<Component> components) { foreach (var component in components.OrderBy(c => c.Name)) { var componentNode = new component(); componentNode.@class = component.Specification.Name; componentNode.name = component.Name; foreach (var property in component.Properties.OrderBy(p => p.PropertyName)) { ComponentProperty representedProperty = property.RepresentedProperty; var propertyNode = new property(); propertyNode.name = representedProperty.Name; propertyNode.type1 = representedProperty.Type; propertyNode.column = property.MappedColumn().Name.BackTick(); propertyNode.notnull = true; // This must be true for Component Properties. componentNode.AddProperty(propertyNode); } yield return componentNode; } }
private void AddExtraInfoToProperty(property xmlProp, Property originalProp) { xmlProp.insert = originalProp.GetPropertyInsert(); xmlProp.update = originalProp.GetPropertyUpdate(); string formula = originalProp.GetPropertyFormula(); if (!string.IsNullOrWhiteSpace(formula)) xmlProp.formula = formula; xmlProp.optimisticlock = originalProp.GetPropertyOptimisticLock(); xmlProp.generated = (propertyGeneration)Enum.Parse(typeof(propertyGeneration), originalProp.GetPropertyGenerated().ToString()); var access = originalProp.GetPropertyAccess(); if (access != Interfaces.NHibernateEnums.PropertyAccessTypes.inherit_default) xmlProp.access = access.ToString().Replace("_", "-"); if (!originalProp.GetPropertyInsert()) { xmlProp.insertSpecified = true; xmlProp.insert = false; } if (!originalProp.GetPropertyUpdate()) { xmlProp.updateSpecified = true; xmlProp.update = false; } }
private Property CreateProperty(Entity newEntity, Mapping mapping, property hProperty) { if (hProperty.column != null) return CreateProperty(newEntity, mapping, hProperty.type1, hProperty.name, hProperty.column, hProperty.length); else { var columns = hProperty.Columns(); var columnName = columns.Count > 0 ? hProperty.Columns()[0].name : hProperty.name; return CreateProperty(newEntity, mapping, hProperty.type1, hProperty.name, columnName, hProperty.length); } }