private object reflect(Query query, string tName)
{
if (this.customQueries == null)
{
this.customQueries = new Dictionary <string, ICustomQuery>();
var interfaceCustomQueryType = typeof(ICustomQuery);
var asm = typeof(QueryService).Assembly;
var types = asm.GetTypes();
foreach (Type t in types)
{
if (interfaceCustomQueryType.IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract)
{
ICustomQuery classInstance = (ICustomQuery)Activator.CreateInstance(t, null);
this.customQueries.Add(t.Name, classInstance);
}
}
//asm = typeof(CustomQueryById).Assembly;
//types = asm.GetTypes();
//foreach (Type t in types)
//{
// if (interfaceCustomQueryType.IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract)
// {
// ICustomQuery classInstance = (ICustomQuery)Activator.CreateInstance(t, null);
// this.customQueries.Add(t.Name, classInstance);
// }
//}
}
if (!this.customQueries.ContainsKey(tName))
{
throw new TechnicalException(new Exception("No se encuentra definido el custom query: " + tName));
}
return(this.customQueries[tName].Execute(query));;
}
private ErrorLevel GetErrorRateLevel(double?value, ICustomQuery query)
{
if (query.GetErrorLevel != null)
{
return(query.GetErrorLevel(value));
}
return(ErrorLevel.Normal);
}
public virtual IList <T> ListCustomQuery <T>(ICustomQuery customQuery, QueryParameters queryParameters)
{
using (new SessionIdLoggingContext(SessionId))
{
var results = new List <T>();
ListCustomQuery(customQuery, queryParameters, results);
return(results);
}
}
public override IList <T> ListCustomQuery <T>(ICustomQuery customQuery, QueryParameters queryParameters)
{
using (new SessionIdLoggingContext(SessionId))
{
// TODO pull up
List <T> results = new List <T>();
ListCustomQuery(customQuery, queryParameters, results);
return(results);
}
}
public virtual async Task <IList <T> > ListCustomQueryAsync <T>(ICustomQuery customQuery, QueryParameters queryParameters, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (new SessionIdLoggingContext(SessionId))
{
var results = new List <T>();
await(ListCustomQueryAsync(customQuery, queryParameters, results, cancellationToken)).ConfigureAwait(false);
return(results);
}
}
public MyQueryAdminController(
IOrchardServices orchardServices,
INotifier notifier,
IContentManager contentManager,
ICustomQuery customQuery)
{
_orchardServices = orchardServices;
_contentManager = contentManager;
_notifier = notifier;
_customQuery = customQuery;
T = NullLocalizer.Instance;
}
private ISQLQuery CreateSqlQuery(BaseQuery <T> query, ICustomQuery queryInt)
{
var nhQuery = _session.CreateSQLQuery(queryInt.Sql);
if (query.Parameters == null || !query.Parameters.Any())
{
return(nhQuery);
}
foreach (var parameter in query.Parameters)
{
nhQuery.SetParameter(parameter.Key, parameter.Value);
}
return(nhQuery);
}
public override void ListCustomQuery(ICustomQuery customQuery, QueryParameters queryParameters, IList results)
{
using (BeginProcess())
{
var loader = new CustomLoader(customQuery, Factory);
var success = false;
try
{
ArrayHelper.AddAll(results, loader.List(this, queryParameters));
success = true;
}
finally
{
AfterOperation(success);
}
temporaryPersistenceContext.Clear();
}
}
public override async Task ListCustomQueryAsync(ICustomQuery customQuery, QueryParameters queryParameters, IList results, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (BeginProcess())
{
var loader = new CustomLoader(customQuery, Factory);
var success = false;
try
{
ArrayHelper.AddAll(results, await(loader.ListAsync(this, queryParameters, cancellationToken)).ConfigureAwait(false));
success = true;
}
finally
{
await(AfterOperationAsync(success, cancellationToken)).ConfigureAwait(false);
}
temporaryPersistenceContext.Clear();
}
}
public override void ListCustomQuery(ICustomQuery customQuery, QueryParameters queryParameters, IList results)
{
using (new SessionIdLoggingContext(SessionId))
{
CheckAndUpdateSessionStatus();
CustomLoader loader = new CustomLoader(customQuery, Factory);
bool success = false;
try
{
ArrayHelper.AddAll(results, loader.List(this, queryParameters));
success = true;
}
finally
{
AfterOperation(success);
}
temporaryPersistenceContext.Clear();
}
}
public override void ListCustomQuery(ICustomQuery customQuery, QueryParameters queryParameters, IList results)
{
using (BeginProcess())
{
// We need to flush the batcher. Otherwise it may have pending operations which will not already have reached the database,
// and the query may yield stale data.
Flush();
var loader = new CustomLoader(customQuery, Factory);
var success = false;
try
{
ArrayHelper.AddAll(results, loader.List(this, queryParameters));
success = true;
}
finally
{
AfterOperation(success);
}
temporaryPersistenceContext.Clear();
}
}
public override async Task ListCustomQueryAsync(ICustomQuery customQuery, QueryParameters queryParameters, IList results, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (BeginProcess())
{
// We need to flush the batcher. Otherwise it may have pending operations which will not already have reached the database,
// and the query may yield stale data.
await(FlushAsync(cancellationToken)).ConfigureAwait(false);
var loader = new CustomLoader(customQuery, Factory);
var success = false;
try
{
ArrayHelper.AddAll(results, await(loader.ListAsync(this, queryParameters, cancellationToken)).ConfigureAwait(false));
success = true;
}
finally
{
await(AfterOperationAsync(success, cancellationToken)).ConfigureAwait(false);
}
temporaryPersistenceContext.Clear();
}
}
public IList <T> ListCustomQuery <T>(ICustomQuery customQuery, QueryParameters queryParameters)
{
return(delegat.ListCustomQuery <T>(customQuery, queryParameters));
}
public abstract Task ListCustomQueryAsync(ICustomQuery customQuery, QueryParameters queryParameters, IList results, CancellationToken cancellationToken);
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());
}
public static QueryResultSet <T> Applying <T>(this IQueryable <T> items, ICustomQuery <T> query) where T : class
{
return(query.ApplyTo(items));
}
public override IList <T> ListCustomQuery <T>(ICustomQuery customQuery, QueryParameters queryParameters);
public void ListCustomQuery(ICustomQuery customQuery, QueryParameters queryParameters, IList results)
{
delegat.ListCustomQuery(customQuery, queryParameters, results);
}
public abstract void ListCustomQuery(ICustomQuery customQuery, QueryParameters queryParameters, IList results);
public virtual QueryResultSet <T> ListWhere(ICustomQuery <T> query)
{
return(this.repository.AsUntracked()
.ListAll()
.Applying(query));
}
public override QueryResultSet <T> ListWhere(ICustomQuery <T> query)
{
return(cache.Applying(query));
}
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 IList <T> ListCustomQuery <T>(ICustomQuery customQuery, QueryParameters queryParameters)
{
return(_session.ListCustomQuery <T>(customQuery, queryParameters));
}
public override void ListCustomQuery(ICustomQuery customQuery, QueryParameters queryParameters, IList results);
public CustomLoader(ICustomQuery customQuery, ISessionFactoryImplementor factory) : base(factory)
{
this.sql = customQuery.SQL;
this.querySpaces.AddAll(customQuery.QuerySpaces);
this.parametersSpecifications = customQuery.CollectedParametersSpecifications.ToList();
var entityPersisters = new List<IEntityPersister>();
var entityOwners = new List<int>();
var entityAliases = new List<IEntityAliases>();
var collectionPersisters = new List<ICollectionPersister>();
var collectionOwners = new List<int>();
var collectionAliases = new List<ICollectionAliases>();
var lockModes = new List<LockMode>();
var resultColumnProcessors = new List<IResultColumnProcessor>();
var resultTypes = new List<IType>();
var transformerAliases = new List<string>();
int returnableCounter = 0;
bool hasScalars = false;
foreach (IReturn rtn in customQuery.CustomQueryReturns)
{
transformerAliases.Add(rtn.Alias);
if (rtn is ScalarReturn)
{
resultTypes.Add(rtn.Type);
resultColumnProcessors.Add(new ScalarResultColumnProcessor(rtn.Alias, rtn.Type));
hasScalars = true;
continue;
}
var nonScalarRtn = rtn as NonScalarReturn;
if (nonScalarRtn != null)
{
lockModes.Add(nonScalarRtn.LockMode);
var ownerIndex = nonScalarRtn.Owner != null
? entityPersisters.IndexOf(nonScalarRtn.Owner.EntityPersister)
: -1;
if (nonScalarRtn.EntityPersister != null)
{
entityPersisters.Add(nonScalarRtn.EntityPersister);
entityAliases.Add(nonScalarRtn.EntityAliases);
entityOwners.Add(ownerIndex);
querySpaces.AddAll(nonScalarRtn.EntityPersister.QuerySpaces);
}
if (nonScalarRtn.CollectionPersister != null)
{
collectionPersisters.Add(nonScalarRtn.CollectionPersister);
collectionAliases.Add(nonScalarRtn.CollectionAliases);
collectionOwners.Add(ownerIndex);
}
if (nonScalarRtn.Owner == null)
{
resultTypes.Add(nonScalarRtn.Type);
resultColumnProcessors.Add(new NonScalarResultColumnProcessor(returnableCounter++));
}
continue;
}
throw new HibernateException("unexpected custom query return type : " + rtn.GetType().FullName);
}
this.entityPersisters = entityPersisters.Cast<ILoadable>().ToArray();
this.entityOwners = entityOwners.ToArray();
this.entityAliases = entityAliases.ToArray();
this.collectionPersisters = collectionPersisters.ToArray();
this.collectionOwners = collectionOwners.ToArray();
this.collectionAliases = collectionAliases.ToArray();
this.lockModes = lockModes.ToArray();
this.resultTypes = resultTypes.ToArray();
this.transformerAliases = transformerAliases.ToArray();
this.rowProcessor = new ResultRowProcessor(hasScalars, resultColumnProcessors.ToArray());
}
public Task ListCustomQueryAsync(ICustomQuery customQuery, QueryParameters queryParameters, IList results,
CancellationToken cancellationToken)
{
return(_session.ListCustomQueryAsync(customQuery, queryParameters, results, cancellationToken));
}
public static QueryResultSet <T> Applying <T>(this ConcurrentBag <T> items, ICustomQuery <T> query) where T : class
{
return(items.AsQueryable().Applying(query));
}
public Task <IList <T> > ListCustomQueryAsync <T>(ICustomQuery customQuery, QueryParameters queryParameters,
CancellationToken cancellationToken)
{
return(_session.ListCustomQueryAsync <T>(customQuery, queryParameters, cancellationToken));
}
public void ListCustomQuery(ICustomQuery customQuery, QueryParameters queryParameters, IList results)
{
_session.ListCustomQuery(customQuery, queryParameters, results);
}
public CustomLoader(ICustomQuery customQuery, ISessionFactoryImplementor factory) : base(factory)
{
sql = customQuery.SQL;
querySpaces.UnionWith(customQuery.QuerySpaces);
parametersSpecifications = customQuery.CollectedParametersSpecifications.ToList();
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>();
List <bool> includeInResultRowList = new List <bool>();
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));
includeInResultRowList.Add(true);
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.UnionWith(persister.QuerySpaces);
includeInResultRowList.Add(true);
}
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.UnionWith(elementPersister.QuerySpaces);
}
includeInResultRowList.Add(true);
}
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.UnionWith(persister.QuerySpaces);
includeInResultRowList.Add(false);
}
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.UnionWith(elementPersister.QuerySpaces);
}
includeInResultRowList.Add(false);
}
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());
includeInResultRow = includeInResultRowList.ToArray();
}
public abstract IList <T> ListCustomQuery <T>(ICustomQuery customQuery, QueryParameters queryParameters);
