private string ResolveCollectionProperties(
string aliasName,
string propertyName,
IDictionary fieldResults,
ISqlLoadable elementPersister,
ISqlLoadableCollection currentPersister,
string suffix,
string persisterSuffix)
{
if ("*".Equals(propertyName))
{
if (fieldResults.Count > 0)
{
throw new QueryException("Using return-propertys together with * syntax is not supported.");
}
string selectFragment = currentPersister.SelectFragment(aliasName, suffix);
aliasesFound++;
return selectFragment
+ ", "
+ ResolveProperties(aliasName, propertyName, fieldResults, elementPersister, persisterSuffix);
}
else if ("element.*".Equals(propertyName))
{
return ResolveProperties(aliasName, "*", fieldResults, elementPersister, persisterSuffix);
}
else
{
string[] columnAliases;
// Let return-propertys override whatever the persister has for aliases.
columnAliases = (string[]) fieldResults[propertyName];
if (columnAliases == null)
{
columnAliases = currentPersister.GetCollectionPropertyColumnAliases(propertyName, suffix);
}
if (columnAliases == null || columnAliases.Length == 0)
{
throw new QueryException("No column name found for property [" +
propertyName +
"] for alias [" + aliasName + "]",
sqlQuery);
}
if (columnAliases.Length != 1)
{
// TODO: better error message since we actually support composites if names are explicitly listed.
throw new QueryException("SQL queries only support properties mapped to a single column - property [" +
propertyName +
"] is mapped to " +
columnAliases.Length +
" columns.",
sqlQuery);
}
aliasesFound++;
return columnAliases[0];
}
}
public ColumnCollectionAliases(IDictionary<string, string[]> userProvidedAliases, ISqlLoadableCollection persister)
{
this.userProvidedAliases = userProvidedAliases;
keyAliases = GetUserProvidedAliases("key", persister.KeyColumnNames);
indexAliases = GetUserProvidedAliases("index", persister.IndexColumnNames);
elementAliases = GetUserProvidedAliases("element", persister.ElementColumnNames);
identifierAlias = GetUserProvidedAlias("id", persister.IdentifierColumnName);
}
public ColumnCollectionAliases(IDictionary<string, string[]> userProvidedAliases, ISqlLoadableCollection persister)
{
this.userProvidedAliases = userProvidedAliases;
this.keyAliases = GetUserProvidedAliases("key", persister.KeyColumnNames);
this.indexAliases = GetUserProvidedAliases("index", persister.IndexColumnNames);
// NH-1612: Add aliases for all composite element properties to support access
// to individual composite element properties in <return-property> elements.
this.elementAliases = persister.ElementType.IsComponentType
? GetUserProvidedCompositeElementAliases(persister.ElementColumnNames)
: GetUserProvidedAliases("element", persister.ElementColumnNames);
this.identifierAlias = GetUserProvidedAlias("id", persister.IdentifierColumnName);
}
private void AddCollection(string role, string alias, IDictionary <string, string[]> propertyResults)
{
ISqlLoadableCollection collectionPersister = (ISqlLoadableCollection)Factory.GetCollectionPersister(role);
alias2CollectionPersister[alias] = collectionPersister;
string suffix = GenerateCollectionSuffix();
log.Debug("mapping alias [{0}] to collection-suffix [{1}]", alias, suffix);
alias2CollectionSuffix[alias] = suffix;
collectionPropertyResultMaps[alias] = propertyResults;
if (collectionPersister.IsOneToMany)
{
ISqlLoadable persister = (ISqlLoadable)collectionPersister.ElementPersister;
AddPersister(alias, Filter(propertyResults), persister);
}
}
public NonScalarReturn(SQLQueryContext context, bool queryHasAliases, string alias, LockMode lockMode, NonScalarReturn owner)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (string.IsNullOrEmpty(alias))
{
throw new HibernateException("alias must be specified");
}
this.alias = alias;
this.lockMode = lockMode;
this.owner = owner;
this.collectionPersister = context.GetCollectionPersister(alias);
if (this.collectionPersister != null)
{
var collectionPropertyResultMap = context.GetCollectionPropertyResultsMap(alias);
this.collectionAliases = queryHasAliases
? new GeneratedCollectionAliases(collectionPropertyResultMap, this.collectionPersister, context.GetCollectionSuffix(alias))
: (ICollectionAliases)new ColumnCollectionAliases(collectionPropertyResultMap, this.collectionPersister);
}
if (this.collectionPersister == null || this.CollectionPersister.ElementType.IsEntityType)
{
this.entityPersister = context.GetEntityPersister(alias);
if (this.entityPersister != null)
{
var entityPropertyResultMap = context.GetEntityPropertyResultsMap(alias);
this.entityAliases = queryHasAliases
? new DefaultEntityAliases(entityPropertyResultMap, this.entityPersister, context.GetEntitySuffix(alias))
: new ColumnEntityAliases(entityPropertyResultMap, this.entityPersister);
}
}
}
public IList GenerateCustomReturns(bool queryHadAliases)
{
IList customReturns = new List <object>();
IDictionary <string, object> customReturnsByAlias = new Dictionary <string, object>();
for (int i = 0; i < queryReturns.Length; i++)
{
if (queryReturns[i] is NativeSQLQueryScalarReturn)
{
NativeSQLQueryScalarReturn rtn = (NativeSQLQueryScalarReturn)queryReturns[i];
customReturns.Add(new ScalarReturn(rtn.Type, rtn.ColumnAlias));
}
else if (queryReturns[i] is NativeSQLQueryRootReturn)
{
NativeSQLQueryRootReturn rtn = (NativeSQLQueryRootReturn)queryReturns[i];
string alias = rtn.Alias;
IEntityAliases entityAliases;
if (queryHadAliases || HasPropertyResultMap(alias))
{
entityAliases =
new DefaultEntityAliases(entityPropertyResultMaps[alias], alias2Persister[alias], alias2Suffix[alias]);
}
else
{
entityAliases =
new ColumnEntityAliases(entityPropertyResultMaps[alias], alias2Persister[alias], alias2Suffix[alias]);
}
RootReturn customReturn = new RootReturn(alias, rtn.ReturnEntityName, entityAliases, rtn.LockMode);
customReturns.Add(customReturn);
customReturnsByAlias[rtn.Alias] = customReturn;
}
else if (queryReturns[i] is NativeSQLQueryCollectionReturn)
{
NativeSQLQueryCollectionReturn rtn = (NativeSQLQueryCollectionReturn)queryReturns[i];
string alias = rtn.Alias;
ISqlLoadableCollection persister = alias2CollectionPersister[alias];
bool isEntityElements = persister.ElementType.IsEntityType;
ICollectionAliases collectionAliases;
IEntityAliases elementEntityAliases = null;
if (queryHadAliases || HasPropertyResultMap(alias))
{
collectionAliases =
new GeneratedCollectionAliases(collectionPropertyResultMaps[alias], alias2CollectionPersister[alias],
alias2CollectionSuffix[alias]);
if (isEntityElements)
{
elementEntityAliases =
new DefaultEntityAliases(entityPropertyResultMaps[alias], alias2Persister[alias], alias2Suffix[alias]);
}
}
else
{
collectionAliases =
new ColumnCollectionAliases(collectionPropertyResultMaps[alias], alias2CollectionPersister[alias]);
if (isEntityElements)
{
elementEntityAliases =
new ColumnEntityAliases(entityPropertyResultMaps[alias], alias2Persister[alias], alias2Suffix[alias]);
}
}
CollectionReturn customReturn =
new CollectionReturn(alias, rtn.OwnerEntityName, rtn.OwnerProperty, collectionAliases, elementEntityAliases,
rtn.LockMode);
customReturns.Add(customReturn);
customReturnsByAlias[rtn.Alias] = customReturn;
}
else if (queryReturns[i] is NativeSQLQueryJoinReturn)
{
NativeSQLQueryJoinReturn rtn = (NativeSQLQueryJoinReturn)queryReturns[i];
string alias = rtn.Alias;
FetchReturn customReturn;
NonScalarReturn ownerCustomReturn = (NonScalarReturn)customReturnsByAlias[rtn.OwnerAlias];
ISqlLoadableCollection persister;
if (alias2CollectionPersister.TryGetValue(alias, out persister))
{
bool isEntityElements = persister.ElementType.IsEntityType;
ICollectionAliases collectionAliases;
IEntityAliases elementEntityAliases = null;
if (queryHadAliases || HasPropertyResultMap(alias))
{
collectionAliases =
new GeneratedCollectionAliases(collectionPropertyResultMaps[alias], persister, alias2CollectionSuffix[alias]);
if (isEntityElements)
{
elementEntityAliases =
new DefaultEntityAliases(entityPropertyResultMaps[alias], alias2Persister[alias], alias2Suffix[alias]);
}
}
else
{
collectionAliases = new ColumnCollectionAliases(collectionPropertyResultMaps[alias], persister);
if (isEntityElements)
{
elementEntityAliases =
new ColumnEntityAliases(entityPropertyResultMaps[alias], alias2Persister[alias], alias2Suffix[alias]);
}
}
customReturn =
new CollectionFetchReturn(alias, ownerCustomReturn, rtn.OwnerProperty, collectionAliases, elementEntityAliases,
rtn.LockMode);
}
else
{
IEntityAliases entityAliases;
if (queryHadAliases || HasPropertyResultMap(alias))
{
entityAliases =
new DefaultEntityAliases(entityPropertyResultMaps[alias], alias2Persister[alias], alias2Suffix[alias]);
}
else
{
entityAliases =
new ColumnEntityAliases(entityPropertyResultMaps[alias], alias2Persister[alias], alias2Suffix[alias]);
}
customReturn = new EntityFetchReturn(alias, entityAliases, ownerCustomReturn, rtn.OwnerProperty, rtn.LockMode);
}
customReturns.Add(customReturn);
customReturnsByAlias[alias] = customReturn;
}
}
return(customReturns);
}
private string ResolveCollectionProperties(string aliasName, string propertyName)
{
IDictionary <string, string[]> fieldResults = context.GetPropertyResultsMapByAlias(aliasName);
ISqlLoadableCollection collectionPersister = context.GetCollectionPersisterByAlias(aliasName);
string collectionSuffix = context.GetCollectionSuffixByAlias(aliasName);
// NH Different behavior for NH-1612
if ("*".Equals(propertyName))
{
if (fieldResults.Count != 0)
{
throw new QueryException("Using return-propertys together with * syntax is not supported.");
}
string selectFragment = collectionPersister.SelectFragment(aliasName, collectionSuffix);
aliasesFound++;
// Collection may just contain elements and no entities, in which case resolution of
// collection properties is enough.
return(collectionPersister.ElementType.IsEntityType
? selectFragment + ", " + ResolveProperties(aliasName, "*")
: selectFragment);
}
if (propertyName.StartsWith("element."))
{
string elementPropertyName = propertyName.Substring("element.".Length);
if (collectionPersister.ElementType.IsEntityType)
{
return(ResolveProperties(aliasName, elementPropertyName));
}
else if (elementPropertyName == "*")
{
throw new QueryException("Using element.* syntax is only supported for entity elements.");
}
}
string[] columnAliases;
// Let return-propertys override whatever the persister has for aliases.
if (!fieldResults.TryGetValue(propertyName, out columnAliases))
{
columnAliases = collectionPersister.GetCollectionPropertyColumnAliases(propertyName, collectionSuffix);
}
if (columnAliases == null || columnAliases.Length == 0)
{
throw new QueryException("No column name found for property [" + propertyName + "] for alias [" + aliasName + "]",
originalQueryString);
}
if (columnAliases.Length != 1)
{
// TODO: better error message since we actually support composites if names are explicitly listed.
throw new QueryException(
"SQL queries only support properties mapped to a single column - property [" + propertyName + "] is mapped to "
+ columnAliases.Length + " columns.", originalQueryString);
}
aliasesFound++;
return(columnAliases[0]);
}
public ColumnCollectionAliases(IDictionary <string, string[]> userProvidedAliases, ISqlLoadableCollection persister)
{
this.userProvidedAliases = userProvidedAliases;
keyAliases = GetUserProvidedAliases("key", persister.KeyColumnNames);
indexAliases = GetUserProvidedAliases("index", persister.IndexColumnNames);
elementAliases = GetUserProvidedAliases("element", persister.ElementColumnNames);
identifierAlias = GetUserProvidedAlias("id", persister.IdentifierColumnName);
}
public ColumnCollectionAliases(IDictionary <string, string[]> userProvidedAliases, ISqlLoadableCollection persister)
{
keyAliases = GetUserProvidedAliases(userProvidedAliases, CollectionPersister.PropKey, persister.KeyColumnNames);
indexAliases = GetUserProvidedAliases(userProvidedAliases, CollectionPersister.PropIndex, persister.IndexColumnNames);
elementAliases = GetUserProvidedAliases(userProvidedAliases, CollectionPersister.PropElement, persister.ElementColumnNames);
identifierAlias = GetUserProvidedAlias(userProvidedAliases, CollectionPersister.PropId, persister.IdentifierColumnName);
}
