/// <summary>
/// Initialize and configure the data source using given properties.
/// Called when space is started.
/// </summary>
/// <param name="properties">Propeties to initialize by.</param>
public override void Init(Dictionary <string, string> properties)
{
base.Init(properties);
_enumeratorLoadFetchSize = GetIntProperty("EnumeratorLoadFetchSize", _enumeratorLoadFetchSize);
_initialLoadChunkSize = GetIntProperty("InitialLoadChunkSize", _initialLoadChunkSize);
_performOrderById = GetBoolProperty("PerformOrderById", _performOrderById);
_initialLoadThreadPoolSize = GetIntProperty("InitialLoadThreadPoolSize", _initialLoadThreadPoolSize);
_useMerge = GetBoolProperty("UseMerge", _useMerge);
// only configure a session factory if it is not injected
if (_sessionFactory == null)
{
string nhibernateFile = GetFileProperty(NHibernateConfigProperty);
string hbmDirectory = GetFileProperty(NHibernateHbmDirectory);
string connectionString = GetProperty(NHibernateConnectionStringProperty);
_sessionFactory = SessionFactoryBuilder.GetFactory(nhibernateFile, hbmDirectory, connectionString);
}
// only extract managed entries if it wasn't injected
if (_managedEntries == null)
{
List <string> managedEntriesList = new List <string>();
IDictionary <string, IClassMetadata> allClassMetadata = _sessionFactory.GetAllClassMetadata();
foreach (string type in allClassMetadata.Keys)
{
managedEntriesList.Add(type);
}
ManagedEntries = managedEntriesList.ToArray();
}
// only extract initial load entries if it wasn't injected
if (_initialLoadEntries == null)
{
List <string> initialLoadEntriesList = new List <string>();
IDictionary <string, IClassMetadata> allClassMetadata = _sessionFactory.GetAllClassMetadata();
foreach (KeyValuePair <string, IClassMetadata> entry in allClassMetadata)
{
AbstractEntityPersister entityPersister = (AbstractEntityPersister)entry.Value;
string mappedSuperClass = entityPersister.MappedSuperclass;
if (mappedSuperClass != null)
{
IClassMetadata superClassMetadata = allClassMetadata[mappedSuperClass];
if (superClassMetadata.GetMappedClass(EntityMode.Map) != null)
{
//Filter out those who have their super classes mapped
continue;
}
}
initialLoadEntriesList.Add(entry.Key);
}
InitialLoadEntries = initialLoadEntriesList.ToArray();
}
}
private bool CheckDatabaseWasCleaned()
{
if (sessions.GetAllClassMetadata().Count == 0)
{
// Return early in the case of no mappings, also avoiding a warning when executing the HQL below.
return(true);
}
bool empty;
using (ISession s = sessions.OpenSession())
{
IList objects = s.CreateQuery("from System.Object o").List();
empty = objects.Count == 0;
}
if (!empty)
{
log.Error("Test case didn't clean up the database after itself, re-creating the schema");
DropSchema();
CreateSchema();
}
return(empty);
}
public static Core.Validator GetValidatorFromSession(ISessionFactory sessionFactory)
{
var allDefindedClasses = sessionFactory.GetAllClassMetadata();
Core.Validator validator = new Core.Validator();
foreach (KeyValuePair<string, IClassMetadata> pair in allDefindedClasses)
{
IClassMetadata metadata = pair.Value;
foreach (string propertyName in metadata.PropertyNames)
{
IType propertyType = metadata.GetPropertyType(propertyName);
StringType st = propertyType as StringType;
if (st != null)
{
if (st.SqlType.Length > 0)
{
validator.AddRule(Rule.For(metadata.GetMappedClass(EntityMode.Poco))
.OnMember(propertyName)
.MaxLength(st.SqlType.Length)
.Message(String.Format(
"Property {0} have a maximum length of {1}",
propertyName,
st.SqlType.Length)));
}
}
}
}
return validator;
}
public static Core.Validator GetValidatorFromSession(ISessionFactory sessionFactory)
{
var allDefindedClasses = sessionFactory.GetAllClassMetadata();
Core.Validator validator = new Core.Validator();
foreach (KeyValuePair <string, IClassMetadata> pair in allDefindedClasses)
{
IClassMetadata metadata = pair.Value;
foreach (string propertyName in metadata.PropertyNames)
{
IType propertyType = metadata.GetPropertyType(propertyName);
StringType st = propertyType as StringType;
if (st != null)
{
if (st.SqlType.Length > 0)
{
validator.AddRule(Rule.For(metadata.GetMappedClass(EntityMode.Poco))
.OnMember(propertyName)
.MaxLength(st.SqlType.Length)
.Message(String.Format(
"Property {0} have a maximum length of {1}",
propertyName,
st.SqlType.Length)));
}
}
}
}
return(validator);
}
private bool CheckDatabaseWasCleaned()
{
if (sessions.GetAllClassMetadata().Count == 0)
{
// Return early in the case of no mappings, also avoiding
// a warning when executing the HQL below.
return(true);
}
bool empty = false;
using (ISession s = sessions.OpenSession())
{
foreach (Type type in this.Mappings)
{
IList objects = s.CreateQuery("from " + type.FullName).List();
empty = objects.Count == 0;
if (!empty)
{
break;
}
}
}
if (!empty)
{
Log.Error("Test case didn't clean up the database after itself, re-creating the schema");
DropSchema();
CreateSchema();
}
return(empty);
}
/// <summary>
/// Registers the interfaces of the entities defined in the session factory in the kernel.
/// </summary>
/// <param name="kernel">The kernel.</param>
/// <param name="sessionFactory">The session factory.</param>
/// <param name="repository">The repository type to map to <seealso cref="IRepository{T}"/>.</param>
/// <param name="isCandidateForRepository">The is candidate for repository.</param>
/// <remarks>
/// The reason that we have the <paramref name="isCandidateForRepository"/> is to avoid registering services
/// for interfaces that are not related to the domain (INotifyPropertyChanged, as a good example).
/// </remarks>
public static void Register(
IKernel kernel,
ISessionFactory sessionFactory,
Type repository,
IsCandidateForRepositoryDelegate isCandidateForRepository
)
{
if (ImplementsOpenIRepository(repository) == false)
{
throw new ArgumentException("Repository must be a type inheriting from IRepository<T>, and must be an open generic type. Sample: typeof(NHRepository<>).");
}
foreach (IClassMetadata meta in sessionFactory.GetAllClassMetadata().Values)
{
Type mappedClass = meta.GetMappedClass(EntityMode.Poco);
if (mappedClass == null)
{
continue;
}
foreach (Type interfaceType in mappedClass.GetInterfaces())
{
if (isCandidateForRepository(interfaceType, mappedClass) == false)
{
continue;
}
kernel.Register(
Component.For(typeof(IRepository <>).MakeGenericType(interfaceType))
.ImplementedBy(repository.MakeGenericType(interfaceType))
.DependsOn(Property.ForKey("ConcreteType").Eq(mappedClass))
);
}
}
}
public ODataSessionFactoryContext(ISessionFactory sessionFactory)
{
Require.NotNull(sessionFactory, "sessionFactory");
MappedClassMetadata = sessionFactory.GetAllClassMetadata().Values.ToDictionary(
x => x.GetMappedClass(EntityMode.Poco),
x => new MappedClassMetadata(x)
);
}
public static ISessionFactory EnsureHasClassMetadata(this ISessionFactory source)
{
if (source.GetAllClassMetadata().Count == 0)
{
throw new Exception("В NHSessionFactory отсутствуют какие-либо ClassMetadata: вероятно MappingAssembly указана некорректно.");
}
return(source);
}
public ODataSessionFactoryContext(ISessionFactory sessionFactory)
{
Require.NotNull(sessionFactory, "sessionFactory");
MappedClassMetadata = sessionFactory.GetAllClassMetadata().Values.ToDictionary(
x => x.MappedClass,
x => new MappedClassMetadata(x)
);
}
public void CanConfirmDatabaseMatchesMappings()
{
var allClassMetadata = sessionFactory.GetAllClassMetadata();
foreach (var entry in allClassMetadata)
{
session.CreateCriteria(entry.Value.GetMappedClass(EntityMode.Poco))
.SetMaxResults(0).List();
}
}
public IList <Type> GetTables()
{
List <Type> result = new List <Type>();
foreach (var entry in _sessionFactory.GetAllClassMetadata())
{
result.Add(entry.Value.GetMappedClass(EntityMode.Poco));
}
return(result);
}
private static void ValidateDatabaseSchemaAgainstMappings(ISessionFactory sessionFactory)
{
using (var session = sessionFactory.OpenSession()) {
var classMetadatas = sessionFactory.GetAllClassMetadata();
foreach (var classMetadata in classMetadatas)
{
session.CreateCriteria(classMetadata.Value.GetMappedClass(EntityMode.Poco)).SetMaxResults(0).List();
}
}
}
/// <summary>
/// Build the Breeze metadata as a nested Dictionary.
/// The result can be converted to JSON and sent to the Breeze client.
/// </summary>
/// <param name="includeFilter">Function that returns true if a Type should be included in metadata, false otherwise</param>
/// <returns></returns>
public Metadata BuildMetadata(Func <Type, bool> includeFilter)
{
// retrieves all mappings with the name property set on the class (mapping with existing type, no duck typing)
IDictionary <string, IClassMetadata> classMeta = _sessionFactory.GetAllClassMetadata().Where(p => ((IEntityPersister)p.Value).EntityMetamodel.Type != null).ToDictionary(p => p.Key, p => p.Value);
if (includeFilter != null)
{
classMeta = classMeta.Where(p => includeFilter(((IEntityPersister)p.Value).EntityMetamodel.Type)).ToDictionary(p => p.Key, p => p.Value);
}
return(BuildMetadata(classMeta.Values));
}
public static void ClearSecondLevelCache(ISessionFactory sessionFactory)
{
var classMetadata = sessionFactory.GetAllClassMetadata();
foreach (var ep in classMetadata.Values) {
sessionFactory.EvictEntity(ep.EntityName);
}
var collMetadata = sessionFactory.GetAllCollectionMetadata();
foreach (var acp in collMetadata.Values) {
sessionFactory.EvictCollection(acp.Role);
}
}
static void ClearCache(ISessionFactory factory)
{
factory.EvictQueries();
foreach (var collectionMetadata in factory.GetAllCollectionMetadata())
{
factory.EvictCollection(collectionMetadata.Key);
}
foreach (var classMetadata in factory.GetAllClassMetadata())
{
factory.EvictEntity(classMetadata.Key);
}
}
/// <summary>
/// Build the Breeze metadata as a nested Dictionary.
/// The result can be converted to JSON and sent to the Breeze client.
/// </summary>
/// <returns></returns>
public IDictionary <string, object> BuildMetadata()
{
InitMap();
IDictionary <string, IClassMetadata> classMeta = _sessionFactory.GetAllClassMetadata();
foreach (var meta in classMeta.Values)
{
AddClass(meta);
}
return(_map);
}
/// <summary>
/// 지정된 <see cref="ISessionFactory"/> 인스턴스에 등록된 모든 NHibernate용 Entity를 조사해서,
/// 자동으로 Generic Dao (INHRepository{T} 구현 클래스)를 <see cref="IKernel"/>에 Component로 등록한다.
/// 이렇게 하면, NHRepository{T} 하나만 만들고, 실제 Entity별의 NHRepository는 Castle에 자동으로 등록되고, Instancing될 것이다!!!
/// (예 NHRepository{Blog}, NHRepository{Customer} 등을 Castle Component로 정의하지 않아도, 이 함수에서 자동으로 조사하여, IoC에 등록시켜 준다는 뜻!!!)
/// </summary>
/// <param name="sessionFactory">NHibernate Session Factory</param>
/// <param name="kernel">Castle.MicroKernel 인스턴스</param>
/// <param name="repositoryType">INHRepository{T} 를 구현한 Concrete Class Type</param>
/// <param name="isCandidateForRepository">NHibernate의 매핑된 Entity 중에 IoC Container에 등록할 Type을 선별하는 Predicator</param>
public static void Register(IKernel kernel,
ISessionFactory sessionFactory,
Type repositoryType,
Predicate <Type> isCandidateForRepository)
{
if (IsDebugEnabled)
{
log.Debug("NHibernate SessionFactory에 등록된 Entity Class에 대한 " +
@"Generic Repository (INHRepository<TEntity>) 의 인스턴스를 생성합니다. repositoryType=[{0}]", repositoryType);
}
if (IsImplementsOfGenericNHRepository(repositoryType) == false)
{
throw new InvalidOperationException("Repository must be a type inheriting from INHRepository<T>, " +
"and must be an open generic type. Sample: typeof(NHRepository<>).");
}
// GetAllClassMetadata 는 IDictionary<Type, IClassMetadata> 이고 Type은 Mapping된 entity의 Type이다.
//
foreach (IClassMetadata meta in sessionFactory.GetAllClassMetadata().Values)
{
var mappedClass = meta.GetMappedClass(EntityMode.Poco);
if (mappedClass == null)
{
continue;
}
foreach (Type interfaceType in mappedClass.GetInterfaces())
{
if (isCandidateForRepository(interfaceType))
{
if (IsDebugEnabled)
{
log.Debug("Register Generic Repository. INHRepository<{0}>", interfaceType.FullName);
}
// NOTE : INHRepository<TEnitity> 는 꼭 ConcreteType 속성 (Entity의 Type) 을 가져야한다.
//
kernel.Register(
Component
.For(typeof(INHRepository <>).MakeGenericType(interfaceType))
.ImplementedBy(repositoryType.MakeGenericType(interfaceType))
.DependsOn(Dependency.OnValue("ConcreteType", mappedClass))
.OnlyNewServices());
//.DependsOn(Property.ForKey("ConcreteType").Eq(mappedClass))
//.Unless(Component.ServiceAlreadyRegistered));
}
}
}
}
/// <summary>
/// Build the Breeze metadata as a nested Dictionary.
/// The result can be converted to JSON and sent to the Breeze client.
/// </summary>
/// <returns></returns>
public IDictionary <string, object> BuildMetadata()
{
InitMap();
// retrieves all mappings with the name property set on the class (mapping with existing type, no duck typing)
IDictionary <string, IClassMetadata> classMeta = _sessionFactory.GetAllClassMetadata().Where(p => ((IEntityPersister)p.Value).EntityMetamodel.Type != null).ToDictionary(p => p.Key, p => p.Value);
//IDictionary<string, ICollectionMetadata> collectionMeta = _sessionFactory.GetAllCollectionMetadata();
foreach (var meta in classMeta.Values)
{
AddClass(meta);
}
return(_map);
}
static IEnumerable <byte[]> CollectAllIdentifiers(ISession session)
{
ISessionFactory sessionFactory = session.SessionFactory;
IDictionary <string, IClassMetadata> allMetadata = sessionFactory.GetAllClassMetadata();
foreach (IClassMetadata classMetadata in allMetadata.Values)
{
string[] names = classMetadata.PropertyNames;
IType[] types = classMetadata.PropertyTypes;
for (int i = 0; i < names.Length; i++)
{
string name = names[i];
IType type = types[i];
if (typeof(ExternalBlobType).IsAssignableFrom(type.GetType()))
{
ICriteria criteria = CreateCriteria(session, classMetadata, name);
foreach (ExternalBlob blob in criteria.List <ExternalBlob>())
{
yield return(blob.Identifier);
}
}
if (typeof(ExternalClobType).IsAssignableFrom(type.GetType()))
{
ICriteria criteria = CreateCriteria(session, classMetadata, name);
foreach (ExternalClob clob in criteria.List <ExternalClob>())
{
yield return(clob.Identifier);
}
}
if (typeof(ExternalXlobType).IsAssignableFrom(type.GetType()))
{
ICriteria criteria = CreateCriteria(session, classMetadata, name);
foreach (ExternalXlob xlob in criteria.List <ExternalXlob>())
{
yield return(xlob.Identifier);
}
}
}
}
}
public static void ClearSecondLevelCache(ISessionFactory sessionFactory)
{
var classMetadata = sessionFactory.GetAllClassMetadata();
foreach (var ep in classMetadata.Values)
{
sessionFactory.EvictEntity(ep.EntityName);
}
var collMetadata = sessionFactory.GetAllCollectionMetadata();
foreach (var acp in collMetadata.Values)
{
sessionFactory.EvictCollection(acp.Role);
}
}
public ODataSessionFactoryContext(ISessionFactory sessionFactory)
{
Require.NotNull(sessionFactory, "sessionFactory");
/**
* 01.06.2020: change first parameter from x.GetMappedClass(EntityMode.Poco) to x.MappedClass
*/
MappedClassMetadata = sessionFactory.GetAllClassMetadata().Values.ToDictionary(
x => x.MappedClass,
x => new MappedClassMetadata(x)
);
/**
* 01.06.2020: SessionFactory extended to hold a dictionary with base type (key) and mapped class type (value).
* The dictionary will be used during building ICriteria if searched type is not mapped, but exists as key in
* this dictionary. This behavior is required if base controller classes are used and model classes are overwritten in the project
* and the project models are mapped. If the base model are queried and filtered by name of referenced type, then the
* OData.nHibernate cannot find the mapping. With the new dictionary the mapping can be found.
* The "base type to inherited mapping" can only be used, if two or more mapped classes have not the same base type.
*/
var baseTypeUse = new Dictionary <string, int>();
foreach (var mappedClass in MappedClassMetadata)
{
var baseTypeName = mappedClass.Key.BaseType.FullName;
if (baseTypeUse.ContainsKey(baseTypeName))
{
baseTypeUse[baseTypeName] += 1;
}
else
{
baseTypeUse[baseTypeName] = 1;
}
}
BaseClassToMappedClass = new Dictionary <System.Type, System.Type>();
foreach (var mappedClass in MappedClassMetadata)
{
var baseTypeName = mappedClass.Key.BaseType.FullName;
if (baseTypeUse[baseTypeName] == 1)
{
BaseClassToMappedClass[mappedClass.Key.BaseType] = mappedClass.Key;
}
}
}
public static List<ExplorerItem> GetSchema(ISessionFactory sessionFactory)
{
var items = sessionFactory.GetAllClassMetadata().Values
.Select(x => new ExplorerItem(x.EntityName, ExplorerItemKind.QueryableObject, ExplorerIcon.Table)
{
Children = x.PropertyNames.Select(p => GetPropertyItem(x, p)).ToList(),
Tag = x.GetMappedClass(EntityMode.Poco)
}).ToList();
foreach (var property in items.SelectMany(x => x.Children))
{
var type = (IType)property.Tag;
var manyToOne = type as ManyToOneType;
if (manyToOne != null)
property.HyperlinkTarget = items.Single(x => Equals(x.Tag, type.ReturnedClass));
}
return items;
}
/// <summary>
/// 지정된 <see cref="ISessionFactory"/> 인스턴스에 등록된 모든 NHibernate용 Entity를 조사해서,
/// 자동으로 Generic Dao (INHRepository{T} 구현 클래스)를 <see cref="IKernel"/>에 Component로 등록한다.
/// 이렇게 하면, NHRepository{T} 하나만 만들고, 실제 Entity별의 NHRepository는 Castle에 자동으로 등록되고, Instancing될 것이다!!!
/// (예 NHRepository{Blog}, NHRepository{Customer} 등을 Castle Component로 정의하지 않아도, 이 함수에서 자동으로 조사하여, IoC에 등록시켜 준다는 뜻!!!)
/// </summary>
/// <param name="sessionFactory">NHibernate Session Factory</param>
/// <param name="kernel">Castle.MicroKernel 인스턴스</param>
/// <param name="repositoryType">INHRepository{T} 를 구현한 Concrete Class Type</param>
/// <param name="isCandidateForRepository">NHibernate의 매핑된 Entity 중에 IoC Container에 등록할 Type을 선별하는 Predicator</param>
public static void Register(IKernel kernel,
ISessionFactory sessionFactory,
Type repositoryType,
Predicate<Type> isCandidateForRepository) {
if(IsDebugEnabled)
log.Debug("NHibernate SessionFactory에 등록된 Entity Class에 대한 " +
@"Generic Repository (INHRepository<TEntity>) 의 인스턴스를 생성합니다. repositoryType=[{0}]", repositoryType);
if(IsImplementsOfGenericNHRepository(repositoryType) == false)
throw new InvalidOperationException("Repository must be a type inheriting from INHRepository<T>, " +
"and must be an open generic type. Sample: typeof(NHRepository<>).");
// GetAllClassMetadata 는 IDictionary<Type, IClassMetadata> 이고 Type은 Mapping된 entity의 Type이다.
//
foreach(IClassMetadata meta in sessionFactory.GetAllClassMetadata().Values) {
var mappedClass = meta.GetMappedClass(EntityMode.Poco);
if(mappedClass == null)
continue;
foreach(Type interfaceType in mappedClass.GetInterfaces()) {
if(isCandidateForRepository(interfaceType)) {
if(IsDebugEnabled)
log.Debug("Register Generic Repository. INHRepository<{0}>", interfaceType.FullName);
// NOTE : INHRepository<TEnitity> 는 꼭 ConcreteType 속성 (Entity의 Type) 을 가져야한다.
//
kernel.Register(
Component
.For(typeof(INHRepository<>).MakeGenericType(interfaceType))
.ImplementedBy(repositoryType.MakeGenericType(interfaceType))
.DependsOn(Dependency.OnValue("ConcreteType", mappedClass))
.OnlyNewServices());
//.DependsOn(Property.ForKey("ConcreteType").Eq(mappedClass))
//.Unless(Component.ServiceAlreadyRegistered));
}
}
}
}
public IDictionary <string, IClassMetadata> GetAllClassMetadata() => _inner.GetAllClassMetadata();
public void Probe(ProbeContext context)
{
context.Add("persistence", "nhibernate");
context.Add("entities", _sessionFactory.GetAllClassMetadata().Select(x => x.Value.EntityName).ToArray());
}
/// <inheritdoc />
public IEnumerable <IClassMetadata> GetAll()
{
return(_sessionFactory.GetAllClassMetadata().Values);
}
public IDictionary <string, IClassMetadata> GetAllClassMetadata()
{
return(_inner.GetAllClassMetadata());
}
public IDictionary <string, IClassMetadata> GetAllClassMetadata()
{
return(_sessionFactory.GetAllClassMetadata());
}
public IEnumerable <IClassMetadata> GetAll()
{
return(_fooSessionFactory.GetAllClassMetadata().Values
.Concat(_barSessionFactory.GetAllClassMetadata().Values));
}
/// <summary>
/// Registers the interfaces of the entities defined in the session factory in the kernel.
/// </summary>
/// <param name="kernel">The kernel.</param>
/// <param name="sessionFactory">The session factory.</param>
/// <param name="repository">The repository type to map to <seealso cref="IRepository{T}"/>.</param>
/// <param name="isCandidateForRepository">The is candidate for repository.</param>
/// <remarks>
/// The reason that we have the <paramref name="isCandidateForRepository"/> is to avoid registering services
/// for interfaces that are not related to the domain (INotifyPropertyChanged, as a good example).
/// </remarks>
public static void Register(
IKernel kernel,
ISessionFactory sessionFactory,
Type repository,
IsCandidateForRepositoryDelegate isCandidateForRepository
)
{
if (ImplementsOpenIRepository(repository) == false)
throw new ArgumentException("Repository must be a type inheriting from IRepository<T>, and must be an open generic type. Sample: typeof(NHRepository<>).");
foreach (IClassMetadata meta in sessionFactory.GetAllClassMetadata().Values)
{
Type mappedClass = meta.GetMappedClass(EntityMode.Poco);
if (mappedClass == null)
continue;
foreach (Type interfaceType in mappedClass.GetInterfaces())
{
if (isCandidateForRepository(interfaceType, mappedClass) == false)
continue;
kernel.Register(
Component.For(typeof(IRepository<>).MakeGenericType(interfaceType))
.ImplementedBy(repository.MakeGenericType(interfaceType))
.DependsOn(Property.ForKey("ConcreteType").Eq(mappedClass))
);
}
}
}
