static void ExplicitMapping(ConventionModelMapper mapper)
{
mapper.Class<Master>(x =>
{
x.Id(y => y.Id, y => y.Generator(Generators.HighLow));
x.Set(y => y.Options, y =>
{
y.Key(z => z.Column("master_id"));
y.Table("master_option");
}, y =>
{
y.ManyToMany(z =>
{
z.Column("option_id");
});
});
});
mapper.Class<Option>(x =>
{
x.Id(y => y.Id, y => y.Generator(Generators.HighLow));
x.Set(y => y.Masters, y =>
{
y.Key(z => z.Column("option_id"));
y.Table("master_option");
y.Inverse(true);
}, y =>
{
y.ManyToMany(z =>
{
z.Column("master_id");
});
});
});
}
public void TestFixtureSetUp()
{
configuration = new Configuration();
configuration.SessionFactory()
.Integrate.Using<SQLiteDialect>()
.Connected.Using("Data source=testdb")
.AutoQuoteKeywords()
.LogSqlInConsole()
.EnableLogFormattedSql();
var mapper = new ConventionModelMapper();
mapper.Class<Foo>(cm => { });
mapper.Class<Bar>(cm => { });
CustomizeMapping(mapper);
var mappingDocument = mapper.CompileMappingForAllExplicitlyAddedEntities();
new XmlSerializer(typeof(HbmMapping)).Serialize(Console.Out, mappingDocument);
configuration.AddDeserializedMapping(mappingDocument, "Mappings");
new SchemaExport(configuration).Create(true, true);
sessionFactory = configuration.BuildSessionFactory();
using (var session = sessionFactory.OpenSession())
using (var tx = session.BeginTransaction())
{
var foo = new Foo { Bars = CreateCollection() };
foo.Bars.Add(new Bar { Data = 1 });
foo.Bars.Add(new Bar { Data = 2 });
id = session.Save(foo);
tx.Commit();
}
sessionFactory.Statistics.IsStatisticsEnabled = true;
}
protected override HbmMapping GetMappings()
{
var mapper = new ConventionModelMapper();
// Working Example
//mapper.Class<Toy>(rc => rc.Set(x => x.Animals, cmap => { }, rel => rel.ManyToAny<int>(meta =>
// {
// meta.MetaValue(1, typeof (Cat));
// meta.MetaValue(2, typeof (Dog));
// })));
// User needs
mapper.Class<Toy>(rc => rc.Set(x => x.Animals, cmap =>
{
cmap.Table("Animals_Toys");
cmap.Key(km => km.Column("Cat_Id"));
}, rel => rel.ManyToAny<int>(meta =>
{
meta.MetaValue(1, typeof(Cat));
meta.MetaValue(2, typeof(Dog));
meta.Columns(cid =>
{
cid.Name("Animal_Id");
cid.NotNullable(true);
}, ctype =>
{
ctype.Name("Animal_Type");
ctype.NotNullable(true);
});
})));
var mappings = mapper.CompileMappingFor(new[] { typeof(Cat), typeof(Dog), typeof(Toy) });
//Console.WriteLine(mappings.AsString()); // <=== uncomment this line to see the XML mapping
return mappings;
}
public void ProcessMapper(NHibernate.Mapping.ByCode.ConventionModelMapper mapper)
{
mapper.Class <Entity>(map =>
{
map.Version("Version", m => m.Generated(VersionGeneration.Never));
});
}
static void Main(string[] args)
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
var mapper = new ConventionModelMapper();
mapper.Class<SomeAreaClass>(c =>
{
c.Property(x => x.Area, m =>
{
m.Type<MsSql2008GeographyType>();
m.NotNullable(true);
});
});
var cfg = new Configuration()
.DataBaseIntegration(db =>
{
db.ConnectionString = "YourConnectionString";
db.Dialect<MsSql2012GeographyDialect>();
});
cfg
.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
cfg
.AddAuxiliaryDatabaseObject(new SpatialAuxiliaryDatabaseObject(cfg));
new SchemaExport(cfg).Execute(false, true, false);
}
protected override HbmMapping GetMappings()
{
var mapper = new ConventionModelMapper();
System.Type baseEntityType = typeof (DomainObject);
mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && !baseEntityType.Equals(t));
mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType));
mapper.Class<DomainObject>(r =>
{
r.Version(x => x.EntityVersion, map => { });
r.Id(x => x.ID, map => map.Generator(Generators.Native));
});
mapper.Class<Class1>(r => { r.IdBag(x => x.Class2List, map => map.Inverse(true), rel => rel.ManyToMany()); });
mapper.Class<Class2>(r => { r.IdBag<Class1>("_class1List", map => { }, rel => rel.ManyToMany()); });
HbmMapping mappings = mapper.CompileMappingFor(new[] {typeof (Class1), typeof (Class2)});
return mappings;
}
protected override void CustomizeMapping(ConventionModelMapper mapper)
{
mapper.Class<Foo>(cm => cm.List(x => x.Bars, bpm =>
{
bpm.Cascade(Cascade.All);
bpm.Type<PersistentQueryableListType<Bar>>();
}));
}
public void WhenPoidNoSetterThenApplyNosetter()
{
var mapper = new ConventionModelMapper();
mapper.Class<MyClass>(x => x.Id(mc=> mc.Id));
var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
var hbmClass = hbmMapping.RootClasses[0];
hbmClass.Id.access.Should().Be("nosetter.camelcase-underscore");
}
protected override void CustomizeMapping(ConventionModelMapper mapper)
{
mapper.Class<Foo>(cm => cm.IdBag(x => x.Bars,
bpm =>
{
bpm.Cascade(Cascade.All);
bpm.Type<PersistentQueryableIdBagType<Bar>>();
},
cer => cer.ManyToMany()));
}
public void WhenFieldAccessToField()
{
var mapper = new ConventionModelMapper();
mapper.Class<MyClass>(mc => mc.Property("aField", x => { }));
var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
var hbmClass = hbmMapping.RootClasses[0];
var hbmProperty = hbmClass.Properties.Single(x => x.Name == "aField");
hbmProperty.Access.Should().Be("field");
}
public static HbmMapping CreateMappingConfiguration()
{
var mapper = new ConventionModelMapper();
var baseEntityType = typeof (Entity);
mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface);
mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType));
mapper.BeforeMapManyToOne += (insp, prop, map) => map.Column(prop.LocalMember.GetPropertyOrFieldType().Name + "Id");
mapper.BeforeMapBag += (insp, prop, map) => map.Key(km => km.Column(prop.GetContainerEntity(insp).Name + "Id"));
mapper.BeforeMapBag += (insp, prop, map) => map.Cascade(Cascade.All);
mapper.Class<Album>(map => map.Id(x => x.AlbumId, m=> m.Generator(Generators.Identity)));
mapper.Class<Artist>(map => map.Id(x => x.ArtistId, m => m.Generator(Generators.Identity)));
var mapping = mapper.CompileMappingFor(baseEntityType.Assembly.GetExportedTypes());
return mapping;
}
public void WhenClassWithoutPoidNorGeeneratorThenApplyGuid()
{
var mapper = new ConventionModelMapper();
mapper.Class<MyClassWithoutPoid>(x => { });
var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClassWithoutPoid) });
var hbmClass = hbmMapping.RootClasses[0];
var hbmId = hbmClass.Id;
hbmId.Should().Not.Be.Null();
hbmId.generator.Should().Not.Be.Null();
[email protected]().Be("guid");
hbmId.type1.Should().Be("Guid");
}
public override void ConfigureMapping(NHibernate.Cfg.Configuration configuration)
{
var mapper = new ConventionModelMapper();
mapper.BeforeMapProperty += (inspector, member, customizer) =>
{
if (member.LocalMember.GetPropertyOrFieldType() == typeof(string))
{
customizer.Length(50);
}
};
mapper.BeforeMapClass += (inspector, type, customizer) => customizer.Id(im => im.Generator(Generators.GuidComb));
// define the mapping shape
mapper.Class<Hotel>(ca => ca.List(item => item.Reservations, cm => cm.Key(km => km.Column("HotelId"))));
mapper.Class<Room>(ca => ca.List(item => item.Reservations, cm => cm.Key(km =>
{
km.Column("RoomId");
km.OnDelete(OnDeleteAction.NoAction);
})));
mapper.Class<Reservation>(ca =>
{
ca.ManyToOne(item => item.Hotel, m => { m.Column("HotelId"); m.Insert(false); m.Update(false); m.Lazy(LazyRelation.Proxy);} );
ca.ManyToOne(item => item.Room, m => { m.Column("RoomId"); m.Insert(false); m.Update(false); m.Lazy(LazyRelation.Proxy); });
});
// list all the entities we want to map.
IEnumerable<Type> baseEntities = GetMappingTypes();
// compile the mapping for the specified entities
HbmMapping mappingDocument = mapper.CompileMappingFor(baseEntities);
// inject the mapping in NHibernate
configuration.AddDeserializedMapping(mappingDocument, "Domain");
// fix up the schema
SchemaMetadataUpdater.QuoteTableAndColumns(configuration);
SessionFactory.SessionFactoryInstance = configuration.BuildSessionFactory();
}
public void WhenClassWithoutPoidWithGeneratorThenApplyDefinedGenerator()
{
var mapper = new ConventionModelMapper();
mapper.Class<MyClassWithoutPoid>(x => x.Id(null, idm=> idm.Generator(Generators.Native)));
var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClassWithoutPoid) });
var hbmClass = hbmMapping.RootClasses[0];
var hbmId = hbmClass.Id;
hbmId.Should().Not.Be.Null();
hbmId.generator.Should().Not.Be.Null();
[email protected]().Be("native");
hbmId.type1.Should().Be(Generators.Native.DefaultReturnType.GetNhTypeName());
}
public void WhenClassWithoutPoidNorGeeneratorThenApplyGuid()
{
var mapper = new ConventionModelMapper();
mapper.Class<MyClassWithoutPoid>(x => { });
var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClassWithoutPoid) });
var hbmClass = hbmMapping.RootClasses[0];
var hbmId = hbmClass.Id;
Assert.That(hbmId, Is.Not.Null);
Assert.That(hbmId.generator, Is.Not.Null);
Assert.That(hbmId.generator.@class, Is.EqualTo("guid"));
Assert.That(hbmId.type1, Is.EqualTo("Guid"));
}
private HbmMapping GetMappingWithParentInCompo()
{
var mapper = new ConventionModelMapper();
mapper.Class<MyClass>(x =>
{
x.Id(c => c.Id);
x.Component(c => c.Compo);
});
mapper.Component<MyCompo>(x =>
{
x.Property(c => c.Something);
});
return mapper.CompileMappingForAllExplicitlyAddedEntities();
}
public void WhenPropertyVersionFromBaseEntityThenFindItAsVersion()
{
var mapper = new ConventionModelMapper();
var baseEntityType = typeof(BaseEntity);
mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface);
mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType));
mapper.Class<BaseEntity>(
map =>
{
map.Id(x => x.Id, idmap => { });
map.Version(x => x.Version, vm => { });
});
var hbmMapping = mapper.CompileMappingFor(new[] { typeof(Person) });
var hbmClass = hbmMapping.RootClasses[0];
var hbmVersion = hbmClass.Version;
Assert.That(hbmVersion, Is.Not.Null);
Assert.That(hbmVersion.name, Is.EqualTo("Version"));
}
public ISessionFactory Create()
{
var cfg = new Configuration();
cfg.DataBaseIntegration(
db =>
{
db.ConnectionString =
"Server=tcp:localhost;Database=DataSample;Trusted_Connection=true;Encrypt=False;";
db.Dialect<MsSql2008Dialect>();
db.BatchSize = 250;
db.KeywordsAutoImport = Hbm2DDLKeyWords.AutoQuote;
db.SchemaAction = SchemaAutoAction.Update;
}).SessionFactory().GenerateStatistics();
var mapper = new ConventionModelMapper();
// filter entities
var baseEntityType = typeof(AbstractEntity);
mapper.IsEntity(
(t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface);
mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType));
// override base properties
mapper.Class<AbstractEntity>(
map =>
{
map.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
});
mapper.BeforeMapProperty += OnBeforeMapProperty;
// compile
var mapping =
mapper.CompileMappingFor(
typeof(AbstractEntity).Assembly.GetExportedTypes().Where(type => typeof(AbstractEntity).IsAssignableFrom(type)));
// use mappings
cfg.AddMapping(mapping);
// build
return cfg.BuildSessionFactory();
}
public void WhenVersionFromBaseEntityThenShouldntMapVersionAsProperty()
{
var mapper = new ConventionModelMapper();
var baseEntityType = typeof(BaseEntity);
mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface);
mapper.IsRootEntity((t, declared) => baseEntityType == t.BaseType);
mapper.Class<BaseEntity>(
map =>
{
map.Id(x => x.Id, idmap => { });
map.Version(x => x.Version, vm => { });
});
var hbmMapping = mapper.CompileMappingFor(new[] { typeof(Person) });
var hbmClass = hbmMapping.RootClasses[0];
var hbmVersion = hbmClass.Version;
Assert.That(hbmVersion, Is.Not.Null);
Assert.That(hbmVersion.name, Is.EqualTo("Version"));
Assert.That(hbmClass.Properties, Is.Empty, "because one is the POID and the other is the version");
}
public void Configure(Configuration configuration)
{
var mapper = new ConventionModelMapper();
var baseEntityType = typeof (Entity);
mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface);
mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType));
mapper.BeforeMapManyToOne += (insp, prop, map) => map.Column(prop.LocalMember.GetPropertyOrFieldType().Name + "Id");
mapper.BeforeMapBag += (insp, prop, map) => map.Key(km => km.Column(prop.GetContainerEntity(insp).Name + "Id"));
mapper.BeforeMapBag += (insp, prop, map) => map.Cascade(Cascade.All);
mapper.Class<Entity>(map =>
{
map.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
map.Version(x => x.Version, m => m.Generated(VersionGeneration.Never));
});
var mapping = mapper.CompileMappingFor(baseEntityType.Assembly.GetExportedTypes());
configuration.AddDeserializedMapping(mapping, "Cronos");
}
private HbmMapping GetMappings()
{
var mapper = new ConventionModelMapper();
//var baseEntityType = typeof(Entity);
//mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface);
//mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType));
mapper.BeforeMapClass += (mi, type, map) =>
{
map.Id(g => g.Generator(Generators.Assigned));
};
mapper.Class<StoredEvent>(m => m.Property("PayLoadEvent", c =>
{
c.Type<NHibernate.Type.BinaryBlobType>();
c.Length(1048576);
}));
//mapper.Class<StoredEvent>(m => m.Property("Command", c => c.Type<NHibernate.Type.BinaryBlobType>()));
//mapper.BeforeMapBag += (mi, type, map) =>
//{
// map.Inverse(true);
// map.Lazy(CollectionLazy.Lazy);
//};
//AcademicApplication
//mapper.Class<AcademicApplication>(m =>
// {
// m.Bag(x => x.AdmissionStatuses, cm =>
// {
// cm.Table("AdmissionStatus");
// cm.Cascade(Cascade.All);
// cm.Key(k => k.Column("AcademicApplication"));
// });
// }
//);
//mapper.Class<AdmissionWorkFlow>(m =>
// {
// m.Bag(x => x.AdmissionWorkFlows, cm =>
// {
// cm.Table("AdmissionWorkFlow");
// cm.Cascade(Cascade.All);
// cm.Key(k => k.Column("ParentAdmissionWorkFlow"));
// cm.Inverse(true);
// });
// }
//);
var entities = new List<Type> { typeof(AggregateVersion), typeof(StoredEvent) };
var reportingEntities = Assembly.Load("Vaccine.Core.Domain").GetTypes();
foreach (var e in reportingEntities.Where(c=>c.Name.EndsWith("Report")))
{
entities.Add(e);
}
HbmMapping domainMapping = mapper.CompileMappingFor(entities);
return domainMapping;
}
static void MapClasses(ConventionModelMapper mapper)
{
mapper.Class<Foo>(cm => cm.Property(x => x.Date, pm => pm.Type<LocalDateType>()));
}
private void Init(XmlReader reader)
{
cfg = new Configuration();
cfg.Configure(reader);
var mapper = new ConventionModelMapper();
mapper.AfterMapClass += (inspector, type, classCustomizer) =>
{
classCustomizer.Lazy(false);
};
mapper.Class<SqlEvent>(map =>
{
map.Id(se => se.Id, idm => idm.Generator(Generators.Native));
map.Property(se => se.Payload, pm => pm.Length(8000));
});
var mapping = mapper.CompileMappingFor(new[] { typeof(SqlEvent) });
//mapper.Class<SqlEvent>(m => m.Id(evt => evt.Ticks));
//Console.Write(mapping.AsString());
cfg.AddDeserializedMapping(mapping, "AutoModel");
_sessionFactory = cfg.BuildSessionFactory();
var export = new SchemaUpdate(cfg);
export.Execute(false, true);
serializerSettings = new JsonSerializerSettings();
serializerSettings.TypeNameHandling = TypeNameHandling.All;
serializerSettings.ContractResolver = new CustomContractResolver();
}
static void Map(ConventionModelMapper mapper)
{
mapper.Class<Blog>(cm => { });
mapper.Class<Post>(cm => { });
}
public void WhenPropertyWithoutFieldNoMatch()
{
var mapper = new ConventionModelMapper();
mapper.Class<MyClass>(mc => mc.Property(x => x.PropertyWithoutField));
var hbmMapping = mapper.CompileMappingFor(new[] {typeof (MyClass)});
var hbmClass = hbmMapping.RootClasses[0];
var hbmProperty = hbmClass.Properties.Single(x => x.Name == "PropertyWithoutField");
hbmProperty.Access.Should().Not.Contain("field");
}
static void Map(ConventionModelMapper mapper)
{
mapper.Class<Blog>(cm => { });
mapper.Class<Post>(cm => cm.Bag(x => x.Categories, bpm => { }, cer => cer.ManyToMany()));
mapper.Class<Category>(cm => cm.Bag(x => x.Posts, bpm => bpm.Inverse(true), cer => cer.ManyToMany()));
}
