public static Configuration CreateCfg()
{
Configuration cfg = new Configuration();
cfg.Properties[NHibernate.Cfg.Environment.Dialect] = typeof(NHibernate.Dialect.GenericDialect).FullName;
cfg.AddAssembly(typeof(MyEntity).Assembly);
cfg.CreateMappings(new NHibernate.Dialect.GenericDialect());
return cfg;
}
public void AddTypeDef()
{
var configure = new Configuration()
.DataBaseIntegration(db => db.Dialect<MsSql2005Dialect>());
configure.TypeDefinition<TableHiLoGenerator>(c=>
{
c.Alias = "HighLow";
c.Properties = new {max_lo = 99};
});
var mappings = configure.CreateMappings(Dialect.Dialect.GetDialect(configure.Properties));
var typeDef = mappings.GetTypeDef("HighLow");
Assert.That(typeDef, Is.Not.Null);
Assert.That(typeDef.Parameters["max_lo"], Is.EqualTo("99"));
}
public MigrationGenerator(NHibernate.Cfg.Configuration configuration, Encoding encoding)
{
this.Encoding = encoding;
Configuration = configuration;
Configuration.BuildMappings(); // necessary to complete columns creation (foreign keys...)
var mapping = Configuration.CreateMappings(new GenericDialect());
// extract the tables scheme
CurrentScheme = new MigrationScheme(mapping.IterateTables.Select(t => new MigrationTable(t)));
UpdateForeignKeys();
PreviousSnapshotFileName = string.Format("{0}\\previous.snapshot", Directory.GetCurrentDirectory());
}
private static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var cfg = new Configuration();
cfg.Properties[Environment.Dialect] = typeof(GenericDialect).FullName;
cfg.Properties[Environment.ProxyFactoryFactoryClass] =
"NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle";
cfg.AddAssembly(typeof(MyEntity).Assembly);
cfg.CreateMappings(new GenericDialect());
var visualizerHost = new VisualizerDevelopmentHost(
cfg, typeof(CfgVisualizer));
visualizerHost.ShowVisualizer();
}
public void WhenMapHiloToDifferentSchemaThanClassThenIdHasTheMappedSchema()
{
var mapper = new ModelMapper();
mapper.Class<MyClass>(cm =>
{
cm.Schema("aSchema");
cm.Id(x => x.Id, idm => idm.Generator(Generators.HighLow, gm => gm.Params(new
{
table = "hilosequences",
schema="gSchema"
})));
});
var conf = new Configuration();
conf.DataBaseIntegration(x=> x.Dialect<MsSql2008Dialect>());
conf.AddDeserializedMapping(mapper.CompileMappingForAllExplicitAddedEntities(), "wholeDomain");
var mappings = conf.CreateMappings(Dialect.Dialect.GetDialect());
var pc = mappings.GetClass(typeof(MyClass).FullName);
((SimpleValue)pc.Identifier).IdentifierGeneratorProperties["schema"].Should().Be("gSchema");
}
public static Configuration TypeDefinition <TDef>(this Configuration configuration, Action <ITypeDefConfigurationProperties> typeDefConfiguration)
where TDef : class
{
if (typeDefConfiguration == null)
{
return(configuration);
}
var tdConfiguration = TypeDefConfigurationProperties.Create <TDef>();
typeDefConfiguration(tdConfiguration);
if (string.IsNullOrEmpty(tdConfiguration.Alias))
{
return(configuration);
}
var mappings = configuration.CreateMappings();
mappings.LazyDialect = new Lazy <Dialect.Dialect>(() => Dialect.Dialect.GetDialect(configuration.Properties));
mappings.AddTypeDef(tdConfiguration.Alias, typeof(TDef).AssemblyQualifiedName, tdConfiguration.Properties.ToTypeParameters());
return(configuration);
}
/// <summary>
/// Initialize the SessionFactory for the given or the
/// default location.
/// </summary>
public virtual void AfterPropertiesSet()
{
// Create Configuration instance.
Configuration config = NewConfiguration();
if (this.dbProvider != null)
{
config.SetProperty(Environment.ConnectionString, dbProvider.ConnectionString);
config.SetProperty(Environment.ConnectionProvider, typeof(DbProviderWrapper).AssemblyQualifiedName);
configTimeDbProvider = this.dbProvider;
}
if (ExposeTransactionAwareSessionFactory)
{
// Set ICurrentSessionContext implementation,
// providing the Spring-managed ISession s current Session.
// Can be overridden by a custom value for the corresponding Hibernate property
config.SetProperty(Environment.CurrentSessionContextClass, typeof(SpringSessionContext).AssemblyQualifiedName);
}
if (this.entityInterceptor != null)
{
// Set given entity interceptor at SessionFactory level.
config.SetInterceptor(this.entityInterceptor);
}
if (this.namingStrategy != null)
{
// Pass given naming strategy to Hibernate Configuration.
config.SetNamingStrategy(this.namingStrategy);
}
#if NH_2_1
if (this.typeDefinitions != null)
{
// Register specified Hibernate type definitions.
IDictionary <string, string> typedProperties = new Dictionary <string, string>();
foreach (DictionaryEntry entry in hibernateProperties)
{
typedProperties.Add((string)entry.Key, (string)entry.Value);
}
Dialect dialect = Dialect.GetDialect(typedProperties);
Mappings mappings = config.CreateMappings(dialect);
for (int i = 0; i < this.typeDefinitions.Length; i++)
{
IObjectDefinition typeDef = this.typeDefinitions[i];
Dictionary <string, string> typedParamMap = new Dictionary <string, string>();
foreach (DictionaryEntry entry in typeDef.PropertyValues)
{
typedParamMap.Add((string)entry.Key, (string)entry.Value);
}
mappings.AddTypeDef(typeDef.ObjectTypeName, typeDef.ObjectTypeName, typedParamMap);
}
}
#endif
if (this.filterDefinitions != null)
{
// Register specified NHibernate FilterDefinitions.
for (int i = 0; i < this.filterDefinitions.Length; i++)
{
config.AddFilterDefinition(this.filterDefinitions[i]);
}
}
#if NH_2_1
// check whether proxy factory has been initialized
if (config.GetProperty(Environment.ProxyFactoryFactoryClass) == null &&
(hibernateProperties == null || !hibernateProperties.Contains(Environment.ProxyFactoryFactoryClass)))
{
// nothing set by user, lets use Spring.NET's proxy factory factory
#region Logging
if (log.IsInfoEnabled)
{
log.Info("Setting proxy factory to Spring provided one as user did not specify any");
}
#endregion
config.Properties.Add(
Environment.ProxyFactoryFactoryClass, typeof(Bytecode.ProxyFactoryFactory).AssemblyQualifiedName);
}
#endif
if (this.hibernateProperties != null)
{
if (config.GetProperty(Environment.ConnectionProvider) != null &&
hibernateProperties.Contains(Environment.ConnectionProvider))
{
#region Logging
if (log.IsInfoEnabled)
{
log.Info("Overriding use of Spring's Hibernate Connection Provider with [" +
hibernateProperties[Environment.ConnectionProvider] + "]");
}
#endregion
config.Properties.Remove(Environment.ConnectionProvider);
}
Dictionary <string, string> genericHibernateProperties = new Dictionary <string, string>();
foreach (DictionaryEntry entry in hibernateProperties)
{
genericHibernateProperties.Add((string)entry.Key, (string)entry.Value);
}
config.AddProperties(genericHibernateProperties);
}
if (this.mappingAssemblies != null)
{
foreach (string assemblyName in mappingAssemblies)
{
config.AddAssembly(assemblyName);
}
}
if (this.mappingResources != null)
{
IResourceLoader loader = this.ResourceLoader;
if (loader == null)
{
loader = this.applicationContext;
}
foreach (string resourceName in mappingResources)
{
config.AddInputStream(loader.GetResource(resourceName).InputStream);
}
}
if (configFilenames != null)
{
foreach (string configFilename in configFilenames)
{
config.Configure(configFilename);
}
}
#if NH_2_1
// Tell Hibernate to eagerly compile the mappings that we registered,
// for availability of the mapping information in further processing.
PostProcessMappings(config);
config.BuildMappings();
if (this.entityCacheStrategies != null)
{
// Register cache strategies for mapped entities.
foreach (string className in this.entityCacheStrategies.Keys)
{
String[] strategyAndRegion = StringUtils.CommaDelimitedListToStringArray(this.entityCacheStrategies.GetProperty(className));
if (strategyAndRegion.Length > 1)
{
config.SetCacheConcurrencyStrategy(className, strategyAndRegion[0], strategyAndRegion[1]);
}
else if (strategyAndRegion.Length > 0)
{
config.SetCacheConcurrencyStrategy(className, strategyAndRegion[0]);
}
}
}
if (this.collectionCacheStrategies != null)
{
// Register cache strategies for mapped collections.
foreach (string collRole in collectionCacheStrategies.Keys)
{
string[] strategyAndRegion = StringUtils.CommaDelimitedListToStringArray(this.collectionCacheStrategies.GetProperty(collRole));
if (strategyAndRegion.Length > 1)
{
throw new Exception("Collection cache concurrency strategy region definition not supported yet");
//config.SetCollectionCacheConcurrencyStrategy(collRole, strategyAndRegion[0], strategyAndRegion[1]);
}
else if (strategyAndRegion.Length > 0)
{
config.SetCollectionCacheConcurrencyStrategy(collRole, strategyAndRegion[0]);
}
}
}
#endif
if (this.eventListeners != null)
{
// Register specified NHibernate event listeners.
foreach (DictionaryEntry entry in eventListeners)
{
ListenerType listenerType;
try
{
listenerType = (ListenerType)Enum.Parse(typeof(ListenerType), (string)entry.Key);
}
catch
{
throw new ArgumentException(string.Format("Unable to parse string '{0}' as valid {1}", entry.Key, typeof(ListenerType)));
}
object listenerObject = entry.Value;
if (listenerObject is ICollection)
{
ICollection listeners = (ICollection)listenerObject;
EventListeners listenerRegistry = config.EventListeners;
// create the array and check that types are valid at the same time
ArrayList items = new ArrayList(listeners);
object[] listenerArray = (object[])items.ToArray(listenerRegistry.GetListenerClassFor(listenerType));
config.SetListeners(listenerType, listenerArray);
}
else
{
config.SetListener(listenerType, listenerObject);
}
}
}
// Perform custom post-processing in subclasses.
PostProcessConfiguration(config);
#if NH_2_1
if (BytecodeProvider != null)
{
// set custom IBytecodeProvider
Environment.BytecodeProvider = BytecodeProvider;
}
else
{
// use Spring's as default
// Environment.BytecodeProvider = new Bytecode.BytecodeProvider(this.applicationContext);
}
#endif
// Build SessionFactory instance.
log.Info("Building new Hibernate SessionFactory");
this.configuration = config;
this.sessionFactory = NewSessionFactory(config);
AfterSessionFactoryCreation();
// set config time DB provider back to null
configTimeDbProvider = null;
}
private static Mappings GetMappings(Configuration configuration)
{
Dialect.Dialect dialect = Dialect.Dialect.GetDialect(configuration.Properties);
return(configuration.CreateMappings(dialect));
}
private void VerifyMapping(HbmMapping mapping)
{
var dialect = new MsSql2008Dialect();
var configuration = new Configuration();
var mappings = configuration.CreateMappings(dialect);
mappings.DefaultAssembly = "NHibernate.Test";
mappings.DefaultNamespace = "NHibernate.Test.NHSpecificTest.NH1007";
var rootBinder = new MappingRootBinder(mappings, dialect);
rootBinder.Bind(mapping);
var employer = rootBinder.Mappings.GetClass("NHibernate.Test.NHSpecificTest.NH1007.Employer1");
var simpleValue = employer.Identifier as SimpleValue;
if (simpleValue != null)
{
Assert.That(simpleValue.IdentifierGeneratorStrategy, Is.EqualTo("guid"));
Assert.That(simpleValue.IdentifierGeneratorProperties, Is.Empty);
}
}