/// <summary> /// Gets the CompositeId of the @class if it exists /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static compositeid CompositeId(this @class theClass) { if (theClass.Item != null && theClass.Item is compositeid) { return((compositeid)theClass.Item); } return(null); }
/// <summary> /// Gets the Version of the @class if it exists /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static version Version(this @class theClass) { if (theClass.Item1 != null && theClass.Item1 is version) { return((version)theClass.Item1); } return(null); }
public static void AddClass(this hibernatemapping hm, @class @class) { if (hm.Items == null) hm.Items = new object[0]; object[] items = hm.Items; Array.Resize(ref items, hm.Items.Length + 1); items[items.Length - 1] = @class; hm.Items = items; }
public static string ResolveShortClassName(@class hClass, hibernatemapping hm) { // remove everything after the comma if there is one. int indexOfComma = Math.Max(hClass.name.IndexOf(","), hClass.name.Length); string className = hClass.name.Substring(0, indexOfComma); // If the classname is not fully qualified, return it. if (className.Contains(".") == false) return className; return className.Substring(className.LastIndexOf(".") + 1); }
public static void AddItem(this @class theClass, object property) { if (theClass.Items == null) { theClass.Items = new object[0]; } object[] items = theClass.Items; Array.Resize(ref items, theClass.Items.Length + 1); items[items.Length - 1] = property; theClass.Items = items; }
public static void AddComponent(this @class theClass, component component) { if (theClass.Items == null) { theClass.Items = new object[0]; } object[] items = theClass.Items; Array.Resize(ref items, theClass.Items.Length + 1); items[items.Length - 1] = component; theClass.Items = items; }
public static void AddSubClass(this @class theClass, @class subClass) { if (theClass.Items1 == null) { theClass.Items1 = new object[0]; } object[] items = theClass.Items1; Array.Resize(ref items, theClass.Items1.Length + 1); items[items.Length - 1] = subClass; theClass.Items1 = items; }
public static void AddItem1 <T>(this @class theClass, T property) where T : class { if (theClass.Items1 == null) { theClass.Items1 = new object[0]; } object[] items = theClass.Items1; Array.Resize(ref items, theClass.Items1.Length + 1); items[items.Length - 1] = property; theClass.Items1 = items; }
/// <summary> /// Gets a collection of union-subclasses in the @class /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static IEnumerable <unionsubclass> UnionSubClasses(this @class theClass) { if (theClass.Items1 == null) { yield break; } foreach (var item in theClass.Items1) { if (item is unionsubclass) { yield return(item as unionsubclass); } } }
/// <summary> /// Gets a collection of joined-subclasses in the @class /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static IEnumerable <joinedsubclass> JoinedSubClasses(this @class theClass) { if (theClass.Items1 == null) { yield break; } foreach (var item in theClass.Items1) { if (item is joinedsubclass) { yield return(item as joinedsubclass); } } }
/// <summary> /// Gets a collection of properties in the @class /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static IEnumerable <property> Properties(this @class theClass) { if (theClass.Items == null) { yield break; } foreach (var item in theClass.Items) { if (item is property) { yield return(item as property); } } }
/// <summary> /// Gets a collection of ManyToOnes in the @class /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static IEnumerable <manytoone> ManyToOnes(this @class theClass) { if (theClass.Items == null) { yield break; } foreach (var item in theClass.Items) { if (item is manytoone) { yield return(item as manytoone); } } }
/// <summary> /// Gets a collection of Sets in the @class /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static IEnumerable <set> Sets(this @class theClass) { if (theClass.Items == null) { yield break; } foreach (var item in theClass.Items) { if (item is set) { yield return(item as set); } } }
/// <summary> /// Gets a collection of Components in the @class /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static IEnumerable <component> Components(this @class theClass) { if (theClass.Items == null) { yield break; } foreach (var item in theClass.Items) { if (item is component) { yield return(item as component); } } }
/// <summary> /// Gets a collection of Maps in the @class /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static IEnumerable <map> Maps(this @class theClass) { if (theClass.Items == null) { yield break; } foreach (var item in theClass.Items) { if (item is map) { yield return(item as map); } } }
/// <summary> /// Gets a collection of Bags in the @class /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static IEnumerable <bag> Bags(this @class theClass) { if (theClass.Items == null) { yield break; } foreach (var item in theClass.Items) { if (item is bag) { yield return(item as bag); } } }
/// <summary> /// Gets a collection of PrimitiveArrays in the @class /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static IEnumerable <primitivearray> PrimitiveArrays(this @class theClass) { if (theClass.Items == null) { yield break; } foreach (var item in theClass.Items) { if (item is primitivearray) { yield return(item as primitivearray); } } }
/// <summary> /// Gets a collection of Anys in the @class /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static IEnumerable <any> Anys(this @class theClass) { if (theClass.Items == null) { yield break; } foreach (var item in theClass.Items) { if (item is any) { yield return(item as any); } } }
public static string ResolveFullClassName(@class hClass, hibernatemapping hm) { // remove everything after the comma if there is one. int indexOfComma = Math.Max(hClass.name.IndexOf(","), hClass.name.Length); string className = hClass.name.Substring(0, indexOfComma); // If there is no default namespace specified, return the classname if (string.IsNullOrEmpty(hm.@namespace)) { return className; } // If the classname is already fully qualified, return it. if (className.Contains(".")) return className; // Otherwise prepend the default namespace return hm.@namespace + "." + className; }
private void ProcessInheritance(Entity entity, @class newClass) { EntityImpl.InheritanceType inheritanceType = EntityImpl.DetermineInheritanceTypeWithChildren(entity); switch (inheritanceType) { case EntityImpl.InheritanceType.None: case EntityImpl.InheritanceType.TablePerConcreteClass: // Table per concrete class doesn't need special treatment. break; case EntityImpl.InheritanceType.TablePerClassHierarchy: // All child entities are mapped to the same table as the parent. ProcessEntityTablePerClassHierarchy(entity, newClass); break; case EntityImpl.InheritanceType.TablePerSubClass: ProcessEntityTablePerSubClass(entity, newClass); break; case EntityImpl.InheritanceType.Unsupported: throw new Exception("An unsupported inheritance structure was detected. " + "We only support Table Per Class Hierarchy, Table Per Sub Class, and Table Per Concrete Class. " + "See the NHibernate documentation for more details."); default: throw new ArgumentOutOfRangeException(); } }
private void ProcessEntityTablePerSubClass(Entity entity, @class classNode) { foreach (var childEntity in entity.Children) { var mappedTable = childEntity.MappedTables().First(); var subclassNode = new joinedsubclass(); subclassNode.table = mappedTable.Name.BackTick(); subclassNode.schema = mappedTable.Schema.BackTick(); subclassNode.name = childEntity.Name; key keyNode = GetKeyNode(mappedTable); subclassNode.key = keyNode; foreach (var property in childEntity.ConcreteProperties) { IColumn column = property.MappedColumn(); if (column == null) continue; property propNode = ProcessProperty(property, column); subclassNode.AddProperty(propNode); } classNode.AddItem1(subclassNode); var referenceMapper = new ReferenceMapper(); referenceMapper.ProcessReferences(childEntity, item => subclassNode.AddItem(item)); ProcessInheritance(childEntity, subclassNode); } }
private void ProcessEntityTablePerClassHierarchy(Entity entity, @class classNode) { foreach (var childEntity in entity.Children) { var subclassNode = new subclass(); subclassNode.name = childEntity.Name; subclassNode.discriminatorvalue = childEntity.DiscriminatorValue; foreach (var property in childEntity.ConcreteProperties) { IColumn column = property.MappedColumn(); if (column == null) continue; property propNode = ProcessProperty(property, column); subclassNode.AddProperty(propNode); } var referenceMapper = new ReferenceMapper(); referenceMapper.ProcessReferences(childEntity, item => subclassNode.AddItem(item)); classNode.AddItem1(subclassNode); } classNode.discriminator = new discriminator(); classNode.discriminator.force = entity.Discriminator.Force; //classNode.discriminator.length = entity.Discriminator.l.Force.ToString(); //classNode.discriminator.notnull = entity.Discriminator..Force.ToString(); if (!entity.Discriminator.Insert) { classNode.discriminator.insert = entity.Discriminator.Insert; } if (entity.Discriminator.DiscriminatorType == Providers.EntityModel.Model.Enums.DiscriminatorTypes.Column) classNode.discriminator.column = entity.Discriminator.ColumnName; else classNode.discriminator.formula = entity.Discriminator.Formula; }
private void ProcessEntityKey(Entity entity, @class newClass, ITable table) { // We do nothing with EntityKeyType.Empty, as there is nothing to do. if (entity.Key.KeyType == EntityKeyType.Properties) ProcessPropertyEntityKey(entity, newClass, table); else if (entity.Key.KeyType == EntityKeyType.Component) { compositeid cId = GetCompositeIDWithComponent(entity.Key.Component); newClass.SetCompositeId(cId); } }
private Mapping CreateMappingFor(Entity entity, @class hEntity, IDatabase database, string defaultSchema) { if (hEntity.table == null) return null; Mapping mapping = new MappingImpl(); string schema = string.IsNullOrEmpty(hEntity.schema) ? defaultSchema : hEntity.schema; var table = database.GetTable(hEntity.table.UnBackTick(), schema.UnBackTick()); if (table == null) { // create the table table = entityProcessor.CreateTable(entity); database.AddTable(table); } mapping.FromTable = table; mapping.ToEntity = entity; return mapping; }
private void ProcessVersionProperty(hibernatemapping hm, @class hClass, Entity newEntity, Mapping mapping, ParseResults parseResults) { version version = hClass.Version(); var typeName = string.IsNullOrEmpty(version.type) ? "int" : version.type; var columnName = string.IsNullOrEmpty(version.column1) ? version.name : version.column1; var property = CreateProperty(newEntity, mapping, typeName, version.name, columnName, ""); property.SetPropertyIsVersion(true); SetPropertyInfoFromParsedCode(property, parseResults, hm.@namespace, mapping.FromTable.Schema, hClass.name); }
public static void AddItem <T>(this @class theClass, T property) where T : class { AddItem(theClass, property); }
public static void SetCompositeId(this @class theClass, compositeid compositeId) { theClass.Item = compositeId; }
/// <summary> /// Gets the Id of the @class if it exists /// </summary> /// <param name="theClass"></param> /// <returns></returns> public static id Id(this @class theClass) { return(theClass.Item as id); }
private void ProcessCollection( @class hClass, key keyNode, index indexNode, manytomany many, string className, string schema, string tableName, string propertyName, string cascade, AssociationType associationType, string whereClause, collectionFetchMode fetchMode, bool inverse, collectionLazy lazy, string orderByClause) { #region OrderBy string orderByPropertyName = ""; bool orderByIsAsc = true; if (!string.IsNullOrWhiteSpace(orderByClause)) { orderByClause = orderByClause.Trim(); if (orderByClause.EndsWith(" desc", StringComparison.InvariantCultureIgnoreCase)) { orderByIsAsc = false; orderByPropertyName = orderByClause.Substring(0, orderByClause.LastIndexOf(" desc", StringComparison.InvariantCultureIgnoreCase)).Trim(); } else if (orderByClause.EndsWith(" asc", StringComparison.InvariantCultureIgnoreCase)) { orderByIsAsc = false; orderByPropertyName = orderByClause.Substring(0, orderByClause.LastIndexOf(" asc", StringComparison.InvariantCultureIgnoreCase)).Trim(); } else orderByPropertyName = orderByClause; } #endregion string indexName = null; if (indexNode != null) { if (indexNode.column != null && indexNode.column.Count() > 0) indexName = indexNode.column[0].name; else indexName = indexNode.column1; } if (many != null) { var fkColumns = GetColumnNames(many.column, many.Columns()).ToList(); string thisEntityName; string otherEntityName; EntityLoader.IsNameFullyQualified(hClass.name, out thisEntityName); EntityLoader.IsNameFullyQualified(many.@class, out otherEntityName); var collectionInfo = new AssociationInformation { PropertyName = propertyName, ForeignKeyColumnNames = fkColumns, ForeignKeyBelongsToThisTable = !ForeignKeyBelongsToThisTable(hClass, fkColumns), AssociationTableName = new AssociationInformation.TableNameType(schema, tableName), ThisEntityName = thisEntityName, OtherEntityName = otherEntityName, Cardinality = Cardinality.Many, CollectionCascade = ArchAngel.Interfaces.NHibernateEnums.Helper.GetCollectionCascadeType(cascade), CollectionLazy = ArchAngel.Interfaces.NHibernateEnums.Helper.GetCollectionLazyType(lazy.ToString()), CollectionFetchMode = (CollectionFetchModes)Enum.Parse(typeof(CollectionFetchModes), fetchMode.ToString(), true), IndexColumn = indexName, WhereClause = whereClause, AssociationType = associationType, Inverse = inverse ? ArchAngel.Interfaces.NHibernateEnums.BooleanInheritedTypes.@true : ArchAngel.Interfaces.NHibernateEnums.BooleanInheritedTypes.@false, OrderByColumnName = orderByPropertyName, OrderByIsAsc = orderByIsAsc }; associationInformation.Add(collectionInfo); } else { var fkColumns = GetColumnNames(keyNode.column1, keyNode.Columns()).ToList(); string thisEntityName; string otherEntityName; EntityLoader.IsNameFullyQualified(hClass.name, out thisEntityName); EntityLoader.IsNameFullyQualified(className, out otherEntityName); bool topLevelInverse = ArchAngel.Interfaces.SharedData.CurrentProject.GetProjectDefaultInverse(); BooleanInheritedTypes inverseValue = inverse ? BooleanInheritedTypes.@true : BooleanInheritedTypes.@false; if ((inverseValue == BooleanInheritedTypes.@false && topLevelInverse == false) || (inverseValue == BooleanInheritedTypes.@true && topLevelInverse == true)) inverseValue = BooleanInheritedTypes.inherit_default; var collectionInfo = new AssociationInformation { PropertyName = propertyName, ForeignKeyColumnNames = fkColumns, ForeignKeyBelongsToThisTable = ForeignKeyBelongsToThisTable(hClass, fkColumns), // GFH ThisEntityName = thisEntityName, OtherEntityName = otherEntityName, Cardinality = Cardinality.Many, CollectionCascade = ArchAngel.Interfaces.NHibernateEnums.Helper.GetCollectionCascadeType(cascade), CollectionLazy = ArchAngel.Interfaces.NHibernateEnums.Helper.GetCollectionLazyType(lazy.ToString()), CollectionFetchMode = (CollectionFetchModes)Enum.Parse(typeof(CollectionFetchModes), fetchMode.ToString(), true), IndexColumn = indexName, AssociationType = associationType, Inverse = inverseValue, OrderByColumnName = orderByPropertyName, OrderByIsAsc = orderByIsAsc }; associationInformation.Add(collectionInfo); } }
private void ProcessPropertyEntityKey(Entity entity, @class newClass, ITable table) { var keyProperties = entity.Key.Properties; bool isSingleColumnPK = keyProperties.Count() == 1; if (isSingleColumnPK) { id newClassId = SetupSingleColumnPrimaryKey(entity); newClass.SetId(newClassId); } else { compositeid cId = GetCompositeIDWithProperties(table, entity); newClass.SetCompositeId(cId); } }
private void ProcessCompositeKey(hibernatemapping hm, @class hClass, Entity newEntity, Mapping mapping, ParseResults parseResults, compositeid hCompId) { foreach (var prop in hCompId.KeyProperties()) { var idProperty = CreateProperty(newEntity, mapping, prop); SetPropertyInfoFromParsedCode(idProperty, parseResults, hm.@namespace, mapping.FromTable.Schema, hClass.name); idProperty.IsKeyProperty = true; } }
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; }
/// <summary> /// Sets the Version of the @class /// </summary> /// <param name="theClass"></param> /// <param name="version"></param> /// <returns></returns> public static void SetVersion(this @class theClass, version version) { theClass.Item1 = version; }
private bool ForeignKeyBelongsToThisTable(@class hClass, List<string> fkColumns) { foreach (var fkCol in fkColumns) if (hClass.Properties().Count(p => p.name == fkCol.UnBackTick()) == 0) if (hClass.CompositeId() != null && hClass.CompositeId().KeyProperties().Count(p => p.name.ToLowerInvariant() == fkCol.UnBackTick().ToLowerInvariant()) == 0) return false; return true; }
public static void SetId(this @class theClass, id Id) { theClass.Item = Id; }