/// <summary>
/// Load an instance by a unique key that is not the primary key.
/// </summary>
/// <param name="entityName">The name of the entity to load </param>
/// <param name="uniqueKeyPropertyName">The name of the property defining the unique key. </param>
/// <param name="key">The unique key property value. </param>
/// <param name="session">The originating session. </param>
/// <returns> The loaded entity </returns>
public object LoadByUniqueKey(string entityName, string uniqueKeyPropertyName, object key, ISessionImplementor session)
{
ISessionFactoryImplementor factory = session.Factory;
IUniqueKeyLoadable persister = (IUniqueKeyLoadable)factory.GetEntityPersister(entityName);
//TODO: implement caching?! proxies?!
EntityUniqueKey euk =
new EntityUniqueKey(entityName, uniqueKeyPropertyName, key, GetIdentifierOrUniqueKeyType(factory),
session.EntityMode, session.Factory);
IPersistenceContext persistenceContext = session.PersistenceContext;
try
{
object result = persistenceContext.GetEntity(euk);
if (result == null)
{
result = persister.LoadByUniqueKey(uniqueKeyPropertyName, key, session);
}
return(result == null ? null : persistenceContext.ProxyFor(result));
}
catch (HibernateException)
{
// Do not call Convert on HibernateExceptions
throw;
}
catch (Exception sqle)
{
throw ADOExceptionHelper.Convert(factory.SQLExceptionConverter, sqle, "Error performing LoadByUniqueKey");
}
}
/// <summary>
/// Create an action that will evict collection and entity regions based on queryspaces (table names).
/// </summary>
public BulkOperationCleanupAction(ISessionImplementor session, ISet <string> querySpaces)
{
//from H3.2 TODO: cache the autodetected information and pass it in instead.
this.session = session;
ISet <string> tmpSpaces = new HashedSet <string>(querySpaces);
ISessionFactoryImplementor factory = session.Factory;
IDictionary <string, IClassMetadata> acmd = factory.GetAllClassMetadata();
foreach (KeyValuePair <string, IClassMetadata> entry in acmd)
{
string entityName = entry.Key;
IEntityPersister persister = factory.GetEntityPersister(entityName);
string[] entitySpaces = persister.QuerySpaces;
if (AffectedEntity(querySpaces, entitySpaces))
{
if (persister.HasCache)
{
affectedEntityNames.Add(persister.EntityName);
}
ISet <string> roles = session.Factory.GetCollectionRolesByEntityParticipant(persister.EntityName);
if (roles != null)
{
affectedCollectionRoles.AddAll(roles);
}
for (int y = 0; y < entitySpaces.Length; y++)
{
tmpSpaces.Add(entitySpaces[y]);
}
}
}
spaces = new List <string>(tmpSpaces);
}
protected virtual IEntityPersister GetEntityPersister(ISessionFactoryImplementor factory, string entityName)
{
// Check for an exact match.
IEntityPersister persister = factory.TryGetEntityPersister(entityName);
if (persister != null)
{
return(persister);
}
// Couldn't find persister through exact name, try finding a single implementing class.
string[] implementors = factory.GetImplementors(entityName);
if (implementors.Length > 1)
{
var messageBuilder = new StringBuilder(512);
messageBuilder.AppendLine(string.Format("Ambiguous persister for {0} implemented by more than one hierarchy: ",
entityName));
Array.ForEach(implementors, s => messageBuilder.AppendLine(s));
throw new HibernateException(messageBuilder.ToString());
}
if (implementors.Length == 0)
{
return(null);
}
return(factory.GetEntityPersister(implementors[0]));
}
public override string ToLoggableString(object value, ISessionFactoryImplementor factory)
{
if (value == null)
{
return("null");
}
IEntityPersister persister = factory.GetEntityPersister(associatedEntityName);
StringBuilder result = new StringBuilder().Append(associatedEntityName);
if (persister.HasIdentifierProperty)
{
EntityMode?entityMode = persister.GuessEntityMode(value);
object id;
if (!entityMode.HasValue)
{
if (isEmbeddedInXML)
{
throw new InvalidCastException(value.GetType().FullName);
}
id = value;
}
else
{
id = GetIdentifier(value, persister, entityMode.Value);
}
result.Append('#').Append(persister.IdentifierType.ToLoggableString(id, factory));
}
return(result.ToString());
}
private static bool TryGetEntityPersister(
string currentEntityName,
System.Type convertedType,
ISessionFactoryImplementor sessionFactory,
out IEntityPersister persister)
{
var currentEntityPersister = sessionFactory.TryGetEntityPersister(currentEntityName);
if (currentEntityPersister == null)
{
// When dealing with a polymorphic query it is not important which entity name we pick
// as they all need to have the same mapped types for members of the type that is queried.
// If one of the entites has a different type mapped (e.g. enum mapped as string instead of numeric),
// the query will fail to execute as currently the ParameterMetadata is bound to IQueryPlan and not to IQueryTranslator
// (e.g. s.Query<IEntity>().Where(a => a.MyEnum == MyEnum.Option)).
currentEntityName = sessionFactory.GetImplementors(currentEntityName).FirstOrDefault();
if (currentEntityName == null)
{
persister = null;
return(false);
}
currentEntityPersister = sessionFactory.GetEntityPersister(currentEntityName);
}
return(TryGetEntityPersister(currentEntityPersister, convertedType, sessionFactory, out persister));
}
protected IQueryableCollection GetQueryableCollection(string entityName, string actualPropertyName,
ISessionFactoryImplementor factory)
{
IPropertyMapping ownerMapping = (IPropertyMapping)factory.GetEntityPersister(entityName);
IType type = ownerMapping.ToType(actualPropertyName);
if (!type.IsCollectionType)
{
throw new MappingException(
"Property path [" + entityName + "." + actualPropertyName + "] does not reference a collection"
);
}
string role = ((CollectionType)type).Role;
try
{
return((IQueryableCollection)factory.GetCollectionPersister(role));
}
catch (InvalidCastException cce)
{
throw new QueryException("collection role is not queryable: " + role, cce);
}
catch (Exception e)
{
throw new QueryException("collection role not found: " + role, e);
}
}
public SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
string entityName = criteriaQuery.GetEntityName(criteria, propertyName);
string actualPropertyName = criteriaQuery.GetPropertyName(propertyName);
string sqlAlias = criteriaQuery.GetSQLAlias(criteria, propertyName);
ISessionFactoryImplementor factory = criteriaQuery.Factory;
IQueryableCollection collectionPersister = GetQueryableCollection(entityName, actualPropertyName, factory);
string[] collectionKeys = collectionPersister.KeyColumnNames;
string[] ownerKeys = ((ILoadable)factory.GetEntityPersister(entityName)).IdentifierColumnNames;
StringBuilder innerSelect = new StringBuilder();
innerSelect.Append("(select 1 from ")
.Append(collectionPersister.TableName)
.Append(" where ")
.Append(
new ConditionalFragment().SetTableAlias(sqlAlias).SetCondition(ownerKeys, collectionKeys).ToSqlStringFragment());
if (collectionPersister.HasWhere)
{
innerSelect.Append(" and (")
.Append(collectionPersister.GetSQLWhereString(collectionPersister.TableName))
.Append(") ");
}
innerSelect.Append(")");
return(new SqlString(new string[] { ExcludeEmpty ? "exists" : "not exists", innerSelect.ToString() }));
}
private IEntityPersister ResolvePersister(string entityName)
{
// Check for an exact match.
var persister = _sessionFactory.TryGetEntityPersister(entityName);
if (persister != null)
{
return(persister);
}
// Couldn't find persister through exact name, try finding a single implementing class.
string[] implementors = _sessionFactory.GetImplementors(entityName);
if (implementors.Length > 1)
{
throw new ODataException(String.Format(ErrorMessages.ODataRequest_AmbiguousEntityName, entityName));
}
else if (implementors.Length == 0)
{
return(null);
}
else
{
return(_sessionFactory.GetEntityPersister(implementors[0]));
}
}
public override bool IsEqual(object x, object y, EntityMode entityMode, ISessionFactoryImplementor factory)
{
IEntityPersister persister = factory.GetEntityPersister(associatedEntityName);
if (!persister.CanExtractIdOutOfEntity)
{
return base.IsEqual(x, y, entityMode);
}
object xid;
if (x.IsProxy())
{
INHibernateProxy proxy = x as INHibernateProxy;
xid = proxy.HibernateLazyInitializer.Identifier;
}
else
{
xid = persister.GetIdentifier(x, entityMode);
}
object yid;
if (y.IsProxy())
{
INHibernateProxy proxy = y as INHibernateProxy;
yid = proxy.HibernateLazyInitializer.Identifier;
}
else
{
yid = persister.GetIdentifier(y, entityMode);
}
return persister.IdentifierType.IsEqual(xid, yid, entityMode, factory);
}
public override bool IsEqual(object x, object y, ISessionFactoryImplementor factory)
{
IEntityPersister persister = factory.GetEntityPersister(associatedEntityName);
if (!persister.CanExtractIdOutOfEntity)
{
return(base.IsEqual(x, y));
}
object xid;
if (x.IsProxy())
{
INHibernateProxy proxy = x as INHibernateProxy;
xid = proxy.HibernateLazyInitializer.Identifier;
}
else
{
xid = persister.GetIdentifier(x);
}
object yid;
if (y.IsProxy())
{
INHibernateProxy proxy = y as INHibernateProxy;
yid = proxy.HibernateLazyInitializer.Identifier;
}
else
{
yid = persister.GetIdentifier(y);
}
return(persister.IdentifierType.IsEqual(xid, yid, factory));
}
public static Type GetRootType(ICriteria criteria)
{
Type rootType = criteria.GetRootEntityTypeIfAvailable();
if (rootType != null)
{
return(rootType);
}
CriteriaImpl impl = GetRootCriteria(criteria);
if (impl.Session == null)
{
throw new InvalidOperationException("Could not get root type on criteria that is not attached to a session");
}
ISessionFactoryImplementor factory = impl.Session.Factory;
IEntityPersister persister = factory.GetEntityPersister(impl.EntityOrClassName);
if (persister == null)
{
throw new InvalidOperationException("Could not find entity named: " + impl.EntityOrClassName);
}
return(persister.GetMappedClass(EntityMode.Poco));
}
protected IQueryableCollection GetQueryableCollection(string entityName, string actualPropertyName,
ISessionFactoryImplementor factory)
{
IPropertyMapping ownerMapping = (IPropertyMapping) factory.GetEntityPersister(entityName);
IType type = ownerMapping.ToType(actualPropertyName);
if (!type.IsCollectionType)
{
throw new MappingException(
"Property path [" + entityName + "." + actualPropertyName + "] does not reference a collection"
);
}
string role = ((CollectionType) type).Role;
try
{
return (IQueryableCollection) factory.GetCollectionPersister(role);
}
catch (InvalidCastException cce)
{
throw new QueryException("collection role is not queryable: " + role, cce);
}
catch (Exception e)
{
throw new QueryException("collection role not found: " + role, e);
}
}
/// <summary>
/// Does the mapping, and Hibernate default semantics, specify that
/// this association should be fetched by outer joining
/// </summary>
protected bool IsJoinedFetchEnabledInMapping(FetchMode config, IAssociationType type)
{
if (!type.IsEntityType && !type.IsCollectionType)
{
return(false);
}
else
{
switch (config)
{
case FetchMode.Join:
return(true);
case FetchMode.Select:
return(false);
case FetchMode.Default:
if (type.IsEntityType)
{
//TODO: look at the owning property and check that it
// isn't lazy (by instrumentation)
EntityType entityType = (EntityType)type;
IEntityPersister persister = factory.GetEntityPersister(entityType.GetAssociatedEntityName());
return(!persister.HasProxy);
}
else
{
return(false);
}
default:
throw new ArgumentOutOfRangeException("config", config, "Unknown OJ strategy " + config);
}
}
}
public static string GenerateSQL(ICriteria criteria)
{
var criteriaImpl = (CriteriaImpl)criteria;
ISessionImplementor session = criteriaImpl.Session;
ISessionFactoryImplementor factory = session.Factory;
var translator =
new CriteriaQueryTranslator(
factory,
criteriaImpl,
criteriaImpl.EntityOrClassName,
CriteriaQueryTranslator.RootSqlAlias);
String[] implementors = factory.GetImplementors(criteriaImpl.EntityOrClassName);
var walker = new CriteriaJoinWalker(
(IOuterJoinLoadable)factory.GetEntityPersister(implementors[0]),
translator,
factory,
criteriaImpl,
criteriaImpl.EntityOrClassName,
session.EnabledFilters);
return(walker.SqlString.ToString());
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
ISessionFactoryImplementor factory = criteriaQuery.Factory;
var innerQuery = new CriteriaQueryTranslator(
factory,
criteriaImpl, //implicit polymorphism not supported (would need a union)
criteriaImpl.EntityOrClassName,
criteriaQuery.GenerateSQLAlias(),
criteriaQuery);
types = innerQuery.HasProjection ? innerQuery.ProjectedTypes : null;
if (innerQuery.HasProjection == false)
{
throw new QueryException("Cannot use subqueries on a criteria without a projection.");
}
IOuterJoinLoadable persister = (IOuterJoinLoadable)factory.GetEntityPersister(criteriaImpl.EntityOrClassName);
//patch to generate joins on subqueries
//stolen from CriteriaLoader
CriteriaJoinWalker walker =
new CriteriaJoinWalker(persister, innerQuery, factory, criteriaImpl, criteriaImpl.EntityOrClassName, enabledFilters);
parameters = innerQuery.GetQueryParameters(); // parameters can be inferred only after initialize the walker
SqlString sql = walker.SqlString;
if (criteriaImpl.FirstResult != 0 || criteriaImpl.MaxResults != RowSelection.NoValue)
{
int? offset = Loader.Loader.GetOffsetUsingDialect(parameters.RowSelection, factory.Dialect);
int? limit = Loader.Loader.GetLimitUsingDialect(parameters.RowSelection, factory.Dialect);
Parameter offsetParameter = offset.HasValue ? innerQuery.CreateSkipParameter(offset.Value) : null;
Parameter limitParameter = limit.HasValue ? innerQuery.CreateTakeParameter(limit.Value) : null;
sql = factory.Dialect.GetLimitString(sql, offset, limit, offsetParameter, limitParameter);
}
SqlStringBuilder buf = new SqlStringBuilder().Add(ToLeftSqlString(criteria, criteriaQuery));
if (op != null)
{
buf.Add(" ").Add(op).Add(" ");
}
if (quantifier != null && prefixOp)
{
buf.Add(quantifier).Add(" ");
}
buf.Add("(").Add(sql).Add(")");
if (quantifier != null && prefixOp == false)
{
buf.Add(" ").Add(quantifier);
}
return(buf.ToSqlString());
}
protected override Expression VisitConstant(ConstantExpression node)
{
if (node.Value is IQueryable queryable)
{
var persister = _sessionFactoryImplementor.GetEntityPersister(queryable.ElementType.FullName);
}
return(node);
}
private Persister.Entity.IJoinable GetPathJoinable(string path)
{
// start with the root
IJoinable last = rootPersister;
var tokens = path.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
if (tokens.Length == 0)
{
return(last);
}
IPropertyMapping lastEntity = rootPersister;
int i = 0;
if (entityJoins.TryGetValue(tokens[0], out var entityJoinInfo))
{
last = entityJoinInfo.Persister;
lastEntity = (IPropertyMapping)last;
i++;
}
string componentPath = string.Empty;
for (; i < tokens.Length; i++)
{
componentPath += tokens[i];
IType type = lastEntity.ToType(componentPath);
if (type.IsAssociationType)
{
if (type.IsCollectionType)
{
// ignore joinables for composite collections
var collectionType = (CollectionType)type;
var persister = Factory.GetCollectionPersister(collectionType.Role);
if (persister.ElementType.IsEntityType == false)
{
return(null);
}
}
IAssociationType atype = (IAssociationType)type;
last = atype.GetAssociatedJoinable(Factory);
lastEntity = (NHibernate_Persister_Entity.IPropertyMapping)Factory.GetEntityPersister(atype.GetAssociatedEntityName(Factory));
componentPath = "";
}
else if (type.IsComponentType)
{
componentPath += '.';
}
else
{
throw new QueryException("not an association: " + componentPath);
}
}
return(last);
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
InitializeInnerQueryAndParameters(criteriaQuery);
if (innerQuery.HasProjection == false)
{
throw new QueryException("Cannot use subqueries on a criteria without a projection.");
}
ISessionFactoryImplementor factory = criteriaQuery.Factory;
IOuterJoinLoadable persister = (IOuterJoinLoadable)factory.GetEntityPersister(criteriaImpl.EntityOrClassName);
//patch to generate joins on subqueries
//stolen from CriteriaLoader
CriteriaJoinWalker walker =
new CriteriaJoinWalker(persister, innerQuery, factory, criteriaImpl, criteriaImpl.EntityOrClassName, enabledFilters);
parameters = innerQuery.GetQueryParameters(); // parameters can be inferred only after initialize the walker
SqlString sql = walker.SqlString;
if (criteriaImpl.FirstResult != 0 || criteriaImpl.MaxResults != RowSelection.NoValue)
{
int? offset = Loader.Loader.GetOffsetUsingDialect(parameters.RowSelection, factory.Dialect);
int? limit = Loader.Loader.GetLimitUsingDialect(parameters.RowSelection, factory.Dialect);
Parameter offsetParameter = offset.HasValue ? innerQuery.CreateSkipParameter(offset.Value) : null;
Parameter limitParameter = limit.HasValue ? innerQuery.CreateTakeParameter(limit.Value) : null;
sql = factory.Dialect.GetLimitString(sql, offset, limit, offsetParameter, limitParameter);
}
// during CriteriaImpl.Clone we are doing a shallow copy of each criterion.
// this is not a problem for common criterion but not for SubqueryExpression because here we are holding the state of inner CriteriaTraslator (ICriteriaQuery).
// After execution (ToSqlString) we have to clean the internal state because the next execution may be performed in a different tree reusing the same istance of SubqueryExpression.
innerQuery = null;
SqlStringBuilder buf = new SqlStringBuilder().Add(ToLeftSqlString(criteria, criteriaQuery));
if (op != null)
{
buf.Add(" ").Add(op).Add(" ");
}
if (quantifier != null && prefixOp)
{
buf.Add(quantifier).Add(" ");
}
buf.Add("(").Add(sql).Add(")");
if (quantifier != null && prefixOp == false)
{
buf.Add(" ").Add(quantifier);
}
return(buf.ToSqlString());
}
public void NotIgnoreSqlTypeDef()
{
var pc = factory.GetEntityPersister(typeof(MultiTypeEntity).FullName);
var type = pc.GetPropertyType("StringProp");
Assert.That(type.SqlTypes(factory)[0].Length, Is.EqualTo(100));
type = pc.GetPropertyType("AnsiStringProp");
Assert.That(type.SqlTypes(factory)[0].Length, Is.EqualTo(101));
type = pc.GetPropertyType("Decimal");
Assert.That(type.SqlTypes(factory)[0].Precision, Is.EqualTo(5));
Assert.That(type.SqlTypes(factory)[0].Scale, Is.EqualTo(2));
type = pc.GetPropertyType("Currency");
Assert.That(type.SqlTypes(factory)[0].Precision, Is.EqualTo(10));
Assert.That(type.SqlTypes(factory)[0].Scale, Is.EqualTo(3));
type = pc.GetPropertyType("Double");
Assert.That(type.SqlTypes(factory)[0].Precision, Is.EqualTo(11));
Assert.That(type.SqlTypes(factory)[0].Scale, Is.EqualTo(4));
type = pc.GetPropertyType("Float");
Assert.That(type.SqlTypes(factory)[0].Precision, Is.EqualTo(6));
Assert.That(type.SqlTypes(factory)[0].Scale, Is.EqualTo(3));
type = pc.GetPropertyType("BinaryBlob");
Assert.That(type.SqlTypes(factory)[0].Length, Is.EqualTo(1000));
type = pc.GetPropertyType("Binary");
Assert.That(type.SqlTypes(factory)[0].Length, Is.EqualTo(1001));
type = pc.GetPropertyType("StringClob");
Assert.That(type.SqlTypes(factory)[0].Length, Is.EqualTo(1002));
type = pc.GetPropertyType(nameof(MultiTypeEntity.DateTimeProp));
Assert.That(type.SqlTypes(factory)[0].Scale, Is.EqualTo(0), "Unexpected scale for DateTimeProp");
Assert.That(type.SqlTypes(factory)[0].ScaleDefined, Is.True);
type = pc.GetPropertyType(nameof(MultiTypeEntity.LocalDateTime));
Assert.That(type.SqlTypes(factory)[0].Scale, Is.EqualTo(1), "Unexpected scale for LocalDateTime");
type = pc.GetPropertyType(nameof(MultiTypeEntity.UtcDateTime));
Assert.That(type.SqlTypes(factory)[0].Scale, Is.EqualTo(2), "Unexpected scale for UtcDateTime");
type = pc.GetPropertyType(nameof(MultiTypeEntity.TimeProp));
Assert.That(type.SqlTypes(factory)[0].Scale, Is.EqualTo(3), "Unexpected scale for TimeProp");
type = pc.GetPropertyType(nameof(MultiTypeEntity.TimeAsTimeSpan));
Assert.That(type.SqlTypes(factory)[0].Scale, Is.EqualTo(4), "Unexpected scale for TimeAsTimeSpan");
type = pc.GetPropertyType(nameof(MultiTypeEntity.DateTimeOffsetProp));
Assert.That(type.SqlTypes(factory)[0].Scale, Is.EqualTo(5), "Unexpected scale for DateTimeOffsetProp");
}
private IJoinable GetPathJoinable(string path)
{
IJoinable last = (IJoinable)Factory.GetEntityPersister(rootEntityName);
IPropertyMapping lastEntity = (IPropertyMapping)last;
string componentPath = "";
StringTokenizer tokens = new StringTokenizer(path, ".", false);
foreach (string token in tokens)
{
componentPath += token;
IType type = lastEntity.ToType(componentPath);
if (type.IsAssociationType)
{
if (type.IsCollectionType)
{
// ignore joinables for composite collections
var collectionType = (CollectionType)type;
var persister = Factory.GetCollectionPersister(collectionType.Role);
if (persister.ElementType.IsEntityType == false)
{
return(null);
}
}
IAssociationType atype = (IAssociationType)type;
last = atype.GetAssociatedJoinable(Factory);
lastEntity = (IPropertyMapping)Factory.GetEntityPersister(atype.GetAssociatedEntityName(Factory));
componentPath = "";
}
else if (type.IsComponentType)
{
componentPath += '.';
}
else
{
throw new QueryException("not an association: " + componentPath);
}
}
return(last);
}
private ISqlLoadable GetSQLLoadable(string entityName)
{
IEntityPersister persister = factory.GetEntityPersister(entityName);
var persisterAsSqlLoadable = persister as ISqlLoadable;
if (persisterAsSqlLoadable == null)
{
throw new MappingException("class persister is not ISqlLoadable: " + entityName);
}
return(persisterAsSqlLoadable);
}
public static IQueryable FindQueryableUsingImports(ISessionFactoryImplementor sfi, string className)
{
string importedClassName = sfi.GetImportedClassName(className);
if (importedClassName == null)
{
return null;
}
return (IQueryable) sfi.GetEntityPersister(importedClassName, false);
}
/// <summary>
/// Locate the persister by class or entity name.
/// </summary>
/// <param name="name">The class or entity name</param>
/// <returns>The defined persister for this entity, or null if none found.</returns>
private IEntityPersister FindEntityPersisterByName(String name)
{
// First, try to get the persister using the given name directly.
try
{
return(sfi.GetEntityPersister(name));
}
catch (MappingException ignore)
{
// unable to locate it using this name
}
// If that didn't work, try using the 'import' name.
String importedClassName = sfi.GetImportedClassName(name);
if (importedClassName == null)
{
return(null);
}
return(sfi.GetEntityPersister(importedClassName));
}
private static System.Type GetRootType(DetachedCriteria criteria, ISession session)
{
ISessionFactoryImplementor factory = (ISessionFactoryImplementor)session.SessionFactory;
IEntityPersister persister = factory.GetEntityPersister(criteria.EntityOrClassName);
if (persister == null)
{
throw new InvalidOperationException("Could not find entity named: " + criteria.EntityOrClassName);
}
return(persister.GetMappedClass(EntityMode.Poco));
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
InitializeInnerQueryAndParameters(criteriaQuery);
if (innerQuery.HasProjection == false)
{
throw new QueryException("Cannot use subqueries on a criteria without a projection.");
}
ISessionFactoryImplementor factory = criteriaQuery.Factory;
IOuterJoinLoadable persister = (IOuterJoinLoadable)factory.GetEntityPersister(criteriaImpl.EntityOrClassName);
//buffer needs to be before CriteriaJoinWalker for sake of parameter order
SqlStringBuilder buf = new SqlStringBuilder().Add(ToLeftSqlString(criteria, criteriaQuery));
//patch to generate joins on subqueries
//stolen from CriteriaLoader
CriteriaJoinWalker walker =
new CriteriaJoinWalker(persister, innerQuery, factory, criteriaImpl, criteriaImpl.EntityOrClassName, enabledFilters);
SqlString sql = walker.SqlString;
if (criteriaImpl.FirstResult != 0 || criteriaImpl.MaxResults != RowSelection.NoValue)
{
int firstResults = Loader.Loader.GetFirstRow(parameters.RowSelection);
int maxResults = Loader.Loader.GetMaxOrLimit(factory.Dialect, parameters.RowSelection);
int?offsetParameterIndex = criteriaQuery.CreatePagingParameter(firstResults);
int?limitParameterIndex = criteriaQuery.CreatePagingParameter(maxResults);
sql = factory.Dialect.GetLimitString(sql, firstResults, maxResults, offsetParameterIndex, limitParameterIndex);
}
if (op != null)
{
buf.Add(" ").Add(op).Add(" ");
}
if (quantifier != null && prefixOp)
{
buf.Add(quantifier).Add(" ");
}
buf.Add("(").Add(sql).Add(")");
if (quantifier != null && prefixOp == false)
{
buf.Add(" ").Add(quantifier);
}
return(buf.ToSqlString());
}
private object AssembleCacheEntry(CacheEntry entry, object id, IEntityPersister persister, LoadEvent @event)
{
object optionalObject = @event.InstanceToLoad;
IEventSource session = @event.Session;
ISessionFactoryImplementor factory = session.Factory;
if (log.IsDebugEnabled)
{
log.Debug("assembling entity from second-level cache: " + MessageHelper.InfoString(persister, id, factory));
}
IEntityPersister subclassPersister = factory.GetEntityPersister(entry.Subclass);
object result = optionalObject ?? session.Instantiate(subclassPersister, id);
// make it circular-reference safe
TwoPhaseLoad.AddUninitializedCachedEntity(new EntityKey(id, subclassPersister, session.EntityMode), result, subclassPersister, LockMode.None, entry.AreLazyPropertiesUnfetched, entry.Version, session);
IType[] types = subclassPersister.PropertyTypes;
object[] values = entry.Assemble(result, id, subclassPersister, session.Interceptor, session); // intializes result by side-effect
TypeFactory.DeepCopy(values, types, subclassPersister.PropertyUpdateability, values, session);
object version = Versioning.GetVersion(values, subclassPersister);
if (log.IsDebugEnabled)
{
log.Debug("Cached Version: " + version);
}
IPersistenceContext persistenceContext = session.PersistenceContext;
persistenceContext.AddEntry(result, Status.Loaded, values, null, id, version, LockMode.None, true, subclassPersister, false, entry.AreLazyPropertiesUnfetched);
subclassPersister.AfterInitialize(result, entry.AreLazyPropertiesUnfetched, session);
persistenceContext.InitializeNonLazyCollections();
// upgrade the lock if necessary:
//lock(result, lockMode);
//PostLoad is needed for EJB3
//TODO: reuse the PostLoadEvent...
PostLoadEvent postLoadEvent = new PostLoadEvent(session);
postLoadEvent.Entity = result;
postLoadEvent.Id = id;
postLoadEvent.Persister = persister;
IPostLoadEventListener[] listeners = session.Listeners.PostLoadEventListeners;
for (int i = 0; i < listeners.Length; i++)
{
listeners[i].OnPostLoad(postLoadEvent);
}
return(result);
}
public void SetupTest()
{
_session = Substitute.For <ISessionImplementor>();
_factory = Substitute.For <ISessionFactoryImplementor>();
_persister = Substitute.For <IEntityPersister>();
_session.Factory.Returns(_factory);
_factory.GetAllClassMetadata().Returns(new Dictionary <string, IClassMetadata> {
["TestClass"] = null
});
_factory.GetEntityPersister("TestClass").Returns(_persister);
_factory.GetCollectionRolesByEntityParticipant("TestClass").Returns(new HashSet <string>(new[] { "TestClass.Children" }));
_persister.QuerySpaces.Returns(new[] { "TestClass" });
_persister.EntityName.Returns("TestClass");
}
public object Destructure(object item, ISessionFactoryImplementor factory)
{
IDictionary map = (IDictionary)item;
bool lazyPropertiesUnfetched = ((bool)map["_lazyPropertiesUnfetched"]);
string subclass = (string)map["_subclass"];
object version = map["_version"];
IEntityPersister subclassPersister = factory.GetEntityPersister(subclass);
string[] names = subclassPersister.PropertyNames;
object[] state = new object[names.Length];
for (int i = 0; i < names.Length; i++)
{
state[i] = map[names[i]];
}
return new CacheEntry(state, subclass, lazyPropertiesUnfetched, version);
}
private void CreateCriteriaEntityNameMap()
{
// initialize the rootProvider first
ICriteriaInfoProvider rootProvider = new EntityCriteriaInfoProvider((IQueryable)sessionFactory.GetEntityPersister(rootEntityName));
criteriaInfoMap.Add(rootCriteria, rootProvider);
nameCriteriaInfoMap.Add(rootProvider.Name, rootProvider);
foreach (KeyValuePair <string, ICriteria> me in associationPathCriteriaMap)
{
ICriteriaInfoProvider info = GetPathInfo(me.Key);
criteriaInfoMap.Add(me.Value, info);
nameCriteriaInfoMap[info.Name] = info;
}
}
public object Destructure(object item, ISessionFactoryImplementor factory)
{
IDictionary map = (IDictionary)item;
bool lazyPropertiesUnfetched = ((bool)map["_lazyPropertiesUnfetched"]);
string subclass = (string)map["_subclass"];
object version = map["_version"];
IEntityPersister subclassPersister = factory.GetEntityPersister(subclass);
string[] names = subclassPersister.PropertyNames;
object[] state = new object[names.Length];
for (int i = 0; i < names.Length; i++)
{
state[i] = map[names[i]];
}
return(new CacheEntry(state, subclass, lazyPropertiesUnfetched, version));
}
public static IDictionary <System.Type, string> GetProxyMetaData(this ISessionFactoryImplementor factory, IDictionary <string, IClassMetadata> metaData)
{
var dict = new Dictionary <System.Type, string>();
foreach (var item in metaData)
{
if (item.Value.HasProxy)
{
var proxyType = factory.GetEntityPersister(item.Key).GetConcreteProxyClass(EntityMode.Poco);
if (proxyType != item.Value.GetMappedClass(EntityMode.Poco) && !dict.ContainsKey(proxyType))
{
dict.Add(proxyType, item.Key);
}
}
}
return(dict);
}
/// <summary>
/// Load an instance by a unique key that is not the primary key.
/// </summary>
/// <param name="entityName">The name of the entity to load </param>
/// <param name="uniqueKeyPropertyName">The name of the property defining the unique key. </param>
/// <param name="key">The unique key property value. </param>
/// <param name="session">The originating session. </param>
/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
/// <returns> The loaded entity </returns>
public async Task <object> LoadByUniqueKeyAsync(string entityName, string uniqueKeyPropertyName, object key, ISessionImplementor session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ISessionFactoryImplementor factory = session.Factory;
IUniqueKeyLoadable persister = (IUniqueKeyLoadable)factory.GetEntityPersister(entityName);
//TODO: implement caching?! proxies?!
var keyType = GetIdentifierOrUniqueKeyType(factory)
// EntityUniqueKey was doing this on the type. I suspect this was needed only for its usage in Loader,
// which can work with entities as keys not yet instanciated and just represented by their identifiers.
// But since removing this call from EntityUniqueKey is done for a patch and that the code path here has
// no known bugs with this GetSemiResolvedType, moving its call here for avoiding altering this code
// path. See GH1645.
.GetSemiResolvedType(factory);
EntityUniqueKey euk =
new EntityUniqueKey(
entityName,
uniqueKeyPropertyName,
key,
keyType,
session.Factory);
IPersistenceContext persistenceContext = session.PersistenceContext;
try
{
object result = persistenceContext.GetEntity(euk);
if (result == null)
{
result = await(persister.LoadByUniqueKeyAsync(uniqueKeyPropertyName, key, session, cancellationToken)).ConfigureAwait(false);
}
return(result == null ? null : persistenceContext.ProxyFor(result));
}
catch (OperationCanceledException) { throw; }
catch (HibernateException)
{
// Do not call Convert on HibernateExceptions
throw;
}
catch (Exception sqle)
{
throw ADOExceptionHelper.Convert(factory.SQLExceptionConverter, sqle, "Error performing LoadByUniqueKey");
}
}
/// <summary>
/// Load an instance by a unique key that is not the primary key.
/// </summary>
/// <param name="entityName">The name of the entity to load </param>
/// <param name="uniqueKeyPropertyName">The name of the property defining the unique key. </param>
/// <param name="key">The unique key property value. </param>
/// <param name="session">The originating session. </param>
/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
/// <returns> The loaded entity </returns>
public async Task <object> LoadByUniqueKeyAsync(string entityName, string uniqueKeyPropertyName, object key, ISessionImplementor session, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ISessionFactoryImplementor factory = session.Factory;
IUniqueKeyLoadable persister = (IUniqueKeyLoadable)factory.GetEntityPersister(entityName);
//TODO: implement caching?! proxies?!
var keyType = GetIdentifierOrUniqueKeyType(factory)
.GetSemiResolvedType(factory);
EntityUniqueKey euk =
new EntityUniqueKey(
entityName,
uniqueKeyPropertyName,
key,
keyType,
session.Factory);
IPersistenceContext persistenceContext = session.PersistenceContext;
try
{
object result = persistenceContext.GetEntity(euk);
if (result == null)
{
result = await(persister.LoadByUniqueKeyAsync(uniqueKeyPropertyName, key, session, cancellationToken)).ConfigureAwait(false);
if (result == null && !IsNullable)
{
factory.EntityNotFoundDelegate.HandleEntityNotFound(entityName, uniqueKeyPropertyName, key);
}
}
return(result == null ? null : persistenceContext.ProxyFor(result));
}
catch (OperationCanceledException) { throw; }
catch (HibernateException)
{
// Do not call Convert on HibernateExceptions
throw;
}
catch (Exception sqle)
{
throw ADOExceptionHelper.Convert(factory.SQLExceptionConverter, sqle, "Error performing LoadByUniqueKey");
}
}
public override int GetHashCode(object x, ISessionFactoryImplementor factory)
{
IEntityPersister persister = factory.GetEntityPersister(associatedClass);
if (!persister.HasIdentifierPropertyOrEmbeddedCompositeIdentifier)
{
return base.GetHashCode(x, factory);
}
object id;
if (x is INHibernateProxy)
{
id = NHibernateProxyHelper.GetLazyInitializer((INHibernateProxy) x).Identifier;
}
else
{
id = persister.GetIdentifier(x);
}
return persister.IdentifierType.GetHashCode(id, factory);
}
public static Type GetRootType(DetachedCriteria criteria, ISession session)
{
Type rootType = criteria.GetRootEntityTypeIfAvailable();
if (rootType != null)
{
return(rootType);
}
ISessionFactoryImplementor factory = (ISessionFactoryImplementor)session.SessionFactory;
IEntityPersister persister = factory.GetEntityPersister(criteria.EntityOrClassName);
if (persister == null)
{
throw new InvalidOperationException("Could not find entity named: " + criteria.EntityOrClassName);
}
return(persister.GetMappedClass(EntityMode.Poco));
}
public override IType GetSemiResolvedType(ISessionFactoryImplementor factory)
{
return factory.GetEntityPersister(associatedEntityName).IdentifierType;
}
public override int GetHashCode(object x, EntityMode entityMode, ISessionFactoryImplementor factory)
{
IEntityPersister persister = factory.GetEntityPersister(associatedEntityName);
if (!persister.CanExtractIdOutOfEntity)
{
return base.GetHashCode(x, entityMode);
}
object id;
if (x.IsProxy())
{
INHibernateProxy proxy = x as INHibernateProxy;
id = proxy.HibernateLazyInitializer.Identifier;
}
else
{
id = persister.GetIdentifier(x, entityMode);
}
return persister.IdentifierType.GetHashCode(id, entityMode, factory);
}
public override string ToLoggableString(object value, ISessionFactoryImplementor factory)
{
if (value == null)
{
return "null";
}
IEntityPersister persister = factory.GetEntityPersister(associatedEntityName);
StringBuilder result = new StringBuilder().Append(associatedEntityName);
if (persister.HasIdentifierProperty)
{
EntityMode? entityMode = persister.GuessEntityMode(value);
object id;
if (!entityMode.HasValue)
{
if (isEmbeddedInXML)
throw new InvalidCastException(value.GetType().FullName);
id = value;
}
else
{
id = GetIdentifier(value, persister, entityMode.Value);
}
result.Append('#').Append(persister.IdentifierType.ToLoggableString(id, factory));
}
return result.ToString();
}
public CustomLoader(
ICustomQuery customQuery,
ISessionFactoryImplementor factory)
: base(factory)
{
this.sql = customQuery.SQL;
this.querySpaces.AddAll(customQuery.QuerySpaces);
this.namedParameterBindPoints = customQuery.NamedParameterBindPoints;
IList entityPersisters = new ArrayList();
IList entityOwners = new ArrayList();
IList entityAliases = new ArrayList();
IList collectionPersisters = new ArrayList();
IList collectionOwners = new ArrayList();
IList collectionAliases = new ArrayList();
IList lockModes = new ArrayList();
IList resultColumnProcessors = new ArrayList();
IList nonScalarReturnList = new ArrayList();
IList resultTypes = new ArrayList();
IList specifiedAliases = new ArrayList();
int returnableCounter = 0;
bool hasScalars = false;
foreach (IReturn rtn in customQuery.CustomQueryReturns)
{
if (rtn is ScalarReturn)
{
ScalarReturn scalarRtn = (ScalarReturn) rtn;
resultTypes.Add(scalarRtn.Type);
specifiedAliases.Add(scalarRtn.ColumnAlias);
resultColumnProcessors.Add(
new ScalarResultColumnProcessor(
scalarRtn.ColumnAlias,
scalarRtn.Type
)
);
hasScalars = true;
}
else if (rtn is RootReturn)
{
RootReturn rootRtn = (RootReturn) rtn;
IQueryable persister = (IQueryable) factory.GetEntityPersister(rootRtn.EntityName);
entityPersisters.Add(persister);
lockModes.Add(rootRtn.LockMode);
resultColumnProcessors.Add(new NonScalarResultColumnProcessor(returnableCounter++));
nonScalarReturnList.Add(rtn);
entityOwners.Add(-1);
resultTypes.Add(persister.Type);
specifiedAliases.Add(rootRtn.Alias);
entityAliases.Add(rootRtn.EntityAliases);
querySpaces.AddAll(persister.QuerySpaces);
}
else if (rtn is CollectionReturn)
{
CollectionReturn collRtn = (CollectionReturn) rtn;
String role = collRtn.OwnerEntityName + "." + collRtn.OwnerProperty;
IQueryableCollection persister = (IQueryableCollection) factory.GetCollectionPersister(role);
collectionPersisters.Add(persister);
lockModes.Add(collRtn.LockMode);
resultColumnProcessors.Add(new NonScalarResultColumnProcessor(returnableCounter++));
nonScalarReturnList.Add(rtn);
collectionOwners.Add(-1);
resultTypes.Add(persister.Type);
specifiedAliases.Add(collRtn.Alias);
collectionAliases.Add(collRtn.CollectionAliases);
// determine if the collection elements are entities...
IType elementType = persister.ElementType;
if (elementType.IsEntityType)
{
IQueryable elementPersister = (IQueryable) ((EntityType) elementType).GetAssociatedJoinable(factory);
entityPersisters.Add(elementPersister);
entityOwners.Add(-1);
entityAliases.Add(collRtn.ElementEntityAliases);
querySpaces.AddAll(elementPersister.QuerySpaces);
}
}
else if (rtn is EntityFetchReturn)
{
EntityFetchReturn fetchRtn = (EntityFetchReturn) rtn;
NonScalarReturn ownerDescriptor = fetchRtn.Owner;
int ownerIndex = nonScalarReturnList.IndexOf(ownerDescriptor);
entityOwners.Add(ownerIndex);
lockModes.Add(fetchRtn.LockMode);
IQueryable ownerPersister = DetermineAppropriateOwnerPersister(ownerDescriptor);
EntityType fetchedType = (EntityType) ownerPersister.GetPropertyType(fetchRtn.OwnerProperty);
string entityName = fetchedType.GetAssociatedEntityName(Factory);
IQueryable persister = (IQueryable) factory.GetEntityPersister(entityName);
entityPersisters.Add(persister);
nonScalarReturnList.Add(rtn);
specifiedAliases.Add(fetchRtn.Alias);
entityAliases.Add(fetchRtn.EntityAliases);
querySpaces.AddAll(persister.QuerySpaces);
}
else if (rtn is CollectionFetchReturn)
{
CollectionFetchReturn fetchRtn = (CollectionFetchReturn) rtn;
NonScalarReturn ownerDescriptor = fetchRtn.Owner;
int ownerIndex = nonScalarReturnList.IndexOf(ownerDescriptor);
collectionOwners.Add(ownerIndex);
lockModes.Add(fetchRtn.LockMode);
IQueryable ownerPersister = DetermineAppropriateOwnerPersister(ownerDescriptor);
String role = ownerPersister.EntityName + '.' + fetchRtn.OwnerProperty;
IQueryableCollection persister = (IQueryableCollection) factory.GetCollectionPersister(role);
collectionPersisters.Add(persister);
nonScalarReturnList.Add(rtn);
specifiedAliases.Add(fetchRtn.Alias);
collectionAliases.Add(fetchRtn.CollectionAliases);
// determine if the collection elements are entities...
IType elementType = persister.ElementType;
if (elementType.IsEntityType)
{
IQueryable elementPersister = (IQueryable) ((EntityType) elementType).GetAssociatedJoinable(factory);
entityPersisters.Add(elementPersister);
entityOwners.Add(ownerIndex);
entityAliases.Add(fetchRtn.ElementEntityAliases);
querySpaces.AddAll(elementPersister.QuerySpaces);
}
}
else
{
throw new HibernateException("unexpected custom query return type : " + rtn.GetType().FullName);
}
}
this.entityPersisters = new IQueryable[entityPersisters.Count];
for (int i = 0; i < entityPersisters.Count; i++)
{
this.entityPersisters[i] = (IQueryable) entityPersisters[i];
}
this.entityOwners = ArrayHelper.ToIntArray(entityOwners);
this.entityAliases = new IEntityAliases[entityAliases.Count];
for (int i = 0; i < entityAliases.Count; i++)
{
this.entityAliases[i] = (IEntityAliases) entityAliases[i];
}
this.collectionPersisters = new IQueryableCollection[collectionPersisters.Count];
for (int i = 0; i < collectionPersisters.Count; i++)
{
this.collectionPersisters[i] = (IQueryableCollection) collectionPersisters[i];
}
this.collectionOwners = ArrayHelper.ToIntArray(collectionOwners);
this.collectionAliases = new ICollectionAliases[collectionAliases.Count];
for (int i = 0; i < collectionAliases.Count; i++)
{
this.collectionAliases[i] = (ICollectionAliases) collectionAliases[i];
}
this.lockModes = new LockMode[lockModes.Count];
for (int i = 0; i < lockModes.Count; i++)
{
this.lockModes[i] = (LockMode) lockModes[i];
}
this.resultTypes = ArrayHelper.ToTypeArray(resultTypes);
this.transformerAliases = ArrayHelper.ToStringArray(specifiedAliases);
this.rowProcessor = new ResultRowProcessor(
hasScalars,
(ResultColumnProcessor[]) ArrayHelper.ToArray(resultColumnProcessors, typeof(ResultColumnProcessor))
);
}
public AbstractCollectionPersister(Mapping.Collection collection, ICacheConcurrencyStrategy cache,
ISessionFactoryImplementor factory)
{
this.factory = factory;
dialect = factory.Dialect;
this.cache = cache;
//sqlExceptionConverter = factory.SQLExceptionConverter;
collectionType = collection.CollectionType;
role = collection.Role;
ownerClass = collection.OwnerClass;
ownerPersister = factory.GetEntityPersister(ownerClass);
queryLoaderName = collection.LoaderName;
Alias alias = new Alias("__");
sqlOrderByString = collection.OrderBy;
hasOrder = sqlOrderByString != null;
sqlOrderByStringTemplate = hasOrder
? Template.RenderOrderByStringTemplate(sqlOrderByString, dialect,
factory.SQLFunctionRegistry) : null;
sqlWhereString = collection.Where;
hasWhere = sqlWhereString != null;
sqlWhereStringTemplate = hasWhere
? Template.RenderWhereStringTemplate(sqlWhereString, dialect, factory.SQLFunctionRegistry)
: null;
hasOrphanDelete = collection.OrphanDelete;
batchSize = collection.BatchSize;
isVersioned = collection.IsOptimisticLocked;
keyType = collection.Key.Type;
int keySpan = collection.Key.ColumnSpan;
keyColumnNames = new string[keySpan];
string[] keyAliases = new string[keySpan];
int k = 0;
foreach (Column col in collection.Key.ColumnCollection)
{
keyColumnNames[k] = col.GetQuotedName(dialect);
keyAliases[k] = col.GetAlias(dialect);
k++;
}
keyColumnAliases = alias.ToAliasStrings(keyAliases, dialect);
//unquotedKeyColumnNames = StringHelper.Unquote( keyColumnAliases );
ISet distinctColumns = new HashedSet();
CheckColumnDuplication(distinctColumns, collection.Key.ColumnCollection);
//isSet = collection.IsSet;
//isSorted = collection.IsSorted;
primitiveArray = collection.IsPrimitiveArray;
array = collection.IsArray;
subselectLoadable = collection.IsSubselectLoadable;
IValue element = collection.Element;
int elementSpan = element.ColumnSpan;
Table table = collection.CollectionTable;
fetchMode = element.FetchMode;
elementType = element.Type;
if (!collection.IsOneToMany)
{
CheckColumnDuplication(distinctColumns, element.ColumnCollection);
}
if (elementType.IsEntityType)
{
elementPersister = factory.GetEntityPersister(((EntityType) elementType).AssociatedClass);
}
else
{
elementPersister = null;
}
qualifiedTableName = table.GetQualifiedName(dialect, factory.DefaultSchema);
elementColumnAliases = new string[elementSpan];
elementColumnNames = new string[elementSpan];
elementFormulaTemplates = new string[elementSpan];
elementFormulas = new string[elementSpan];
elementColumnIsSettable = new bool[elementSpan];
elementColumnIsInPrimaryKey = new bool[elementSpan];
int j = 0;
foreach (ISelectable selectable in element.ColumnCollection)
{
elementColumnAliases[j] = selectable.GetAlias(dialect);
if (selectable.IsFormula)
{
Formula form = (Formula) selectable;
elementFormulaTemplates[j] = form.GetTemplate(dialect, factory.SQLFunctionRegistry);
elementFormulas[j] = form.FormulaString;
}
else
{
Column col = (Column) selectable;
elementColumnNames[j] = col.GetQuotedName(dialect);
elementColumnIsSettable[j] = true;
elementColumnIsInPrimaryKey[j] = !col.IsNullable;
}
j++;
}
hasIndex = collection.IsIndexed;
if (hasIndex)
{
IndexedCollection indexedCollection = (IndexedCollection) collection;
indexType = indexedCollection.Index.Type;
int indexSpan = indexedCollection.Index.ColumnSpan;
indexColumnNames = new string[indexSpan];
string[] indexAliases = new string[indexSpan];
int i = 0;
foreach (Column indexCol in indexedCollection.Index.ColumnCollection)
{
indexAliases[i] = indexCol.GetAlias(dialect);
indexColumnNames[i] = indexCol.GetQuotedName(dialect);
i++;
}
indexColumnAliases = alias.ToAliasStrings(indexAliases, dialect);
CheckColumnDuplication(distinctColumns, indexedCollection.Index.ColumnCollection);
}
else
{
indexType = null;
indexColumnNames = null;
indexColumnAliases = null;
}
hasIdentifier = collection.IsIdentified;
if (hasIdentifier)
{
if (collection.IsOneToMany)
{
throw new MappingException("one-to-many collections with identifiers are not supported.");
}
IdentifierCollection idColl = (IdentifierCollection) collection;
identifierType = idColl.Identifier.Type;
Column col = null;
foreach (Column column in idColl.Identifier.ColumnCollection)
{
col = column;
break;
}
identifierColumnName = col.GetQuotedName(dialect);
identifierColumnAlias = alias.ToAliasString(col.GetAlias(dialect), dialect);
identifierGenerator = idColl.Identifier.CreateIdentifierGenerator(dialect);
CheckColumnDuplication(distinctColumns, idColl.Identifier.ColumnCollection);
}
else
{
identifierType = null;
identifierColumnName = null;
identifierColumnAlias = null;
identifierGenerator = null;
}
sqlInsertRowString = GenerateInsertRowString();
if (collection.CustomSQLInsert == null)
{
insertCallable = false;
insertCheckStyle = ExecuteUpdateResultCheckStyle.Count;
}
else
{
sqlInsertRowString = new SqlCommandInfo(collection.CustomSQLInsert, sqlInsertRowString.ParameterTypes);
insertCallable = collection.IsCustomInsertCallable;
insertCheckStyle = collection.CustomSQLInsertCheckStyle == null
? ExecuteUpdateResultCheckStyle.DetermineDefault(collection.CustomSQLInsert, insertCallable)
: collection.CustomSQLInsertCheckStyle;
}
sqlUpdateRowString = GenerateUpdateRowString();
if (collection.CustomSQLUpdate == null)
{
updateCallable = false;
updateCheckStyle = ExecuteUpdateResultCheckStyle.Count;
}
else
{
sqlUpdateRowString = new SqlCommandInfo(collection.CustomSQLUpdate, sqlUpdateRowString.ParameterTypes);
updateCallable = collection.IsCustomUpdateCallable;
updateCheckStyle = collection.CustomSQLUpdateCheckStyle == null
? ExecuteUpdateResultCheckStyle.DetermineDefault(collection.CustomSQLUpdate, updateCallable)
: collection.CustomSQLUpdateCheckStyle;
}
sqlDeleteRowString = GenerateDeleteRowString();
if (collection.CustomSQLDelete == null)
{
deleteCallable = false;
deleteCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
else
{
sqlDeleteRowString = new SqlCommandInfo(collection.CustomSQLDelete, sqlDeleteRowString.ParameterTypes);
deleteCallable = collection.IsCustomDeleteCallable;
deleteCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
sqlDeleteString = GenerateDeleteString();
if (collection.CustomSQLDeleteAll == null)
{
deleteAllCallable = false;
deleteAllCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
else
{
sqlDeleteString = new SqlCommandInfo(collection.CustomSQLDeleteAll, sqlDeleteString.ParameterTypes);
deleteAllCallable = collection.IsCustomDeleteAllCallable;
deleteAllCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
isLazy = collection.IsLazy;
isInverse = collection.IsInverse;
if (collection.IsArray)
{
elementClass = ((Array) collection).ElementClass;
}
else
{
// for non-arrays, we don't need to know the element class
elementClass = null;
}
if (elementType.IsComponentType)
{
elementPropertyMapping = new CompositeElementPropertyMapping(
elementColumnNames, elementFormulaTemplates,
(IAbstractComponentType) elementType, factory);
}
else if (!elementType.IsEntityType)
{
elementPropertyMapping = new ElementPropertyMapping(elementColumnNames, elementType);
}
else
{
IEntityPersister persister = factory.GetEntityPersister(((EntityType) elementType).AssociatedClass);
// Not all classpersisters implement IPropertyMapping!
if (persister is IPropertyMapping)
{
elementPropertyMapping = (IPropertyMapping) persister;
}
else
{
elementPropertyMapping = new ElementPropertyMapping(elementColumnNames, elementType);
}
}
// Handle any filters applied to this collection
filterHelper = new FilterHelper(collection.FilterMap, dialect, factory.SQLFunctionRegistry);
// Handle any filters applied to this collection for many-to-many
manyToManyFilterHelper = new FilterHelper(collection.ManyToManyFilterMap, dialect, factory.SQLFunctionRegistry);
manyToManyWhereString = StringHelper.IsNotEmpty(collection.ManyToManyWhere) ?
"( " + collection.ManyToManyWhere + " )" :
null;
manyToManyWhereTemplate = manyToManyWhereString == null
?
null
:
Template.RenderWhereStringTemplate(manyToManyWhereString, factory.Dialect,
factory.SQLFunctionRegistry);
// , factory.getSqlFunctionRegistry() );
manyToManyOrderByString = collection.ManyToManyOrdering;
manyToManyOrderByTemplate = manyToManyOrderByString == null
? null
: Template.RenderOrderByStringTemplate(manyToManyOrderByString, factory.Dialect,
factory.SQLFunctionRegistry);
// , factory.getSqlFunctionRegistry() );
InitCollectionPropertyMap();
}
public override string ToLoggableString(object value, ISessionFactoryImplementor factory)
{
IEntityPersister persister = factory.GetEntityPersister(associatedClass);
if (value == null)
{
return "null";
}
StringBuilder result = new StringBuilder();
result.Append(StringHelper.Unqualify(NHibernateProxyHelper.GetClass(value).FullName));
if (persister.HasIdentifierProperty)
{
result.Append('#')
.Append(persister.IdentifierType.ToLoggableString(NHibernateProxyHelper.GetIdentifier(value, persister), factory));
}
return result.ToString();
}
public IEntityPersister GetSubclassEntityPersister(object instance, ISessionFactoryImplementor factory,
EntityMode entityMode)
{
if (!HasSubclasses)
{
return this;
}
else
{
// TODO : really need a way to do something like :
// getTuplizer(entityMode).determineConcreteSubclassEntityName(instance)
System.Type clazz = instance.GetType();
if (clazz == GetMappedClass(entityMode))
{
return this;
}
else
{
string subclassEntityName = GetSubclassEntityName(clazz);
if (subclassEntityName == null)
{
throw new HibernateException("instance not of expected entity type: " + clazz.FullName + " is not a: "
+ EntityName);
}
else
{
return factory.GetEntityPersister(subclassEntityName);
}
}
}
}
/// <summary> Retrieves the {@link Joinable} defining the associated entity. </summary>
/// <param name="factory">The session factory. </param>
/// <returns> The associated joinable </returns>
public IJoinable GetAssociatedJoinable(ISessionFactoryImplementor factory)
{
return (IJoinable)factory.GetEntityPersister(associatedEntityName);
}
public IEntityPersister GetSubclassEntityPersister(object instance, ISessionFactoryImplementor factory,
EntityMode entityMode)
{
if (!HasSubclasses)
{
return this;
}
// TODO : really need a way to do something like :
// getTuplizer(entityMode).determineConcreteSubclassEntityName(instance)
var clazz = instance.GetType();
if (clazz == GetMappedClass(entityMode))
{
return this;
}
var subclassEntityName = GetSubclassEntityName(clazz);
if (subclassEntityName == null || EntityName.Equals(subclassEntityName))
{
return this;
}
return factory.GetEntityPersister(subclassEntityName);
}
protected virtual IEntityPersister GetEntityPersister(ISessionFactoryImplementor factory, string entityName)
{
// Check for an exact match.
IEntityPersister persister = factory.TryGetEntityPersister(entityName);
if (persister != null)
{
return persister;
}
// Couldn't find persister through exact name, try finding a single implementing class.
string[] implementors = factory.GetImplementors(entityName);
if (implementors.Length > 1)
{
var messageBuilder = new StringBuilder(512);
messageBuilder.AppendLine(string.Format("Ambiguous persister for {0} implemented by more than one hierarchy: ",
entityName));
Array.ForEach(implementors, s=> messageBuilder.AppendLine(s));
throw new HibernateException(messageBuilder.ToString());
}
if (implementors.Length == 0)
{
return null;
}
return factory.GetEntityPersister(implementors[0]);
}
public AbstractCollectionPersister(Mapping.Collection collection, ICacheConcurrencyStrategy cache, Configuration cfg,
ISessionFactoryImplementor factory)
{
this.factory = factory;
this.cache = cache;
if (factory.Settings.IsStructuredCacheEntriesEnabled)
{
cacheEntryStructure = collection.IsMap
? (ICacheEntryStructure) new StructuredMapCacheEntry()
: (ICacheEntryStructure) new StructuredCollectionCacheEntry();
}
else
{
cacheEntryStructure = new UnstructuredCacheEntry();
}
dialect = factory.Dialect;
sqlExceptionConverter = factory.SQLExceptionConverter;
collectionType = collection.CollectionType;
role = collection.Role;
entityName = collection.OwnerEntityName;
ownerPersister = factory.GetEntityPersister(entityName);
queryLoaderName = collection.LoaderName;
nodeName = collection.NodeName;
isMutable = collection.IsMutable;
Table table = collection.CollectionTable;
fetchMode = collection.Element.FetchMode;
elementType = collection.Element.Type;
isPrimitiveArray = collection.IsPrimitiveArray;
isArray = collection.IsArray;
subselectLoadable = collection.IsSubselectLoadable;
qualifiedTableName = table.GetQualifiedName(dialect, factory.Settings.DefaultCatalogName, factory.Settings.DefaultSchemaName);
int spacesSize = 1 + collection.SynchronizedTables.Count;
spaces = new string[spacesSize];
int ispa = 0;
spaces[ispa++] = qualifiedTableName;
foreach (string s in collection.SynchronizedTables)
{
spaces[ispa++] = s;
}
sqlOrderByString = collection.OrderBy;
hasOrder = sqlOrderByString != null;
sqlOrderByStringTemplate = hasOrder
? Template.RenderOrderByStringTemplate(sqlOrderByString, dialect,
factory.SQLFunctionRegistry)
: null;
sqlWhereString = !string.IsNullOrEmpty(collection.Where) ? '(' + collection.Where + ')' : null;
hasWhere = sqlWhereString != null;
sqlWhereStringTemplate = hasWhere
? Template.RenderWhereStringTemplate(sqlWhereString, dialect, factory.SQLFunctionRegistry)
: null;
hasOrphanDelete = collection.HasOrphanDelete;
int batch = collection.BatchSize;
if (batch == -1)
{
batch = factory.Settings.DefaultBatchFetchSize;
}
batchSize = batch;
isVersioned = collection.IsOptimisticLocked;
keyType = collection.Key.Type;
int keySpan = collection.Key.ColumnSpan;
keyColumnNames = new string[keySpan];
keyColumnAliases = new string[keySpan];
int k = 0;
foreach (Column col in collection.Key.ColumnIterator)
{
keyColumnNames[k] = col.GetQuotedName(dialect);
keyColumnAliases[k] = col.GetAlias(dialect);
k++;
}
ISet distinctColumns = new HashedSet();
CheckColumnDuplication(distinctColumns, collection.Key.ColumnIterator);
#region Element
IValue element = collection.Element;
if (!collection.IsOneToMany)
{
CheckColumnDuplication(distinctColumns, element.ColumnIterator);
}
string elemNode = collection.ElementNodeName;
if (elementType.IsEntityType)
{
string _entityName = ((EntityType) elementType).GetAssociatedEntityName();
elementPersister = factory.GetEntityPersister(_entityName);
if (elemNode == null)
{
elemNode = cfg.GetClassMapping(_entityName).NodeName;
}
// NativeSQL: collect element column and auto-aliases
}
else
{
elementPersister = null;
}
elementNodeName = elemNode;
int elementSpan = element.ColumnSpan;
elementColumnAliases = new string[elementSpan];
elementColumnNames = new string[elementSpan];
elementFormulaTemplates = new string[elementSpan];
elementFormulas = new string[elementSpan];
elementColumnIsSettable = new bool[elementSpan];
elementColumnIsInPrimaryKey = new bool[elementSpan];
bool isPureFormula = true;
bool hasNotNullableColumns = false;
int j = 0;
foreach (ISelectable selectable in element.ColumnIterator)
{
elementColumnAliases[j] = selectable.GetAlias(dialect);
if (selectable.IsFormula)
{
Formula form = (Formula) selectable;
elementFormulaTemplates[j] = form.GetTemplate(dialect, factory.SQLFunctionRegistry);
elementFormulas[j] = form.FormulaString;
}
else
{
Column col = (Column) selectable;
elementColumnNames[j] = col.GetQuotedName(dialect);
elementColumnIsSettable[j] = true;
elementColumnIsInPrimaryKey[j] = !col.IsNullable;
if (!col.IsNullable)
{
hasNotNullableColumns = true;
}
isPureFormula = false;
}
j++;
}
elementIsPureFormula = isPureFormula;
//workaround, for backward compatibility of sets with no
//not-null columns, assume all columns are used in the
//row locator SQL
if (!hasNotNullableColumns)
{
ArrayHelper.Fill(elementColumnIsInPrimaryKey, true);
}
#endregion
#region INDEX AND ROW SELECT
hasIndex = collection.IsIndexed;
if (hasIndex)
{
// NativeSQL: collect index column and auto-aliases
IndexedCollection indexedCollection = (IndexedCollection) collection;
indexType = indexedCollection.Index.Type;
int indexSpan = indexedCollection.Index.ColumnSpan;
indexColumnNames = new string[indexSpan];
indexFormulaTemplates = new string[indexSpan];
indexFormulas = new string[indexSpan];
indexColumnIsSettable = new bool[indexSpan];
indexColumnAliases = new string[indexSpan];
bool hasFormula = false;
int i = 0;
foreach (ISelectable selectable in indexedCollection.Index.ColumnIterator)
{
indexColumnAliases[i] = selectable.GetAlias(dialect);
if (selectable.IsFormula)
{
Formula indexForm = (Formula) selectable;
indexFormulaTemplates[i] = indexForm.GetTemplate(dialect, factory.SQLFunctionRegistry);
indexFormulas[i] = indexForm.FormulaString;
hasFormula = true;
}
else
{
Column indexCol = (Column) selectable;
indexColumnNames[i] = indexCol.GetQuotedName(dialect);
indexColumnIsSettable[i] = true;
}
i++;
}
indexContainsFormula = hasFormula;
baseIndex = indexedCollection.IsList ? ((List) indexedCollection).BaseIndex : 0;
indexNodeName = indexedCollection.IndexNodeName;
CheckColumnDuplication(distinctColumns, indexedCollection.Index.ColumnIterator);
}
else
{
indexContainsFormula = false;
indexColumnIsSettable = null;
indexFormulaTemplates = null;
indexFormulas = null;
indexType = null;
indexColumnNames = null;
indexColumnAliases = null;
baseIndex = 0;
indexNodeName = null;
}
hasIdentifier = collection.IsIdentified;
if (hasIdentifier)
{
if (collection.IsOneToMany)
{
throw new MappingException("one-to-many collections with identifiers are not supported.");
}
IdentifierCollection idColl = (IdentifierCollection) collection;
identifierType = idColl.Identifier.Type;
Column col = null;
foreach (Column column in idColl.Identifier.ColumnIterator)
{
col = column;
break;
}
identifierColumnName = col.GetQuotedName(dialect);
identifierColumnAlias = col.GetAlias(dialect);
identifierGenerator =
idColl.Identifier.CreateIdentifierGenerator(factory.Dialect, factory.Settings.DefaultCatalogName,
factory.Settings.DefaultSchemaName, null);
// NH see : identityDelegate declaration
IPostInsertIdentifierGenerator pig = (identifierGenerator as IPostInsertIdentifierGenerator);
if (pig != null)
{
identityDelegate = pig.GetInsertGeneratedIdentifierDelegate(this, Factory, UseGetGeneratedKeys());
}
else
{
identityDelegate = null;
}
CheckColumnDuplication(distinctColumns, idColl.Identifier.ColumnIterator);
}
else
{
identifierType = null;
identifierColumnName = null;
identifierColumnAlias = null;
identifierGenerator = null;
identityDelegate = null;
}
#endregion
#region GENERATE THE SQL
// NH Different behavior : for the Insert SQL we are managing isPostInsertIdentifier (not supported in H3.2.5)
if (collection.CustomSQLInsert == null)
{
if (!IsIdentifierAssignedByInsert)
{
sqlInsertRowString = GenerateInsertRowString();
}
else
{
sqlInsertRowString = GenerateIdentityInsertRowString();
}
insertCallable = false;
insertCheckStyle = ExecuteUpdateResultCheckStyle.Count;
}
else
{
SqlType[] parmsTypes = GenerateInsertRowString().ParameterTypes;
sqlInsertRowString = new SqlCommandInfo(collection.CustomSQLInsert, parmsTypes);
insertCallable = collection.IsCustomInsertCallable;
insertCheckStyle = collection.CustomSQLInsertCheckStyle
?? ExecuteUpdateResultCheckStyle.DetermineDefault(collection.CustomSQLInsert, insertCallable);
}
sqlUpdateRowString = GenerateUpdateRowString();
if (collection.CustomSQLUpdate == null)
{
updateCallable = false;
updateCheckStyle = ExecuteUpdateResultCheckStyle.Count;
}
else
{
sqlUpdateRowString = new SqlCommandInfo(collection.CustomSQLUpdate, sqlUpdateRowString.ParameterTypes);
updateCallable = collection.IsCustomUpdateCallable;
updateCheckStyle = collection.CustomSQLUpdateCheckStyle
?? ExecuteUpdateResultCheckStyle.DetermineDefault(collection.CustomSQLUpdate, updateCallable);
}
sqlDeleteRowString = GenerateDeleteRowString();
if (collection.CustomSQLDelete == null)
{
deleteCallable = false;
deleteCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
else
{
sqlDeleteRowString = new SqlCommandInfo(collection.CustomSQLDelete, sqlDeleteRowString.ParameterTypes);
deleteCallable = collection.IsCustomDeleteCallable;
deleteCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
sqlDeleteString = GenerateDeleteString();
if (collection.CustomSQLDeleteAll == null)
{
deleteAllCallable = false;
deleteAllCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
else
{
sqlDeleteString = new SqlCommandInfo(collection.CustomSQLDeleteAll, sqlDeleteString.ParameterTypes);
deleteAllCallable = collection.IsCustomDeleteAllCallable;
deleteAllCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
isCollectionIntegerIndex = collection.IsIndexed && !collection.IsMap;
sqlDetectRowByIndexString = GenerateDetectRowByIndexString();
sqlDetectRowByElementString = GenerateDetectRowByElementString();
sqlSelectRowByIndexString = GenerateSelectRowByIndexString();
LogStaticSQL();
#endregion
isLazy = collection.IsLazy;
isExtraLazy = collection.ExtraLazy;
isInverse = collection.IsInverse;
if (collection.IsArray)
{
elementClass = ((Array) collection).ElementClass;
}
else
{
// for non-arrays, we don't need to know the element class
elementClass = null;
}
if (elementType.IsComponentType)
{
elementPropertyMapping =
new CompositeElementPropertyMapping(elementColumnNames, elementFormulaTemplates,
(IAbstractComponentType) elementType, factory);
}
else if (!elementType.IsEntityType)
{
elementPropertyMapping = new ElementPropertyMapping(elementColumnNames, elementType);
}
else
{
elementPropertyMapping = elementPersister as IPropertyMapping;
if (elementPropertyMapping == null)
{
elementPropertyMapping = new ElementPropertyMapping(elementColumnNames, elementType);
}
}
// Handle any filters applied to this collection
filterHelper = new FilterHelper(collection.FilterMap, dialect, factory.SQLFunctionRegistry);
// Handle any filters applied to this collection for many-to-many
manyToManyFilterHelper = new FilterHelper(collection.ManyToManyFilterMap, dialect, factory.SQLFunctionRegistry);
manyToManyWhereString = !string.IsNullOrEmpty(collection.ManyToManyWhere)
? "( " + collection.ManyToManyWhere + " )"
: null;
manyToManyWhereTemplate = manyToManyWhereString == null
? null
: Template.RenderWhereStringTemplate(manyToManyWhereString, factory.Dialect,
factory.SQLFunctionRegistry);
manyToManyOrderByString = collection.ManyToManyOrdering;
manyToManyOrderByTemplate = manyToManyOrderByString == null
? null
: Template.RenderOrderByStringTemplate(manyToManyOrderByString, factory.Dialect,
factory.SQLFunctionRegistry);
InitCollectionPropertyMap();
}
public CustomLoader(ICustomQuery customQuery, ISessionFactoryImplementor factory) : base(factory)
{
sql = customQuery.SQL;
querySpaces.AddAll(customQuery.QuerySpaces);
namedParameterBindPoints = customQuery.NamedParameterBindPoints;
List<IQueryable> entitypersisters = new List<IQueryable>();
List<int> entityowners = new List<int>();
List<IEntityAliases> entityaliases = new List<IEntityAliases>();
List<IQueryableCollection> collectionpersisters = new List<IQueryableCollection>();
List<int> collectionowners = new List<int>();
List<ICollectionAliases> collectionaliases = new List<ICollectionAliases>();
List<LockMode> lockmodes = new List<LockMode>();
List<IResultColumnProcessor> resultColumnProcessors = new List<IResultColumnProcessor>();
List<IReturn> nonScalarReturnList = new List<IReturn>();
List<IType> resulttypes = new List<IType>();
List<string> specifiedAliases = new List<string>();
int returnableCounter = 0;
bool hasScalars = false;
foreach (IReturn rtn in customQuery.CustomQueryReturns)
{
if (rtn is ScalarReturn)
{
ScalarReturn scalarRtn = (ScalarReturn) rtn;
resulttypes.Add(scalarRtn.Type);
specifiedAliases.Add(scalarRtn.ColumnAlias);
resultColumnProcessors.Add(new ScalarResultColumnProcessor(scalarRtn.ColumnAlias, scalarRtn.Type));
hasScalars = true;
}
else if (rtn is RootReturn)
{
RootReturn rootRtn = (RootReturn) rtn;
IQueryable persister = (IQueryable) factory.GetEntityPersister(rootRtn.EntityName);
entitypersisters.Add(persister);
lockmodes.Add(rootRtn.LockMode);
resultColumnProcessors.Add(new NonScalarResultColumnProcessor(returnableCounter++));
nonScalarReturnList.Add(rtn);
entityowners.Add(-1);
resulttypes.Add(persister.Type);
specifiedAliases.Add(rootRtn.Alias);
entityaliases.Add(rootRtn.EntityAliases);
querySpaces.AddAll(persister.QuerySpaces);
}
else if (rtn is CollectionReturn)
{
CollectionReturn collRtn = (CollectionReturn) rtn;
string role = collRtn.OwnerEntityName + "." + collRtn.OwnerProperty;
IQueryableCollection persister = (IQueryableCollection) factory.GetCollectionPersister(role);
collectionpersisters.Add(persister);
lockmodes.Add(collRtn.LockMode);
resultColumnProcessors.Add(new NonScalarResultColumnProcessor(returnableCounter++));
nonScalarReturnList.Add(rtn);
collectionowners.Add(-1);
resulttypes.Add(persister.Type);
specifiedAliases.Add(collRtn.Alias);
collectionaliases.Add(collRtn.CollectionAliases);
// determine if the collection elements are entities...
IType elementType = persister.ElementType;
if (elementType.IsEntityType)
{
IQueryable elementPersister = (IQueryable) ((EntityType) elementType).GetAssociatedJoinable(factory);
entitypersisters.Add(elementPersister);
entityowners.Add(-1);
entityaliases.Add(collRtn.ElementEntityAliases);
querySpaces.AddAll(elementPersister.QuerySpaces);
}
}
else if (rtn is EntityFetchReturn)
{
EntityFetchReturn fetchRtn = (EntityFetchReturn) rtn;
NonScalarReturn ownerDescriptor = fetchRtn.Owner;
int ownerIndex = nonScalarReturnList.IndexOf(ownerDescriptor);
entityowners.Add(ownerIndex);
lockmodes.Add(fetchRtn.LockMode);
IQueryable ownerPersister = DetermineAppropriateOwnerPersister(ownerDescriptor);
EntityType fetchedType = (EntityType) ownerPersister.GetPropertyType(fetchRtn.OwnerProperty);
string entityName = fetchedType.GetAssociatedEntityName(Factory);
IQueryable persister = (IQueryable) factory.GetEntityPersister(entityName);
entitypersisters.Add(persister);
nonScalarReturnList.Add(rtn);
specifiedAliases.Add(fetchRtn.Alias);
entityaliases.Add(fetchRtn.EntityAliases);
querySpaces.AddAll(persister.QuerySpaces);
}
else if (rtn is CollectionFetchReturn)
{
CollectionFetchReturn fetchRtn = (CollectionFetchReturn) rtn;
NonScalarReturn ownerDescriptor = fetchRtn.Owner;
int ownerIndex = nonScalarReturnList.IndexOf(ownerDescriptor);
collectionowners.Add(ownerIndex);
lockmodes.Add(fetchRtn.LockMode);
IQueryable ownerPersister = DetermineAppropriateOwnerPersister(ownerDescriptor);
string role = ownerPersister.EntityName + '.' + fetchRtn.OwnerProperty;
IQueryableCollection persister = (IQueryableCollection) factory.GetCollectionPersister(role);
collectionpersisters.Add(persister);
nonScalarReturnList.Add(rtn);
specifiedAliases.Add(fetchRtn.Alias);
collectionaliases.Add(fetchRtn.CollectionAliases);
// determine if the collection elements are entities...
IType elementType = persister.ElementType;
if (elementType.IsEntityType)
{
IQueryable elementPersister = (IQueryable) ((EntityType) elementType).GetAssociatedJoinable(factory);
entitypersisters.Add(elementPersister);
entityowners.Add(ownerIndex);
entityaliases.Add(fetchRtn.ElementEntityAliases);
querySpaces.AddAll(elementPersister.QuerySpaces);
}
}
else
{
throw new HibernateException("unexpected custom query return type : " + rtn.GetType().FullName);
}
}
entityPersisters = entitypersisters.ToArray();
entityOwners = entityowners.ToArray();
entityAliases = entityaliases.ToArray();
collectionPersisters = collectionpersisters.ToArray();
collectionOwners = collectionowners.ToArray();
collectionAliases = collectionaliases.ToArray();
lockModes = lockmodes.ToArray();
resultTypes = resulttypes.ToArray();
transformerAliases = specifiedAliases.ToArray();
rowProcessor = new ResultRowProcessor(hasScalars, resultColumnProcessors.ToArray());
}
