CompositeElementMapping ICompositeElementMappingProvider.GetCompositeElementMapping() { var mapping = new CompositeElementMapping(attributes.Clone()); PopulateMapping(mapping); return(mapping); }
ManyToOneMapping IManyToOneMappingProvider.GetManyToOneMapping() { var mapping = new ManyToOneMapping(attributes.Clone()) { ContainingEntityType = entity, Member = member }; mapping.Set(x => x.Name, Layer.Defaults, member.Name); mapping.Set(x => x.Class, Layer.Defaults, new TypeReference(typeof(TOther))); if (columns.Count == 0 && !mapping.IsSpecified("Formula")) { mapping.AddColumn(Layer.Defaults, CreateColumn(member.Name + "_id")); } foreach (var column in columns) { var columnMapping = CreateColumn(column); mapping.AddColumn(Layer.UserSupplied, columnMapping); } return(mapping); }
PropertyMapping IPropertyMappingProvider.GetPropertyMapping() { var mapping = new PropertyMapping(attributes.Clone()) { ContainingEntityType = parentType, Member = member }; if (columns.Count() == 0 && !mapping.IsSpecified("Formula")) { var columnMapping = new ColumnMapping(columnAttributes.Clone()); columnMapping.Set(x => x.Name, Layer.Defaults, member.Name); mapping.AddColumn(Layer.Defaults, columnMapping); } foreach (var column in columns) { mapping.AddColumn(Layer.UserSupplied, column); } foreach (var column in mapping.Columns) { if (member.PropertyType.IsNullable() && member.PropertyType.IsEnum()) { column.Set(x => x.NotNull, Layer.Defaults, false); } column.MergeAttributes(columnAttributes); } mapping.Set(x => x.Name, Layer.Defaults, mapping.Member.Name); mapping.Set(x => x.Type, Layer.Defaults, GetDefaultType()); return(mapping); }
ColumnMapping CreateColumn(string column) { var columnMapping = new ColumnMapping(columnAttributes.Clone()); columnMapping.Set(x => x.Name, Layer.Defaults, column); return(columnMapping); }
CacheMapping ICacheMappingProvider.GetCacheMapping() { var mapping = new CacheMapping(attributes.Clone()); mapping.ContainedEntityType = entityType; return(mapping); }
SubclassMapping IIndeterminateSubclassMappingProvider.GetSubclassMapping(SubclassType type) { var mapping = new SubclassMapping(type); GenerateNestedSubclasses(mapping); attributes.Set("Type", Layer.Defaults, typeof(T)); attributes.Set("Name", Layer.Defaults, typeof(T).AssemblyQualifiedName); attributes.Set("DiscriminatorValue", Layer.Defaults, typeof(T).Name); // TODO: un-hardcode this var key = new KeyMapping(); key.AddColumn(Layer.Defaults, new ColumnMapping(typeof(T).BaseType.Name + "_id")); attributes.Set("TableName", Layer.Defaults, GetDefaultTableName()); attributes.Set("Key", Layer.Defaults, key); // TODO: this is nasty, we should find a better way mapping.OverrideAttributes(attributes.Clone()); foreach (var join in joins) { mapping.AddJoin(join); } foreach (var property in providers.Properties) { mapping.AddProperty(property.GetPropertyMapping()); } foreach (var component in providers.Components) { mapping.AddComponent(component.GetComponentMapping()); } foreach (var oneToOne in providers.OneToOnes) { mapping.AddOneToOne(oneToOne.GetOneToOneMapping()); } foreach (var collection in providers.Collections) { mapping.AddCollection(collection.GetCollectionMapping()); } foreach (var reference in providers.References) { mapping.AddReference(reference.GetManyToOneMapping()); } foreach (var any in providers.Anys) { mapping.AddAny(any.GetAnyMapping()); } return(mapping.DeepClone()); }
NaturalIdMapping INaturalIdMappingProvider.GetNaturalIdMapping() { var mapping = new NaturalIdMapping(attributes.Clone()); properties.Each(mapping.AddProperty); manyToOnes.Each(mapping.AddReference); return(mapping); }
OneToOneMapping IOneToOneMappingProvider.GetOneToOneMapping() { var mapping = new OneToOneMapping(attributes.Clone()); mapping.ContainingEntityType = entity; mapping.Set(x => x.Class, Layer.Defaults, new TypeReference(typeof(TOther))); mapping.Set(x => x.Name, Layer.Defaults, member.Name); return(mapping); }
JoinMapping IJoinMappingProvider.GetJoinMapping() { var mapping = new JoinMapping(attributes.Clone()) { ContainingEntityType = typeof(T) }; if (columns.Count == 0) { var columnMapping = new ColumnMapping(); columnMapping.Set(x => x.Name, Layer.Defaults, typeof(T).Name + "_id"); mapping.Key.AddColumn(Layer.Defaults, columnMapping); } else { foreach (var column in columns) { var columnMapping = new ColumnMapping(); columnMapping.Set(x => x.Name, Layer.Defaults, column); mapping.Key.AddColumn(Layer.UserSupplied, columnMapping); } } foreach (var property in providers.Properties) { mapping.AddProperty(property.GetPropertyMapping()); } foreach (var component in providers.Components) { mapping.AddComponent(component.GetComponentMapping()); } foreach (var reference in providers.References) { mapping.AddReference(reference.GetManyToOneMapping()); } foreach (var any in providers.Anys) { mapping.AddAny(any.GetAnyMapping()); } foreach (var collection in providers.Collections) { mapping.AddCollection(collection.GetCollectionMapping()); } foreach (var storedProcedure in providers.StoredProcedures) { mapping.AddStoredProcedure(storedProcedure.GetStoredProcedureMapping()); } return(mapping); }
CompositeIdMapping ICompositeIdMappingProvider.GetCompositeIdMapping() { var mapping = new CompositeIdMapping(attributes.Clone()) { ContainingEntityType = typeof(T) }; keys.Each(mapping.AddKey); return(mapping); }
ElementMapping IElementMappingProvider.GetElementMapping() { var mapping = new ElementMapping(attributes.Clone()); mapping.ContainingEntityType = entity; foreach (var column in Columns) { column.MergeAttributes(columnAttributes); mapping.AddColumn(Layer.Defaults, column); } return(mapping); }
IdMapping IIdentityMappingProvider.GetIdentityMapping() { var mapping = new IdMapping(attributes.Clone()) { ContainingEntityType = entityType }; if (columns.Count > 0) { foreach (var column in columns) { var columnMapping = new ColumnMapping(columnAttributes.Clone()); columnMapping.Set(x => x.Name, Layer.Defaults, column); mapping.AddColumn(Layer.UserSupplied, columnMapping); } } else if (HasNameSpecified) { var columnMapping = new ColumnMapping(columnAttributes.Clone()); columnMapping.Set(x => x.Name, Layer.Defaults, name); mapping.AddColumn(Layer.Defaults, columnMapping); } if (member != null) { mapping.Set(x => x.Name, Layer.Defaults, name); } mapping.Set(x => x.Type, Layer.Defaults, new TypeReference(identityType)); if (GeneratedBy.IsDirty) { mapping.Set(x => x.Generator, Layer.UserSupplied, GeneratedBy.GetGeneratorMapping()); } return(mapping); }
AnyMapping IAnyMappingProvider.GetAnyMapping() { var mapping = new AnyMapping(attributes.Clone()); if (typeColumns.Count() == 0) { throw new InvalidOperationException("<any> mapping is not valid without specifying an Entity Type Column"); } if (identifierColumns.Count() == 0) { throw new InvalidOperationException("<any> mapping is not valid without specifying an Entity Identifier Column"); } if (!idTypeSet) { throw new InvalidOperationException("<any> mapping is not valid without specifying an IdType"); } mapping.ContainingEntityType = entity; mapping.Set(x => x.Name, Layer.Defaults, member.Name); if (!mapping.IsSpecified("MetaType")) { mapping.Set(x => x.MetaType, Layer.Defaults, new TypeReference(member.PropertyType)); } if (metaValues.Count() > 0) { metaValues.Each(mapping.AddMetaValue); mapping.Set(x => x.MetaType, Layer.Defaults, new TypeReference(typeof(string))); } foreach (var column in typeColumns) { var columnMapping = new ColumnMapping(); columnMapping.Set(x => x.Name, Layer.Defaults, column); mapping.AddTypeColumn(Layer.UserSupplied, columnMapping); } foreach (var column in identifierColumns) { var columnMapping = new ColumnMapping(); columnMapping.Set(x => x.Name, Layer.Defaults, column); mapping.AddIdentifierColumn(Layer.UserSupplied, columnMapping); } return(mapping); }
VersionMapping IVersionMappingProvider.GetVersionMapping() { var mapping = new VersionMapping(attributes.Clone()) { ContainingEntityType = entity }; mapping.Set(x => x.Name, Layer.Defaults, member.Name); mapping.Set(x => x.Type, Layer.Defaults, member.PropertyType == typeof(DateTime) ? new TypeReference("timestamp") : new TypeReference(member.PropertyType)); var defaultColumnMapping = new ColumnMapping(columnAttributes.Clone()); defaultColumnMapping.Set(x => x.Name, Layer.Defaults, member.Name); mapping.AddColumn(Layer.Defaults, defaultColumnMapping); columns.ForEach(column => { var columnMapping = new ColumnMapping(columnAttributes.Clone()); columnMapping.Set(x => x.Name, Layer.Defaults, column); mapping.AddColumn(Layer.UserSupplied, columnMapping); }); return(mapping); }
public IndexMapping GetIndexMapping() { var mapping = new IndexMapping(attributes.Clone()); mapping.ContainingEntityType = entity; columns.Each(name => { var columnMapping = new ColumnMapping(); columnMapping.Set(x => x.Name, Layer.Defaults, name); mapping.AddColumn(Layer.UserSupplied, columnMapping); }); return(mapping); }
DiscriminatorMapping IDiscriminatorMappingProvider.GetDiscriminatorMapping() { var mapping = new DiscriminatorMapping(attributes.Clone()) { ContainingEntityType = entity, }; mapping.Set(x => x.Type, Layer.Defaults, discriminatorValueType); var columnMapping = new ColumnMapping(columnAttributes.Clone()); columnMapping.Set(x => x.Name, Layer.Defaults, columnName); mapping.AddColumn(Layer.Defaults, columnMapping); return(mapping); }
SubclassMapping ISubclassMappingProvider.GetSubclassMapping() { var mapping = new SubclassMapping(SubclassType.JoinedSubclass, attributes.Clone()); mapping.Set(x => x.Key, Layer.Defaults, new KeyMapping { ContainingEntityType = typeof(TSubclass) }); mapping.Set(x => x.Name, Layer.Defaults, typeof(TSubclass).AssemblyQualifiedName); mapping.Set(x => x.Type, Layer.Defaults, typeof(TSubclass)); foreach (var column in columns) { mapping.Key.AddColumn(Layer.Defaults, column); } foreach (var property in providers.Properties) { mapping.AddProperty(property.GetPropertyMapping()); } foreach (var component in providers.Components) { mapping.AddComponent(component.GetComponentMapping()); } foreach (var oneToOne in providers.OneToOnes) { mapping.AddOneToOne(oneToOne.GetOneToOneMapping()); } foreach (var collection in providers.Collections) { mapping.AddCollection(collection.GetCollectionMapping()); } foreach (var reference in providers.References) { mapping.AddReference(reference.GetManyToOneMapping()); } foreach (var any in providers.Anys) { mapping.AddAny(any.GetAnyMapping()); } return(mapping); }
SubclassMapping ISubclassMappingProvider.GetSubclassMapping() { var mapping = new SubclassMapping(SubclassType.Subclass, attributes.Clone()); if (discriminatorValue != null) { mapping.Set(x => x.DiscriminatorValue, Layer.Defaults, discriminatorValue); } mapping.Set(x => x.Type, Layer.Defaults, typeof(TSubclass)); mapping.Set(x => x.Name, Layer.Defaults, typeof(TSubclass).AssemblyQualifiedName); foreach (var property in providers.Properties) { mapping.AddProperty(property.GetPropertyMapping()); } foreach (var component in providers.Components) { mapping.AddComponent(component.GetComponentMapping()); } foreach (var oneToOne in providers.OneToOnes) { mapping.AddOneToOne(oneToOne.GetOneToOneMapping()); } foreach (var collection in providers.Collections) { mapping.AddCollection(collection.GetCollectionMapping()); } foreach (var reference in providers.References) { mapping.AddReference(reference.GetManyToOneMapping()); } foreach (var any in providers.Anys) { mapping.AddAny(any.GetAnyMapping()); } subclassMappings.Each(mapping.AddSubclass); return(mapping); }
protected virtual CollectionMapping GetCollectionMapping() { var mapping = collectionBuilder(collectionAttributes.Clone()); mapping.ContainingEntityType = entity; mapping.Member = member; mapping.Set(x => x.Name, Layer.Defaults, GetDefaultName()); mapping.Set(x => x.ChildType, Layer.Defaults, typeof(TChild)); mapping.Set(x => x.Key, Layer.Defaults, keyMapping); mapping.Set(x => x.Relationship, Layer.Defaults, GetRelationship()); mapping.Key.ContainingEntityType = entity; if (Cache.IsDirty) { mapping.Set(x => x.Cache, Layer.Defaults, ((ICacheMappingProvider)Cache).GetCacheMapping()); } if (componentMapping != null) { mapping.Set(x => x.CompositeElement, Layer.Defaults, componentMapping.GetCompositeElementMapping()); mapping.Set(x => x.Relationship, Layer.Defaults, null); // HACK: bad design } // HACK: Index only on list and map - shouldn't have to do this! if (mapping.Collection == Collection.Array || mapping.Collection == Collection.List || mapping.Collection == Collection.Map) { mapping.Set(x => x.Index, Layer.Defaults, indexMapping); } if (elementPart != null) { mapping.Set(x => x.Element, Layer.Defaults, ((IElementMappingProvider)elementPart).GetElementMapping()); mapping.Set(x => x.Relationship, Layer.Defaults, null); // HACK: bad design } foreach (var filterPart in Filters) { mapping.AddFilter(filterPart.GetFilterMapping()); } return(mapping); }
protected ComponentMapping CreateComponentMapping() { var mapping = CreateComponentMappingRoot(attributes.Clone()); if (member != null) { mapping.Set(x => x.Name, Layer.Defaults, member.Name); } foreach (var property in providers.Properties) { mapping.AddProperty(property.GetPropertyMapping()); } foreach (var component in providers.Components) { mapping.AddComponent(component.GetComponentMapping()); } foreach (var oneToOne in providers.OneToOnes) { mapping.AddOneToOne(oneToOne.GetOneToOneMapping()); } foreach (var collection in providers.Collections) { mapping.AddCollection(collection.GetCollectionMapping()); } foreach (var reference in providers.References) { mapping.AddReference(reference.GetManyToOneMapping()); } foreach (var any in providers.Anys) { mapping.AddAny(any.GetAnyMapping()); } return(mapping); }
public void CreateNewAttributeStore() { var store = new AttributeStore(); var value = new object(); store.Set("name1", value, new NameValueMapAttribute { Name = "A.B.C" }); store.Get("name1").Layer.ShouldEqual(3); store.Get("name1").Value.ShouldEqual(value); store.Set("name1", value, new NameValueMapAttribute { Name = "A.B" }); store.Get("name1").Layer.ShouldEqual(2); store.Get("name1").Value.ShouldEqual(value); store.Equals(store.Clone()).ShouldBeTrue(); }
protected override ComponentMapping CreateComponentMappingRoot(AttributeStore store) { return(new ExternalComponentMapping(ComponentType.Component, attributes.Clone())); }
HibernateMapping IHibernateMappingProvider.GetHibernateMapping() { return(new HibernateMapping(attributes.Clone())); }
ClassMapping IMappingProvider.GetClassMapping() { var mapping = new ClassMapping(attributes.Clone()); mapping.Set(x => x.Type, Layer.Defaults, typeof(T)); mapping.Set(x => x.Name, Layer.Defaults, typeof(T).AssemblyQualifiedName); foreach (var property in providers.Properties) { mapping.AddProperty(property.GetPropertyMapping()); } foreach (var component in providers.Components) { mapping.AddComponent(component.GetComponentMapping()); } if (providers.Version != null) { mapping.Set(x => x.Version, Layer.Defaults, providers.Version.GetVersionMapping()); } foreach (var oneToOne in providers.OneToOnes) { mapping.AddOneToOne(oneToOne.GetOneToOneMapping()); } foreach (var collection in providers.Collections) { mapping.AddCollection(collection.GetCollectionMapping()); } foreach (var reference in providers.References) { mapping.AddReference(reference.GetManyToOneMapping()); } foreach (var any in providers.Anys) { mapping.AddAny(any.GetAnyMapping()); } foreach (var subclass in providers.Subclasses.Values) { mapping.AddSubclass(subclass.GetSubclassMapping()); } foreach (var join in providers.Joins) { mapping.AddJoin(join.GetJoinMapping()); } if (providers.Discriminator != null) { mapping.Set(x => x.Discriminator, Layer.Defaults, providers.Discriminator.GetDiscriminatorMapping()); } if (Cache.IsDirty) { mapping.Set(x => x.Cache, Layer.Defaults, ((ICacheMappingProvider)Cache).GetCacheMapping()); } if (providers.Id != null) { mapping.Set(x => x.Id, Layer.Defaults, providers.Id.GetIdentityMapping()); } if (providers.CompositeId != null) { mapping.Set(x => x.Id, Layer.Defaults, providers.CompositeId.GetCompositeIdMapping()); } if (providers.NaturalId != null) { mapping.Set(x => x.NaturalId, Layer.Defaults, providers.NaturalId.GetNaturalIdMapping()); } mapping.Set(x => x.TableName, Layer.Defaults, GetDefaultTableName()); foreach (var filter in providers.Filters) { mapping.AddFilter(filter.GetFilterMapping()); } foreach (var storedProcedure in providers.StoredProcedures) { mapping.AddStoredProcedure(storedProcedure.GetStoredProcedureMapping()); } mapping.Set(x => x.Tuplizer, Layer.Defaults, providers.TuplizerMapping); return(mapping); }
internal ImportMapping GetImportMapping() { return(new ImportMapping(attributes.Clone())); }
SubclassMapping IIndeterminateSubclassMappingProvider.GetSubclassMapping(SubclassType type) { var mapping = new SubclassMapping(type); GenerateNestedSubclasses(mapping); attributes.Set("Type", Layer.Defaults, typeof(T)); attributes.Set("Name", Layer.Defaults, typeof(T).AssemblyQualifiedName); attributes.Set("DiscriminatorValue", Layer.Defaults, typeof(T).Name); // TODO: un-hardcode this Type baseType = typeof(T).BaseType ?? attributes.Get("Extends") as Type; if (baseType != null) { var key = new KeyMapping(); key.AddColumn(Layer.Defaults, new ColumnMapping(baseType.Name + "_id")); attributes.Set("Key", Layer.Defaults, key); } attributes.Set("TableName", Layer.Defaults, GetDefaultTableName()); // TODO: this is nasty, we should find a better way mapping.OverrideAttributes(attributes.Clone()); foreach (var join in joins) { mapping.AddJoin(join); } foreach (var provider in providers.OrderedProviders) { var mappingProviderObj = provider.Item2; switch (provider.Item1) { case MappingProviderStore.ProviderType.Property: mapping.AddProperty(((IPropertyMappingProvider)mappingProviderObj).GetPropertyMapping()); break; case MappingProviderStore.ProviderType.Component: mapping.AddComponent(((IComponentMappingProvider)mappingProviderObj).GetComponentMapping()); break; case MappingProviderStore.ProviderType.OneToOne: mapping.AddOneToOne(((IOneToOneMappingProvider)mappingProviderObj).GetOneToOneMapping()); break; case MappingProviderStore.ProviderType.Collection: mapping.AddCollection(((ICollectionMappingProvider)mappingProviderObj).GetCollectionMapping()); break; case MappingProviderStore.ProviderType.ManyToOne: mapping.AddReference(((IManyToOneMappingProvider)mappingProviderObj).GetManyToOneMapping()); break; case MappingProviderStore.ProviderType.Any: mapping.AddAny(((IAnyMappingProvider)mappingProviderObj).GetAnyMapping()); break; case MappingProviderStore.ProviderType.Subclass: case MappingProviderStore.ProviderType.Filter: case MappingProviderStore.ProviderType.StoredProcedure: case MappingProviderStore.ProviderType.Join: case MappingProviderStore.ProviderType.Identity: case MappingProviderStore.ProviderType.CompositeId: case MappingProviderStore.ProviderType.NaturalId: case MappingProviderStore.ProviderType.Version: case MappingProviderStore.ProviderType.Discriminator: case MappingProviderStore.ProviderType.Tupilizer: default: throw new Exception("Internal Error"); } } return(mapping.DeepClone()); }
ClassMapping IMappingProvider.GetClassMapping() { var mapping = new ClassMapping(attributes.Clone()); mapping.Set(x => x.Type, Layer.Defaults, typeof(T)); mapping.Set(x => x.Name, Layer.Defaults, typeof(T).AssemblyQualifiedName); if (providers.Version != null) { mapping.Set(x => x.Version, Layer.Defaults, providers.Version.GetVersionMapping()); } foreach (var provider in providers.OrderedProviders) { var x = provider.Item2; switch (provider.Item1) { case MappingProviderStore.ProviderType.Property: mapping.AddProperty(((IPropertyMappingProvider)x).GetPropertyMapping()); break; case MappingProviderStore.ProviderType.Component: mapping.AddComponent(((IComponentMappingProvider)x).GetComponentMapping()); break; case MappingProviderStore.ProviderType.OneToOne: mapping.AddOneToOne(((IOneToOneMappingProvider)x).GetOneToOneMapping()); break; case MappingProviderStore.ProviderType.Subclass: mapping.AddSubclass(((ISubclassMappingProvider)x).GetSubclassMapping()); break; case MappingProviderStore.ProviderType.Collection: mapping.AddCollection(((ICollectionMappingProvider)x).GetCollectionMapping()); break; case MappingProviderStore.ProviderType.ManyToOne: mapping.AddReference(((IManyToOneMappingProvider)x).GetManyToOneMapping()); break; case MappingProviderStore.ProviderType.Any: mapping.AddAny(((IAnyMappingProvider)x).GetAnyMapping()); break; case MappingProviderStore.ProviderType.Filter: mapping.AddFilter(((IFilterMappingProvider)x).GetFilterMapping()); break; case MappingProviderStore.ProviderType.StoredProcedure: mapping.AddStoredProcedure(((IStoredProcedureMappingProvider)x).GetStoredProcedureMapping()); break; case MappingProviderStore.ProviderType.Join: mapping.AddJoin(((IJoinMappingProvider)x).GetJoinMapping()); break; case MappingProviderStore.ProviderType.Identity: mapping.Set(y => y.Id, Layer.Defaults, ((IIdentityMappingProvider)x).GetIdentityMapping()); break; case MappingProviderStore.ProviderType.CompositeId: mapping.Set(y => y.Id, Layer.Defaults, ((ICompositeIdMappingProvider)x).GetCompositeIdMapping()); break; case MappingProviderStore.ProviderType.NaturalId: mapping.Set(y => y.NaturalId, Layer.Defaults, ((INaturalIdMappingProvider)x).GetNaturalIdMapping()); break; case MappingProviderStore.ProviderType.Version: mapping.Set(y => y.Version, Layer.Defaults, ((IVersionMappingProvider)x).GetVersionMapping()); break; case MappingProviderStore.ProviderType.Discriminator: mapping.Set(y => y.Discriminator, Layer.Defaults, ((IDiscriminatorMappingProvider)x).GetDiscriminatorMapping()); break; case MappingProviderStore.ProviderType.Tupilizer: mapping.Set(y => y.Tuplizer, Layer.Defaults, (TuplizerMapping)x); break; default: throw new Exception("Internal Error"); } } if (Cache.IsDirty) { mapping.Set(x => x.Cache, Layer.Defaults, ((ICacheMappingProvider)Cache).GetCacheMapping()); } mapping.Set(x => x.TableName, Layer.Defaults, GetDefaultTableName()); mapping.Set(x => x.Tuplizer, Layer.Defaults, providers.TuplizerMapping); return(mapping); }