/// <summary>
///
/// </summary>
/// <param name="tableName"></param>
/// <param name="alias"></param>
/// <param name="concreteAlias"></param>
/// <param name="fkColumns"></param>
/// <param name="pkColumns"></param>
/// <param name="joinType"></param>
public void AddJoin(string tableName, string alias, string concreteAlias, string[] fkColumns, string[] pkColumns, JoinType joinType)
{
if (!useThetaStyleInnerJoins || joinType != JoinType.InnerJoin)
{
JoinFragment jf = dialect.CreateOuterJoinFragment();
jf.AddJoin(tableName, alias, fkColumns, pkColumns, joinType);
AddFragment(jf);
}
else
{
AddCrossJoin(tableName, alias);
AddCondition(concreteAlias, fkColumns, pkColumns);
}
}
private void MergeJoins(JoinFragment ojf)
{
foreach (KeyValuePair<string, JoinSequence> de in joins)
{
string name = de.Key;
JoinSequence join = de.Value;
join.SetSelector(new Selector(this));
if (typeMap.ContainsKey(name))
{
ojf.AddFragment(join.ToJoinFragment(enabledFilters, true));
}
else if (collections.ContainsKey(name))
{
ojf.AddFragment(join.ToJoinFragment(enabledFilters, true));
}
else
{
//name from a super query (a bit inelegant that it shows up here)
}
}
}
public virtual void AddFragment(JoinFragment ojf)
{
AddJoins(ojf.ToFromFragmentString, ojf.ToWhereFragmentString);
}
/// <summary>
///
/// </summary>
/// <param name="dialect"></param>
public QuerySelect(Dialect.Dialect dialect)
{
joins = new QueryJoinFragment(dialect, false);
}
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));
}
public void AddJoins(JoinFragment outerjoin)
{
outerjoin.AddJoin(joinable.TableName, rhsAlias, lhsColumns, rhsColumns, joinType, on);
outerjoin.AddJoins(joinable.FromJoinFragment(rhsAlias, false, true),
joinable.WhereJoinFragment(rhsAlias, false, true));
}
internal void AddPathAliasAndJoin( string path, string alias, JoinFragment join )
{
pathAliases.Add( path, alias );
pathJoins.Add( path, join.Copy() );
}
public void SetJoinFragment(JoinFragment joinFragment)
{
_joinFragment = joinFragment;
}
internal void AddJoin( string name, JoinFragment newjoin )
{
JoinFragment oldjoin = ( JoinFragment ) joins[ name ];
if( oldjoin == null )
{
joins.Add( name, newjoin );
}
else
{
oldjoin.AddCondition( newjoin.ToWhereFragmentString );
//TODO: HACKS with ToString()
if( oldjoin.ToFromFragmentString.ToString().IndexOf( newjoin.ToFromFragmentString.Trim().ToString() ) < 0 )
{
throw new AssertionFailure( "bug in query parser: " + queryString );
//TODO: what about the toFromFragmentString() ????
}
}
}
private void MergeJoins( JoinFragment ojf )
{
foreach( DictionaryEntry de in joins )
{
string name = (string)de.Key;
JoinFragment join = (JoinFragment) de.Value;
if ( typeMap.Contains( name ) )
{
IQueryable p = GetPersisterForName( name );
bool includeSubclasses = returnedTypes.Contains( name )
&& !IsShallowQuery;
bool isCrossJoin = crossJoins.Contains( name );
ojf.AddFragment( join );
ojf.AddJoins(
p.FromJoinFragment( name, isCrossJoin, includeSubclasses ),
p.QueryWhereFragment( name, isCrossJoin, includeSubclasses )
);
}
else if ( collections.Contains( name ) )
{
ojf.AddFragment(join);
}
else
{
//name from a super query (a bit inelegant that it shows up here)
}
}
}
internal void AddFrom( string name, JoinFragment join )
{
fromTypes.Add( name );
AddJoin( name, join );
}
internal void AddFromCollection( string name, string collectionRole, JoinFragment join )
{
//register collection role
AddCollection( name, collectionRole );
AddJoin( name, join );
}
internal void AddFrom( string name, System.Type type, JoinFragment join )
{
AddType( name, type );
AddFrom( name, join );
}
public void AddWhereFragment(
JoinFragment joinFragment,
SqlString whereFragment,
QueryNode query,
FromElement fromElement,
HqlSqlWalker hqlSqlWalker)
{
if (whereFragment == null)
{
return;
}
if (!fromElement.UseWhereFragment && !joinFragment.HasThetaJoins)
{
return;
}
whereFragment = whereFragment.Trim();
if (StringHelper.IsEmpty(whereFragment.ToString()))
{
return;
}
// Forcefully remove leading ands from where fragments; the grammar will
// handle adding them
if (whereFragment.StartsWithCaseInsensitive("and"))
{
whereFragment = whereFragment.Substring(4);
}
log.Debug("Using unprocessed WHERE-fragment [" + whereFragment +"]");
SqlFragment fragment = (SqlFragment) Create(HqlSqlWalker.SQL_TOKEN, whereFragment.ToString());
fragment.SetJoinFragment(joinFragment);
fragment.FromElement = fromElement;
if (fromElement.IndexCollectionSelectorParamSpec != null)
{
fragment.AddEmbeddedParameter(fromElement.IndexCollectionSelectorParamSpec);
fromElement.IndexCollectionSelectorParamSpec = null;
}
if (hqlSqlWalker.IsFilter())
{
//if (whereFragment.IndexOfCaseInsensitive("?") >= 0)
if (whereFragment.ToString().IndexOf("?") >= 0)
{
IType collectionFilterKeyType = hqlSqlWalker.SessionFactoryHelper
.RequireQueryableCollection(hqlSqlWalker.CollectionFilterRole)
.KeyType;
CollectionFilterKeyParameterSpecification paramSpec = new CollectionFilterKeyParameterSpecification(
hqlSqlWalker.CollectionFilterRole,
collectionFilterKeyType,
0
);
fragment.AddEmbeddedParameter(paramSpec);
}
}
JoinProcessor.ProcessDynamicFilterParameters(
whereFragment,
fragment,
hqlSqlWalker
);
log.Debug("Using processed WHERE-fragment [" + fragment.Text + "]");
// Filter conditions need to be inserted before the HQL where condition and the
// theta join node. This is because org.hibernate.loader.Loader binds the filter parameters first,
// then it binds all the HQL query parameters, see org.hibernate.loader.Loader.processFilterParameters().
if (fragment.FromElement.IsFilter || fragment.HasFilterCondition)
{
if (_filters == null)
{
// Find or create the WHERE clause
IASTNode where = (IASTNode) query.WhereClause;
// Create a new FILTERS node as a parent of all filters
_filters = Create(HqlSqlWalker.FILTERS, "{filter conditions}");
// Put the FILTERS node before the HQL condition and theta joins
where.InsertChild(0, _filters);
}
// add the current fragment to the FILTERS node
_filters.AddChild(fragment);
}
else
{
if (_thetaJoins == null)
{
// Find or create the WHERE clause
IASTNode where = (IASTNode) query.WhereClause;
// Create a new THETA_JOINS node as a parent of all filters
_thetaJoins = Create(HqlSqlWalker.THETA_JOINS, "{theta joins}");
// Put the THETA_JOINS node before the HQL condition, after the filters.
if (_filters == null)
{
where.InsertChild(0, _thetaJoins);
}
else
{
_filters.AddSibling(_thetaJoins);
}
}
// add the current fragment to the THETA_JOINS node
_thetaJoins.AddChild(fragment);
}
}
private void AddExtraJoins(JoinFragment joinFragment, string alias, IJoinable joinable, bool innerJoin)
{
bool include = IsIncluded(alias);
joinFragment.AddJoins(joinable.FromJoinFragment(alias, innerJoin, include),
joinable.WhereJoinFragment(alias, innerJoin, include));
}
public virtual void AddFragment(JoinFragment ojf)
{
AddJoins(ojf.ToFromFragmentString, ojf.ToWhereFragmentString);
}
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));
}
/// <summary>
///
/// </summary>
/// <param name="dialect"></param>
public QuerySelect(Dialect.Dialect dialect)
{
joins = new QueryJoinFragment(dialect, false);
}
private void AddJoin( JoinFragment ojf, QueryTranslator q )
{
JoinFragment fromClause = q.CreateJoinFragment( true );
fromClause.AddJoins( ojf.ToFromFragmentString, new SqlString( String.Empty ) );
q.AddJoin( pathExpressionParser.Name, fromClause );
//TODO: HACK with ToString()
AddToCurrentJoin( ojf.ToWhereFragmentString.ToString() );
}
