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() }));
}
public OneToManyLoader(
IQueryableCollection oneToManyPersister,
ISessionFactoryImplementor session,
IDictionary enabledFilters)
: this(oneToManyPersister, 1, session, enabledFilters)
{
}
public override void PrepareForDot(string propertyName)
{
FromElement fromElement = FromElement;
if (fromElement == null)
{
throw new InvalidOperationException("No FROM element for index operator!");
}
IQueryableCollection queryableCollection = fromElement.QueryableCollection;
if (queryableCollection != null && !queryableCollection.IsOneToMany)
{
FromReferenceNode collectionNode = ( FromReferenceNode )GetChild(0);
String path = collectionNode.Path + "[]." + propertyName;
if (Log.IsDebugEnabled)
{
Log.Debug("Creating join for many-to-many elements for " + path);
}
FromElementFactory factory = new FromElementFactory(fromElement.FromClause, fromElement, path);
// This will add the new from element to the origin.
FromElement elementJoin = factory.CreateElementJoin(queryableCollection);
FromElement = elementJoin;
}
}
public BasicCollectionJoinWalker(
IQueryableCollection collectionPersister,
int batchSize,
SqlString subquery,
ISessionFactoryImplementor factory,
IDictionary enabledFilters)
: base(factory, enabledFilters)
{
this.collectionPersister = collectionPersister;
string alias = GenerateRootAlias(collectionPersister.Role);
WalkCollectionTree(collectionPersister, alias);
IList allAssociations = new ArrayList();
ArrayHelper.AddAll(allAssociations, associations);
allAssociations.Add(new OuterJoinableAssociation(
collectionPersister.CollectionType,
null,
null,
alias,
JoinType.LeftOuterJoin,
Factory,
enabledFilters
));
InitPersisters(allAssociations, LockMode.None);
InitStatementString(alias, batchSize, subquery);
}
public SubselectOneToManyLoader(IQueryableCollection persister, SqlString subquery, ICollection<EntityKey> entityKeys,
QueryParameters queryParameters,
ISessionFactoryImplementor factory, IDictionary<string, IFilter> enabledFilters)
: base(persister, BatchSizeForSubselectFetching, factory, enabledFilters)
{
keys = new object[entityKeys.Count];
int i = 0;
foreach (EntityKey entityKey in entityKeys)
{
keys[i++] = entityKey.Identifier;
}
// NH Different behavior: to deal with positionslParameter+NamedParameter+ParameterOfFilters
namedParameters = new Dictionary<string, TypedValue>(queryParameters.NamedParameters);
parametersSpecifications = queryParameters.ProcessedSqlParameters.ToList();
var processedRowSelection = queryParameters.ProcessedRowSelection;
SqlString finalSubquery = subquery;
if (queryParameters.ProcessedRowSelection != null && !SubselectClauseExtractor.HasOrderBy(queryParameters.ProcessedSql))
{
// when the original query has an "ORDER BY" we can't re-apply the pagination.
// This is a simplification, we should actually check which is the "ORDER BY" clause because when the "ORDER BY" is just for the PK we can re-apply "ORDER BY" and pagination.
finalSubquery = GetSubSelectWithLimits(subquery, parametersSpecifications, processedRowSelection, namedParameters);
}
InitializeFromWalker(persister, finalSubquery, BatchSizeForSubselectFetching, enabledFilters, factory);
types = queryParameters.PositionalParameterTypes;
values = queryParameters.PositionalParameterValues;
}
private void InitStatementString( IQueryableCollection persister, string alias, IList associations, int batchSize, ISessionFactoryImplementor factory )
{
Suffixes = GenerateSuffixes( associations.Count );
SqlStringBuilder whereString = WhereString( factory, alias, persister.KeyColumnNames, persister.KeyType, batchSize );
if( persister.HasWhere )
{
whereString
.Add( " and " )
.Add( persister.GetSQLWhereString( alias ) );
}
JoinFragment ojf = MergeOuterJoins( associations );
SqlSelectBuilder select = new SqlSelectBuilder( factory )
.SetSelectClause(
persister.SelectFragment( alias ).Append(
SelectString( associations, factory ) ).ToString()
)
.SetFromClause( persister.TableName, alias )
.SetWhereClause( whereString.ToSqlString() )
.SetOuterJoins(
ojf.ToFromFragmentString,
ojf.ToWhereFragmentString
);
if( persister.HasOrdering )
{
select.SetOrderByClause( persister.GetSQLOrderByString( alias ) );
}
SqlString = select.ToSqlString();
}
private static void AddImpliedFromToFromNode(IASTNode fromClause, string collectionRole, ISessionFactoryImplementor factory)
{
SessionFactoryHelperExtensions _sessionFactoryHelper = new SessionFactoryHelperExtensions(factory);
IQueryableCollection persister = _sessionFactoryHelper.GetCollectionPersister(collectionRole);
IType collectionElementType = persister.ElementType;
if (!collectionElementType.IsEntityType)
{
throw new QueryException("collection of values in filter: this");
}
string collectionElementEntityName = persister.ElementPersister.EntityName;
ITreeAdaptor adaptor = new ASTTreeAdaptor();
IASTNode fromElement = (IASTNode)adaptor.Create(HqlParser.FILTER_ENTITY, collectionElementEntityName);
IASTNode alias = (IASTNode)adaptor.Create(HqlParser.ALIAS, "this");
fromClause.AddChild(fromElement);
fromClause.AddChild(alias);
// Show the modified AST.
if (log.IsDebugEnabled())
{
log.Debug("AddImpliedFormToFromNode() : Filter - Added 'this' as a from element...");
}
}
/// <summary>
/// Add on association (one-to-one, many-to-one, or a collection) to a list
/// of associations to be fetched by outerjoin
/// </summary>
private void AddAssociationToJoinTree(IAssociationType type, string[] aliasedLhsColumns, string alias,
string path, int currentDepth, JoinType joinType)
{
IJoinable joinable = type.GetAssociatedJoinable(Factory);
string subalias = GenerateTableAlias(associations.Count + 1, path, joinable);
OuterJoinableAssociation assoc =
new OuterJoinableAssociation(type, alias, aliasedLhsColumns, subalias, joinType, GetWithClause(path), Factory, enabledFilters);
assoc.ValidateJoin(path);
AddAssociation(subalias, assoc);
int nextDepth = currentDepth + 1;
if (!joinable.IsCollection)
{
IOuterJoinLoadable pjl = joinable as IOuterJoinLoadable;
if (pjl != null)
{
WalkEntityTree(pjl, subalias, path, nextDepth);
}
}
else
{
IQueryableCollection qc = joinable as IQueryableCollection;
if (qc != null)
{
WalkCollectionTree(qc, subalias, path, nextDepth);
}
}
}
public BasicCollectionLoader(
IQueryableCollection collectionPersister,
ISessionFactoryImplementor session,
IDictionary<string, IFilter> enabledFilters)
: this(collectionPersister, 1, session, enabledFilters)
{
}
public SubselectOneToManyLoader(IQueryableCollection persister, SqlString subquery, ICollection <EntityKey> entityKeys,
QueryParameters queryParameters,
ISessionFactoryImplementor factory, IDictionary <string, IFilter> enabledFilters)
: base(persister, BatchSizeForSubselectFetching, factory, enabledFilters)
{
keys = new object[entityKeys.Count];
int i = 0;
foreach (EntityKey entityKey in entityKeys)
{
keys[i++] = entityKey.Identifier;
}
// NH Different behavior: to deal with positionslParameter+NamedParameter+ParameterOfFilters
namedParameters = new Dictionary <string, TypedValue>(queryParameters.NamedParameters);
parametersSpecifications = queryParameters.ProcessedSqlParameters.ToList();
var processedRowSelection = queryParameters.ProcessedRowSelection;
SqlString finalSubquery = subquery;
if (queryParameters.ProcessedRowSelection != null && !SubselectClauseExtractor.HasOrderBy(queryParameters.ProcessedSql))
{
// when the original query has an "ORDER BY" we can't re-apply the pagination.
// This is a simplification, we should actually check which is the "ORDER BY" clause because when the "ORDER BY" is just for the PK we can re-apply "ORDER BY" and pagination.
finalSubquery = GetSubSelectWithLimits(subquery, parametersSpecifications, processedRowSelection, namedParameters);
}
InitializeFromWalker(persister, finalSubquery, BatchSizeForSubselectFetching, enabledFilters, factory);
types = queryParameters.PositionalParameterTypes;
values = queryParameters.PositionalParameterValues;
}
private void InitStatementString(IQueryableCollection persister, string alias, IList associations, int batchSize, ISessionFactoryImplementor factory)
{
Suffixes = GenerateSuffixes(associations.Count);
SqlStringBuilder whereString = WhereString(factory, alias, persister.KeyColumnNames, persister.KeyType, batchSize);
if (persister.HasWhere)
{
whereString
.Add(" and ")
.Add(persister.GetSQLWhereString(alias));
}
JoinFragment ojf = MergeOuterJoins(associations);
SqlSelectBuilder select = new SqlSelectBuilder(factory)
.SetSelectClause(
persister.SelectFragment(alias).Append(
SelectString(associations, factory)).ToString()
)
.SetFromClause(persister.TableName, alias)
.SetWhereClause(whereString.ToSqlString())
.SetOuterJoins(
ojf.ToFromFragmentString,
ojf.ToWhereFragmentString
);
if (persister.HasOrdering)
{
select.SetOrderByClause(persister.GetSQLOrderByString(alias));
}
SqlString = select.ToSqlString();
}
protected void InitPersisters(IList <OuterJoinableAssociation> associations, LockMode lockMode)
{
int joins = CountEntityPersisters(associations);
int collections = CountCollectionPersisters(associations);
collectionOwners = collections == 0 ? null : new int[collections];
collectionPersisters = collections == 0 ? null : new ICollectionPersister[collections];
collectionSuffixes = BasicLoader.GenerateSuffixes(joins + 1, collections);
persisters = new ILoadable[joins];
aliases = new String[joins];
owners = new int[joins];
ownerAssociationTypes = new EntityType[joins];
lockModeArray = ArrayHelper.Fill(lockMode, joins);
int i = 0;
int j = 0;
foreach (OuterJoinableAssociation oj in associations)
{
if (!oj.IsCollection)
{
persisters[i] = (ILoadable)oj.Joinable;
aliases[i] = oj.RHSAlias;
owners[i] = oj.GetOwner(associations);
ownerAssociationTypes[i] = (EntityType)oj.JoinableType;
i++;
}
else
{
IQueryableCollection collPersister = (IQueryableCollection)oj.Joinable;
if (oj.JoinType == JoinType.LeftOuterJoin)
{
//it must be a collection fetch
collectionPersisters[j] = collPersister;
collectionOwners[j] = oj.GetOwner(associations);
j++;
}
if (collPersister.IsOneToMany)
{
persisters[i] = (ILoadable)collPersister.ElementPersister;
aliases[i] = oj.RHSAlias;
i++;
}
}
}
if (ArrayHelper.IsAllNegative(owners))
{
owners = null;
}
if (collectionOwners != null && ArrayHelper.IsAllNegative(collectionOwners))
{
collectionOwners = null;
}
}
public BasicCollectionLoader(
IQueryableCollection collectionPersister,
int batchSize,
ISessionFactoryImplementor factory,
IDictionary<string, IFilter> enabledFilters)
: this(collectionPersister, batchSize, null, factory, enabledFilters)
{
}
public FromElement CreateCollectionElementsJoin(IQueryableCollection queryableCollection,
String collectionName)
{
JoinSequence collectionJoinSequence = _fromClause.SessionFactoryHelper.CreateCollectionJoinSequence(queryableCollection, collectionName);
_queryableCollection = queryableCollection;
return(CreateCollectionJoin(collectionJoinSequence, null));
}
public OneToManyLoader(
IQueryableCollection oneToManyPersister,
int batchSize,
ISessionFactoryImplementor factory,
IDictionary enabledFilters)
: this(oneToManyPersister, batchSize, null, factory, enabledFilters)
{
}
/// <summary>
/// For a composite element, add to a list of associations to be fetched by outerjoin
/// </summary>
private void WalkCompositeElementTree(IAbstractComponentType compositeType, string[] cols,
IQueryableCollection persister, string alias, string path, string subPathAlias, int currentDepth)
{
IType[] types = compositeType.Subtypes;
string[] propertyNames = compositeType.PropertyNames;
int begin = 0;
for (int i = 0; i < types.Length; i++)
{
int length = types[i].GetColumnSpan(factory);
string[] lhsColumns = ArrayHelper.Slice(cols, begin, length);
if (types[i].IsAssociationType)
{
IAssociationType associationType = types[i] as IAssociationType;
// simple, because we can't have a one-to-one or collection
// (or even a property-ref) in a composite element:
string[] aliasedLhsColumns = StringHelper.Qualify(alias, lhsColumns);
string subpath = SubPath(path, propertyNames[i]);
bool[] propertyNullability = compositeType.PropertyNullability;
var joinType =
GetJoinType(
associationType,
compositeType.GetFetchMode(i),
subpath,
alias,
persister.TableName,
lhsColumns,
propertyNullability == null || propertyNullability[i],
currentDepth,
compositeType.GetCascadeStyle(i));
AddAssociationToJoinTreeIfNecessary(
associationType,
aliasedLhsColumns,
alias,
subpath,
subPathAlias,
currentDepth,
joinType);
}
else if (types[i].IsComponentType)
{
string subpath = SubPath(path, propertyNames[i]);
WalkCompositeElementTree(
(IAbstractComponentType)types[i],
lhsColumns,
persister,
alias,
subpath,
subPathAlias,
currentDepth);
}
begin += length;
}
}
/// <summary>
/// For a collection role, return a list of associations to be fetched by outerjoin
/// </summary>
private void WalkCollectionTree(IQueryableCollection persister, string alias, string path, string subPathAlias, int currentDepth)
{
if (persister.IsOneToMany)
{
WalkEntityTree((IOuterJoinLoadable)persister.ElementPersister, alias, path, currentDepth);
}
else
{
IType type = persister.ElementType;
if (type.IsAssociationType)
{
// a many-to-many
// decrement currentDepth here to allow join across the association table
// without exceeding MAX_FETCH_DEPTH (i.e. the "currentDepth - 1" bit)
IAssociationType associationType = (IAssociationType)type;
string[] aliasedLhsColumns = persister.GetElementColumnNames(alias);
string[] lhsColumns = persister.ElementColumnNames;
// if the current depth is 0, the root thing being loaded is the
// many-to-many collection itself. Here, it is alright to use
// an inner join...
bool useInnerJoin = currentDepth == 0;
var joinType =
GetJoinType(
associationType,
persister.FetchMode,
path,
subPathAlias,
persister.TableName,
lhsColumns,
!useInnerJoin,
currentDepth - 1,
null);
AddAssociationToJoinTreeIfNecessary(
associationType,
aliasedLhsColumns,
alias,
path,
subPathAlias,
currentDepth - 1,
joinType);
}
else if (type.IsComponentType)
{
WalkCompositeElementTree(
(IAbstractComponentType)type,
persister.ElementColumnNames,
persister,
alias,
path,
subPathAlias,
currentDepth);
}
}
}
private bool IsManyToManyRoot(IJoinable joinable)
{
if (joinable != null && joinable.IsCollection)
{
IQueryableCollection persister = (IQueryableCollection)joinable;
return(persister.IsManyToMany);
}
return(false);
}
protected virtual void InitializeFromWalker(IQueryableCollection oneToManyPersister, SqlString subquery, int batchSize, IDictionary<string, IFilter> enabledFilters, ISessionFactoryImplementor factory)
{
JoinWalker walker = new OneToManyJoinWalker(oneToManyPersister, batchSize, subquery, factory, enabledFilters);
InitFromWalker(walker);
PostInstantiate();
log.Debug("Static select for one-to-many " + oneToManyPersister.Role + ": " + SqlString);
}
protected void InitClassPersisters(IList associations)
{
int joins = CountClassPersisters(associations);
collectionOwner = -1; // if no collection found
classPersisters = new ILoadable[joins + 1];
Owners = new int[joins + 1];
aliases = new string[joins + 1];
lockModeArray = CreateLockModeArray(joins + 1, LockMode.None);
int i = 0;
foreach (OuterJoinableAssociation oj in associations)
{
object subpersister = oj.Joinable;
if (subpersister is ILoadable)
{
classPersisters[i] = ( ILoadable )subpersister;
Owners[i] = ToOwner(oj, joins, oj.IsOneToOne);
aliases[i] = oj.Subalias;
if (oj.JoinType == JoinType.InnerJoin)
{
AddAllToPropertySpaces(classPersisters[i].PropertySpaces);
}
i++;
}
else
{
IQueryableCollection collPersister = ( IQueryableCollection )subpersister;
// TODO: ?? suppress initialization of collections with a where condition
if (oj.JoinType == JoinType.LeftOuterJoin)
{
collectionPersister = collPersister;
collectionOwner = ToOwner(oj, joins, true);
}
else
{
AddToPropertySpaces(collPersister.CollectionSpace);
}
if (collPersister.IsOneToMany)
{
classPersisters[i] = ( ILoadable )collPersister.ElementPersister;
aliases[i] = oj.Subalias;
i++;
}
}
}
classPersisters[joins] = persister;
Owners[joins] = -1;
aliases[joins] = alias;
if (ArrayHelper.IsAllNegative(Owners))
{
Owners = null;
}
}
protected virtual void InitializeFromWalker(IQueryableCollection oneToManyPersister, SqlString subquery, int batchSize, IDictionary <string, IFilter> enabledFilters, ISessionFactoryImplementor factory)
{
JoinWalker walker = new OneToManyJoinWalker(oneToManyPersister, batchSize, subquery, factory, enabledFilters);
InitFromWalker(walker);
PostInstantiate();
log.Debug("Static select for one-to-many {0}: {1}", oneToManyPersister.Role, SqlString);
}
protected virtual void InitializeFromWalker(IQueryableCollection collectionPersister, SqlString subquery, int batchSize, IDictionary <string, IFilter> enabledFilters, ISessionFactoryImplementor factory)
{
JoinWalker walker = new BasicCollectionJoinWalker(collectionPersister, batchSize, subquery, factory, enabledFilters);
InitFromWalker(walker);
PostInstantiate();
log.Debug("Static select for collection " + collectionPersister.Role + ": " + SqlString);
}
public FromElement CreateElementJoin(IQueryableCollection queryableCollection)
{
_implied = true; //TODO: always true for now, but not if we later decide to support elements() in the from clause
_inElementsFunction = true;
IType elementType = queryableCollection.ElementType;
if (!elementType.IsEntityType)
{
throw new InvalidOperationException("Cannot create element join for a collection of non-entities!");
}
_queryableCollection = queryableCollection;
SessionFactoryHelperExtensions sfh = _fromClause.SessionFactoryHelper;
IEntityPersister entityPersister = queryableCollection.ElementPersister;
string tableAlias = _fromClause.AliasGenerator.CreateName(entityPersister.EntityName);
string associatedEntityName = entityPersister.EntityName;
IEntityPersister targetEntityPersister = sfh.RequireClassPersister(associatedEntityName);
// Create the FROM element for the target (the elements of the collection).
FromElement destination = CreateAndAddFromElement(
associatedEntityName,
_classAlias,
targetEntityPersister,
(EntityType)queryableCollection.ElementType,
tableAlias
);
// If the join is implied, then don't include sub-classes on the element.
if (_implied)
{
destination.IncludeSubclasses = false;
}
_fromClause.AddCollectionJoinFromElementByPath(_path, destination);
// origin.addDestination(destination);
// Add the query spaces.
_fromClause.Walker.AddQuerySpaces(entityPersister.QuerySpaces);
CollectionType type = queryableCollection.CollectionType;
string role = type.Role;
string roleAlias = _origin.TableAlias;
string[] targetColumns = sfh.GetCollectionElementColumns(role, roleAlias);
IAssociationType elementAssociationType = sfh.GetElementAssociationType(type);
// Create the join element under the from element.
JoinSequence joinSequence = sfh.CreateJoinSequence(_implied, elementAssociationType, tableAlias, JoinType.InnerJoin, targetColumns);
FromElement elem = InitializeJoin(_path, destination, joinSequence, targetColumns, _origin, false);
elem.UseFromFragment = true; // The associated entity is implied, but it must be included in the FROM.
elem.CollectionTableAlias = roleAlias; // The collection alias is the role.
return(elem);
}
protected BasicCollectionLoader(IQueryableCollection collectionPersister, int batchSize, SqlString subquery,
ISessionFactoryImplementor factory, IDictionary<string, IFilter> enabledFilters)
: base(collectionPersister, factory, enabledFilters)
{
JoinWalker walker = new BasicCollectionJoinWalker(collectionPersister, batchSize, subquery, factory, enabledFilters);
InitFromWalker(walker);
PostInstantiate();
log.Debug("Static select for collection " + collectionPersister.Role + ": " + SqlString);
}
public void AddManyToManyJoin(JoinFragment outerjoin, IQueryableCollection collection)
{
string manyToManyFilter = collection.GetManyToManyFilterFragment(rhsAlias, enabledFilters);
string condition = string.Empty.Equals(manyToManyFilter)
? on
: string.Empty.Equals(on) ? manyToManyFilter : on + " and " + manyToManyFilter;
outerjoin.AddJoin(joinable.TableName, rhsAlias, lhsColumns, rhsColumns, joinType, condition);
outerjoin.AddJoins(joinable.FromJoinFragment(rhsAlias, false, true),
joinable.WhereJoinFragment(rhsAlias, false, true));
}
public bool IsManyToManyWith(OuterJoinableAssociation other)
{
if (joinable.IsCollection)
{
IQueryableCollection persister = (IQueryableCollection)joinable;
if (persister.IsManyToMany)
{
return(persister.ElementType == other.JoinableType);
}
}
return(false);
}
public OneToManyLoader(IQueryableCollection oneToManyPersister, int batchSize, SqlString subquery,
ISessionFactoryImplementor factory, IDictionary <string, IFilter> enabledFilters)
: base(oneToManyPersister, factory, enabledFilters)
{
JoinWalker walker = new OneToManyJoinWalker(oneToManyPersister, batchSize, subquery, factory, enabledFilters);
InitFromWalker(walker);
PostInstantiate();
log.Debug("Static select for one-to-many " + oneToManyPersister.Role + ": " + SqlString);
}
public void AddManyToManyJoin(JoinFragment outerjoin, IQueryableCollection collection)
{
string manyToManyFilter = collection.GetManyToManyFilterFragment(rhsAlias, enabledFilters);
SqlString condition = string.Empty.Equals(manyToManyFilter)
? on
: SqlStringHelper.IsEmpty(on) ? new SqlString(manyToManyFilter) :
on.Append(" and ").Append(manyToManyFilter);
outerjoin.AddJoin(joinable.TableName, rhsAlias, lhsColumns, rhsColumns, joinType, condition);
outerjoin.AddJoins(joinable.FromJoinFragment(rhsAlias, false, true),
joinable.WhereJoinFragment(rhsAlias, false, true));
}
/// <summary>
/// Create a join sequence rooted at the given collection.
/// </summary>
/// <param name="collPersister">The persister for the collection at which the join should be rooted.</param>
/// <param name="collectionName">The alias to use for qualifying column references.</param>
/// <returns>The generated join sequence.</returns>
public JoinSequence CreateCollectionJoinSequence(IQueryableCollection collPersister, String collectionName)
{
JoinSequence joinSequence = CreateJoinSequence();
joinSequence.SetRoot(collPersister, collectionName);
joinSequence.SetUseThetaStyle(true); // TODO: figure out how this should be set.
///////////////////////////////////////////////////////////////////////////////
// This was the reason for failures regarding INDEX_OP and subclass joins on
// theta-join dialects; not sure what behaviour we were trying to emulate ;)
// joinSequence = joinSequence.getFromPart(); // Emulate the old addFromOnly behavior.
return joinSequence;
}
IASTNode CreateFromFilterElement(IASTNode filterEntity, IASTNode alias)
{
var fromElementFound = true;
var fromElement = _currentFromClause.GetFromElement(alias.Text) ??
_currentFromClause.GetFromElementByClassName(filterEntity.Text);
if (fromElement == null)
{
fromElementFound = false;
fromElement = _currentFromClause.AddFromElement(filterEntity.Text, alias);
}
FromClause fromClause = fromElement.FromClause;
IQueryableCollection persister = _sessionFactoryHelper.GetCollectionPersister(_collectionFilterRole);
// Get the names of the columns used to link between the collection
// owner and the collection elements.
String[] keyColumnNames = persister.KeyColumnNames;
String fkTableAlias = persister.IsOneToMany
? fromElement.TableAlias
: fromClause.AliasGenerator.CreateName(_collectionFilterRole);
JoinSequence join = _sessionFactoryHelper.CreateJoinSequence();
join.SetRoot(persister, fkTableAlias);
if (!persister.IsOneToMany)
{
join.AddJoin((IAssociationType)persister.ElementType,
fromElement.TableAlias,
JoinType.InnerJoin,
persister.GetElementColumnNames(fkTableAlias));
}
join.AddCondition(fkTableAlias, keyColumnNames, " = ", true);
fromElement.JoinSequence = join;
fromElement.Filter = true;
if (log.IsDebugEnabled())
{
log.Debug("createFromFilterElement() : processed filter FROM element.");
}
if (fromElementFound)
{
return((IASTNode)adaptor.Nil());
}
return(fromElement);
}
public CollectionLoader( IQueryableCollection persister, int batchSize, ISessionFactoryImplementor factory )
: base( factory.Dialect )
{
this.collectionPersister = persister;
this.keyType = persister.KeyType;
string alias = GenerateRootAlias( persister.Role );
IList associations = WalkCollectionTree( persister, alias, factory );
InitStatementString( persister, alias, associations, batchSize, factory );
InitClassPersisters( associations );
PostInstantiate();
}
public CollectionLoader(IQueryableCollection persister, int batchSize, ISessionFactoryImplementor factory)
: base(factory.Dialect)
{
this.collectionPersister = persister;
this.keyType = persister.KeyType;
string alias = GenerateRootAlias(persister.Role);
IList associations = WalkCollectionTree(persister, alias, factory);
InitStatementString(persister, alias, associations, batchSize, factory);
InitClassPersisters(associations);
PostInstantiate();
}
private void PrepareForIndex(QueryTranslator q)
{
IQueryableCollection collPersister = q.GetCollectionPersister(collectionRole);
if (!collPersister.HasIndex)
{
throw new QueryException("unindexed collection before []");
}
string[] indexCols = collPersister.IndexColumnNames;
if (indexCols.Length != 1)
{
throw new QueryException("composite-index appears in []: " + path);
}
string[] keyCols = collPersister.KeyColumnNames;
JoinFragment ojf = q.CreateJoinFragment(useThetaStyleJoin);
ojf.AddCrossJoin(collPersister.TableName, collectionName);
ojf.AddFromFragmentString(join.ToFromFragmentString);
if (collPersister.IsOneToMany)
{
IQueryable persister = (IQueryable)collPersister.ElementPersister;
ojf.AddJoins(
((IJoinable)persister).FromJoinFragment(collectionName, true, false),
((IJoinable)persister).WhereJoinFragment(collectionName, true, false)
);
}
if (!continuation)
{
AddJoin(collPersister.TableName, collectionName, keyCols);
}
join.AddCondition(collectionName, indexCols, " = ");
string[] eltCols = collPersister.ElementColumnNames;
CollectionElement elem = new CollectionElement();
elem.ElementColumns = StringHelper.Qualify(collectionName, eltCols);
elem.Type = collPersister.ElementType;
elem.IsOneToMany = collPersister.IsOneToMany;
elem.Alias = collectionName;
elem.Join = join;
collectionElements.Add(elem); //addlast
SetExpectingCollectionIndex();
q.AddCollection(collectionName, collectionRole);
q.AddJoin(collectionName, ojf);
}
public CollectionElementLoader(IQueryableCollection collectionPersister, ISessionFactoryImplementor factory, IDictionary<string, IFilter> enabledFilters)
: base(factory, enabledFilters)
{
keyType = collectionPersister.KeyType;
indexType = collectionPersister.IndexType;
persister = (IOuterJoinLoadable)collectionPersister.ElementPersister;
entityName = persister.EntityName;
JoinWalker walker = new EntityJoinWalker(persister, ArrayHelper.Join(collectionPersister.KeyColumnNames, collectionPersister.IndexColumnNames), 1, LockMode.None, factory, enabledFilters);
InitFromWalker(walker);
PostInstantiate();
log.Debug("Static select for entity " + entityName + ": " + SqlString);
}
public OneToManyLoader( IQueryableCollection collPersister, int batchSize, ISessionFactoryImplementor factory )
: base( factory.Dialect )
{
collectionPersister = collPersister;
idType = collectionPersister.KeyType;
IOuterJoinLoadable persister = ( IOuterJoinLoadable ) collPersister.ElementPersister;
string alias = GenerateRootAlias( collPersister.Role );
IList associations = WalkTree( persister, alias, factory );
InitStatementString( collPersister, persister, alias, associations, batchSize, factory );
InitClassPersisters( persister, associations );
PostInstantiate();
}
public OneToManyLoader(IQueryableCollection collPersister, int batchSize, ISessionFactoryImplementor factory)
: base(factory.Dialect)
{
collectionPersister = collPersister;
idType = collectionPersister.KeyType;
IOuterJoinLoadable persister = ( IOuterJoinLoadable )collPersister.ElementPersister;
string alias = GenerateRootAlias(collPersister.Role);
IList associations = WalkTree(persister, alias, factory);
InitStatementString(collPersister, persister, alias, associations, batchSize, factory);
InitClassPersisters(persister, associations);
PostInstantiate();
}
public System.Type GetAssociatedClass(ISessionFactoryImplementor factory)
{
try
{
IQueryableCollection collectionPersister = (IQueryableCollection)factory.GetCollectionPersister(role);
if (!collectionPersister.ElementType.IsEntityType)
{
throw new MappingException(string.Format("collection was not an association: {0}", collectionPersister.Role));
}
return(collectionPersister.ElementPersister.MappedClass);
}
catch (InvalidCastException ice)
{
throw new MappingException("collection role is not queryable " + role, ice);
}
}
/// <summary>
/// Get the order by string required for collection fetching
/// </summary>
protected SqlString OrderBy(IList <OuterJoinableAssociation> associations)
{
SqlStringBuilder buf = new SqlStringBuilder();
OuterJoinableAssociation last = null;
foreach (OuterJoinableAssociation oj in associations)
{
if (oj.JoinType == JoinType.LeftOuterJoin)
{
if (oj.Joinable.IsCollection)
{
IQueryableCollection queryableCollection = (IQueryableCollection)oj.Joinable;
if (queryableCollection.HasOrdering)
{
string orderByString = queryableCollection.GetSQLOrderByString(oj.RHSAlias);
buf.Add(orderByString).Add(StringHelper.CommaSpace);
}
}
else
{
// it might still need to apply a collection ordering based on a
// many-to-many defined order-by...
if (last != null && last.Joinable.IsCollection)
{
IQueryableCollection queryableCollection = (IQueryableCollection)last.Joinable;
if (queryableCollection.IsManyToMany && last.IsManyToManyWith(oj))
{
if (queryableCollection.HasManyToManyOrdering)
{
string orderByString = queryableCollection.GetManyToManyOrderByString(oj.RHSAlias);
buf.Add(orderByString).Add(StringHelper.CommaSpace);
}
}
}
}
}
last = oj;
}
if (buf.Count > 0)
{
buf.RemoveAt(buf.Count - 1);
}
return(buf.ToSqlString());
}
public ComponentCollectionCriteriaInfoProvider(IQueryableCollection persister)
{
this.persister = persister;
if (!persister.ElementType.IsComponentType)
{
throw new ArgumentException("persister for role " + persister.Role + " is not a collection-of-component");
}
var componentType = (ComponentType)persister.ElementType;
var names = componentType.PropertyNames;
var types = componentType.Subtypes;
for (var i = 0; i < names.Length; i++)
{
subTypes.Add(names[i], types[i]);
}
}
public ComponentCollectionCriteriaInfoProvider(IQueryableCollection persister)
{
this.persister = persister;
if (!persister.ElementType.IsComponentType)
{
throw new ArgumentException("persister for role " + persister.Role + " is not a collection-of-component");
}
var componentType = (IAbstractComponentType) persister.ElementType;
string[] names = componentType.PropertyNames;
IType[] types = componentType.Subtypes;
for (int i = 0; i < names.Length; i++)
{
subTypes.Add(names[i], types[i]);
}
}
public OneToManyJoinWalker(IQueryableCollection oneToManyPersister, int batchSize, SqlString subquery,
ISessionFactoryImplementor factory, IDictionary<string, IFilter> enabledFilters)
: base(factory, enabledFilters)
{
this.oneToManyPersister = oneToManyPersister;
IOuterJoinLoadable elementPersister = (IOuterJoinLoadable) oneToManyPersister.ElementPersister;
string alias = GenerateRootAlias(oneToManyPersister.Role);
WalkEntityTree(elementPersister, alias);
IList<OuterJoinableAssociation> allAssociations = new List<OuterJoinableAssociation>(associations);
allAssociations.Add(
new OuterJoinableAssociation(oneToManyPersister.CollectionType, null, null, alias, JoinType.LeftOuterJoin, null, Factory,
new CollectionHelper.EmptyMapClass<string, IFilter>()));
InitPersisters(allAssociations, LockMode.None);
InitStatementString(elementPersister, alias, batchSize, subquery);
}
public string GetAssociatedEntityName(ISessionFactoryImplementor factory)
{
try
{
IQueryableCollection collectionPersister = (IQueryableCollection)factory.GetCollectionPersister(role);
if (!collectionPersister.ElementType.IsEntityType)
{
throw new MappingException("collection was not an association: " + collectionPersister.Role);
}
return(collectionPersister.ElementPersister.EntityName);
}
catch (InvalidCastException cce)
{
throw new MappingException("collection role is not queryable " + role, cce);
}
}
private void HandleElements(FromReferenceNode collectionNode, String propertyName)
{
FromElement collectionFromElement = collectionNode.FromElement;
IQueryableCollection queryableCollection = collectionFromElement.QueryableCollection;
String path = collectionNode.Path + "[]." + propertyName;
Log.Debug("Creating elements for {0}", path);
_fromElement = collectionFromElement;
if (!collectionFromElement.IsCollectionOfValuesOrComponents)
{
Walker.AddQuerySpaces(queryableCollection.ElementPersister);
}
DataType = queryableCollection.ElementType;
_selectColumns = collectionFromElement.ToColumns(_fromElement.TableAlias, propertyName, _inSelect);
}
public SubselectOneToManyLoader(IQueryableCollection persister, SqlString subquery, ICollection<EntityKey> entityKeys,
QueryParameters queryParameters, IDictionary<string, int[]> namedParameterLocMap,
ISessionFactoryImplementor factory, IDictionary<string, IFilter> enabledFilters)
: base(persister, 1, subquery, factory, enabledFilters)
{
keys = new object[entityKeys.Count];
int i = 0;
foreach (EntityKey entityKey in entityKeys)
{
keys[i++] = entityKey.Identifier;
}
namedParameters = queryParameters.NamedParameters;
// NH Different behavior: to deal with positionslParameter+NamedParameter+ParameterOfFilters
types = queryParameters.PositionalParameterTypes;
values = queryParameters.PositionalParameterValues;
this.namedParameterLocMap = namedParameterLocMap;
}
public BasicCollectionJoinWalker(IQueryableCollection collectionPersister, int batchSize,
SqlString subquery, ISessionFactoryImplementor factory, IDictionary<string, IFilter> enabledFilters)
: base(factory, enabledFilters)
{
this.collectionPersister = collectionPersister;
string alias = GenerateRootAlias(collectionPersister.Role);
WalkCollectionTree(collectionPersister, alias);
IList<OuterJoinableAssociation> allAssociations = new List<OuterJoinableAssociation>(associations);
// NH Different behavior : passing enabledFilters instead empty-filter
allAssociations.Add(
new OuterJoinableAssociation(collectionPersister.CollectionType, null, null, alias, JoinType.LeftOuterJoin, null, Factory,
enabledFilters));
InitPersisters(allAssociations, LockMode.None);
InitStatementString(alias, batchSize, subquery);
}
public BasicCollectionJoinWalker(IQueryableCollection collectionPersister, int batchSize,
SqlString subquery, ISessionFactoryImplementor factory, IDictionary <string, IFilter> enabledFilters)
: base(factory, enabledFilters)
{
this.collectionPersister = collectionPersister;
string alias = GenerateRootAlias(collectionPersister.Role);
WalkCollectionTree(collectionPersister, alias);
IList <OuterJoinableAssociation> allAssociations = new List <OuterJoinableAssociation>(associations);
// NH Different behavior : passing enabledFilters instead empty-filter
allAssociations.Add(
new OuterJoinableAssociation(collectionPersister.CollectionType, null, null, alias, JoinType.LeftOuterJoin, null, Factory,
enabledFilters));
InitPersisters(allAssociations, LockMode.None);
InitStatementString(alias, batchSize, subquery);
}
public static ICollectionInitializer CreateBatchingCollectionInitializer(IQueryableCollection persister,
int maxBatchSize,
ISessionFactoryImplementor factory,
IDictionary<string, IFilter> enabledFilters)
{
if (maxBatchSize > 1)
{
int[] batchSizesToCreate = ArrayHelper.GetBatchSizes(maxBatchSize);
Loader[] loadersToCreate = new Loader[batchSizesToCreate.Length];
for (int i = 0; i < batchSizesToCreate.Length; i++)
{
loadersToCreate[i] = new BasicCollectionLoader(persister, batchSizesToCreate[i], factory, enabledFilters);
}
return new BatchingCollectionInitializer(persister, batchSizesToCreate, loadersToCreate);
}
else
{
return new BasicCollectionLoader(persister, factory, enabledFilters);
}
}
public OneToManyLoader(
IQueryableCollection oneToManyPersister,
int batchSize,
SqlString subquery,
ISessionFactoryImplementor factory,
IDictionary enabledFilters)
: base(oneToManyPersister, factory, enabledFilters)
{
JoinWalker walker = new OneToManyJoinWalker(
oneToManyPersister,
batchSize,
subquery,
factory,
enabledFilters
);
InitFromWalker(walker);
PostInstantiate();
log.Debug("Static select for one-to-many " + oneToManyPersister.Role + ": " + SqlString);
}
public SubselectCollectionLoader(
IQueryableCollection persister,
SqlString subquery,
ICollection entityKeys,
QueryParameters queryParameters,
IDictionary namedParameterLocMap,
ISessionFactoryImplementor factory,
IDictionary<string, IFilter> enabledFilters)
: base(persister, 1, subquery, factory, enabledFilters)
{
keys = new object[entityKeys.Count];
int i = 0;
foreach (EntityKey entityKey in entityKeys)
{
keys[i++] = entityKey.Identifier;
}
namedParameters = queryParameters.NamedParameters;
types = queryParameters.FilteredPositionalParameterTypes;
values = queryParameters.FilteredPositionalParameterValues;
this.namedParameterLocMap = namedParameterLocMap;
}
public void AddManyToManyJoin(JoinFragment outerjoin, IQueryableCollection collection)
{
string manyToManyFilter = collection.GetManyToManyFilterFragment(rhsAlias, enabledFilters);
string condition = string.Empty.Equals(manyToManyFilter)
? on
: string.Empty.Equals(on) ? manyToManyFilter : on + " and " + manyToManyFilter;
outerjoin.AddJoin(joinable.TableName, rhsAlias, lhsColumns, rhsColumns, joinType, condition);
outerjoin.AddJoins(joinable.FromJoinFragment(rhsAlias, false, true),
joinable.WhereJoinFragment(rhsAlias, false, true));
}
public FromElement CreateElementJoin(IQueryableCollection queryableCollection)
{
_implied = true; //TODO: always true for now, but not if we later decide to support elements() in the from clause
_inElementsFunction = true;
IType elementType = queryableCollection.ElementType;
if (!elementType.IsEntityType)
{
throw new InvalidOperationException("Cannot create element join for a collection of non-entities!");
}
_queryableCollection = queryableCollection;
SessionFactoryHelperExtensions sfh = _fromClause.SessionFactoryHelper;
IEntityPersister entityPersister = queryableCollection.ElementPersister;
string tableAlias = _fromClause.AliasGenerator.CreateName(entityPersister.EntityName);
string associatedEntityName = entityPersister.EntityName;
IEntityPersister targetEntityPersister = sfh.RequireClassPersister(associatedEntityName);
// Create the FROM element for the target (the elements of the collection).
FromElement destination = CreateAndAddFromElement(
associatedEntityName,
_classAlias,
targetEntityPersister,
(EntityType)queryableCollection.ElementType,
tableAlias
);
// If the join is implied, then don't include sub-classes on the element.
if (_implied)
{
destination.IncludeSubclasses = false;
}
_fromClause.AddCollectionJoinFromElementByPath(_path, destination);
// origin.addDestination(destination);
// Add the query spaces.
_fromClause.Walker.AddQuerySpaces(entityPersister.QuerySpaces);
CollectionType type = queryableCollection.CollectionType;
string role = type.Role;
string roleAlias = _origin.TableAlias;
string[] targetColumns = sfh.GetCollectionElementColumns(role, roleAlias);
IAssociationType elementAssociationType = sfh.GetElementAssociationType(type);
// Create the join element under the from element.
JoinSequence joinSequence = sfh.CreateJoinSequence(_implied, elementAssociationType, tableAlias, JoinType.InnerJoin, targetColumns);
FromElement elem = InitializeJoin(_path, destination, joinSequence, targetColumns, _origin, false);
elem.UseFromFragment = true; // The associated entity is implied, but it must be included in the FROM.
elem.CollectionTableAlias = roleAlias; // The collection alias is the role.
return elem;
}
/// <summary>
/// For a collection role, return a list of associations to be fetched by outerjoin
/// </summary>
private void WalkCollectionTree(IQueryableCollection persister, string alias, string path, int currentDepth)
{
if (persister.IsOneToMany)
{
WalkEntityTree((IOuterJoinLoadable)persister.ElementPersister, alias, path, currentDepth);
}
else
{
IType type = persister.ElementType;
if (type.IsAssociationType)
{
// a many-to-many
// decrement currentDepth here to allow join across the association table
// without exceeding MAX_FETCH_DEPTH (i.e. the "currentDepth - 1" bit)
IAssociationType associationType = (IAssociationType)type;
string[] aliasedLhsColumns = persister.GetElementColumnNames(alias);
string[] lhsColumns = persister.ElementColumnNames;
// if the current depth is 0, the root thing being loaded is the
// many-to-many collection itself. Here, it is alright to use
// an inner join...
bool useInnerJoin = currentDepth == 0;
JoinType joinType =
GetJoinType(associationType, persister.FetchMode, path, persister.TableName, lhsColumns, !useInnerJoin,
currentDepth - 1, null);
AddAssociationToJoinTreeIfNecessary(associationType, aliasedLhsColumns, alias, path, currentDepth - 1, joinType);
}
else if (type.IsComponentType)
{
WalkCompositeElementTree((IAbstractComponentType)type, persister.ElementColumnNames, persister, alias, path,
currentDepth);
}
}
}
public CollectionPropertyMapping(IQueryableCollection memberPersister)
{
this.memberPersister = memberPersister;
}
public void AddManyToManyJoin(JoinFragment outerjoin, IQueryableCollection collection)
{
string manyToManyFilter = collection.GetManyToManyFilterFragment(rhsAlias, enabledFilters);
SqlString condition = string.Empty.Equals(manyToManyFilter)
? on
: StringHelper.IsEmpty(on) ? new SqlString(manyToManyFilter) :
on.Append(" and ").Append(manyToManyFilter);
outerjoin.AddJoin(joinable.TableName, rhsAlias, lhsColumns, rhsColumns, joinType, condition);
outerjoin.AddJoins(joinable.FromJoinFragment(rhsAlias, false, true),
joinable.WhereJoinFragment(rhsAlias, false, true));
}
/// <summary>
/// Create a join sequence rooted at the given collection.
/// </summary>
/// <param name="collPersister">The persister for the collection at which the join should be rooted.</param>
/// <param name="collectionName">The alias to use for qualifying column references.</param>
/// <returns>The generated join sequence.</returns>
public JoinSequence CreateCollectionJoinSequence(IQueryableCollection collPersister, String collectionName)
{
JoinSequence joinSequence = CreateJoinSequence();
joinSequence.SetRoot(collPersister, collectionName);
joinSequence.SetUseThetaStyle(true); // TODO: figure out how this should be set.
///////////////////////////////////////////////////////////////////////////////
// This was the reason for failures regarding INDEX_OP and subclass joins on
// theta-join dialects; not sure what behaviour we were trying to emulate ;)
// joinSequence = joinSequence.getFromPart(); // Emulate the old addFromOnly behavior.
return joinSequence;
}
public FromElement CreateCollectionElementsJoin(IQueryableCollection queryableCollection,
String collectionName)
{
JoinSequence collectionJoinSequence = _fromClause.SessionFactoryHelper.CreateCollectionJoinSequence(queryableCollection, collectionName);
_queryableCollection = queryableCollection;
return CreateCollectionJoin(collectionJoinSequence, null);
}
/// <summary>
/// For a collection role, return a list of associations to be fetched by outerjoin
/// </summary>
protected void WalkCollectionTree(IQueryableCollection persister, string alias)
{
WalkCollectionTree(persister, alias, string.Empty, 0);
//TODO: when this is the entry point, we should use an INNER_JOIN for fetching the many-to-many elements!
}
public CollectionLoader(IQueryableCollection persister, ISessionFactoryImplementor factory,
IDictionary<string, IFilter> enabledFilters)
: base(factory, enabledFilters)
{
collectionPersister = persister;
}
/// <summary>
/// For a composite element, add to a list of associations to be fetched by outerjoin
/// </summary>
private void WalkCompositeElementTree(IAbstractComponentType compositeType, string[] cols,
IQueryableCollection persister, string alias, string path, int currentDepth)
{
IType[] types = compositeType.Subtypes;
string[] propertyNames = compositeType.PropertyNames;
int begin = 0;
for (int i = 0; i < types.Length; i++)
{
int length = types[i].GetColumnSpan(factory);
string[] lhsColumns = ArrayHelper.Slice(cols, begin, length);
if (types[i].IsAssociationType)
{
IAssociationType associationType = types[i] as IAssociationType;
// simple, because we can't have a one-to-one or collection
// (or even a property-ref) in a composite element:
string[] aliasedLhsColumns = StringHelper.Qualify(alias, lhsColumns);
string subpath = SubPath(path, propertyNames[i]);
bool[] propertyNullability = compositeType.PropertyNullability;
JoinType joinType =
GetJoinType(associationType, compositeType.GetFetchMode(i), subpath, persister.TableName, lhsColumns,
propertyNullability == null || propertyNullability[i], currentDepth, compositeType.GetCascadeStyle(i));
AddAssociationToJoinTreeIfNecessary(associationType, aliasedLhsColumns, alias, subpath, currentDepth, joinType);
}
else if (types[i].IsComponentType)
{
string subpath = SubPath(path, propertyNames[i]);
WalkCompositeElementTree((IAbstractComponentType)types[i], lhsColumns, persister, alias, subpath, currentDepth);
}
begin += length;
}
}
public OneToManyLoader(IQueryableCollection oneToManyPersister, int batchSize, SqlString subquery,
ISessionFactoryImplementor factory, IDictionary<string, IFilter> enabledFilters)
: base(oneToManyPersister, factory, enabledFilters)
{
InitializeFromWalker(oneToManyPersister, subquery, batchSize, enabledFilters, factory);
}
