public void Token( string token, QueryTranslator q )
{
if( q.IsName( StringHelper.Root( token ) ) )
{
ParserHelper.Parse( pathExpressionParser, q.Unalias( token ), ParserHelper.PathSeparators, q );
q.AppendGroupByToken( pathExpressionParser.WhereColumn );
pathExpressionParser.AddAssociation( q );
}
else
{
q.AppendGroupByToken( token );
}
}
/// <summary>
///
/// </summary>
/// <param name="token"></param>
/// <param name="q"></param>
public void Token( string token, QueryTranslator q )
{
if( q.IsName( StringHelper.Root( token ) ) )
{
ParserHelper.Parse( pathExpressionParser, q.Unalias( token ), ParserHelper.PathSeparators, q );
q.AppendOrderByToken( pathExpressionParser.WhereColumn );
pathExpressionParser.AddAssociation( q );
}
else if ( token.StartsWith( ParserHelper.HqlVariablePrefix ) )
{
q.AddNamedParameter( token.Substring( 1 ) );
// this is only a temporary parameter to help with the parsing of hql -
// when the type becomes known then this will be converted to its real
// parameter type.
//AppendToken( q, new SqlString( new object[ ] {new Parameter( StringHelper.SqlParameter )} ) );
}
else
{
q.AppendOrderByToken( token );
}
}
public void Token( string token, QueryTranslator q )
{
if( token != null )
{
path += token;
}
string alias = q.GetPathAlias( path );
if( alias != null )
{
Reset( q ); //reset the dotcount (but not the path)
currentName = alias; //after reset!
currentPropertyMapping = q.GetPropertyMapping( currentName );
if( !ignoreInitialJoin )
{
JoinFragment ojf = q.GetPathJoin( path );
join.AddCondition( ojf.ToWhereFragmentString ); //after reset!
// we don't need to worry about any condition in the ON clause
// here (toFromFragmentString), since anything in the ON condition
// is already applied to the whole query
}
}
else if( ".".Equals( token ) )
{
dotcount++;
}
else
{
if( dotcount == 0 )
{
if( !continuation )
{
if( !q.IsName( token ) )
{
throw new QueryException( "undefined alias or unknown mapping: " + token );
}
currentName = token;
currentPropertyMapping = q.GetPropertyMapping( currentName );
}
}
else if( dotcount == 1 )
{
if( currentName != null )
{
currentProperty = token;
}
else if( collectionName != null )
{
//IQueryableCollection p = q.GetCollectionPersister( collectionRole );
//DoCollectionProperty( token, p, collectionName );
continuation = false;
}
else
{
throw new QueryException( "unexpected" );
}
}
else
{ // dotcount>=2
// Do the corresponding RHS
IType propertyType = PropertyType;
if( propertyType == null )
{
throw new QueryException( "unresolved property: " + currentProperty );
}
if( propertyType.IsComponentType )
{
DereferenceComponent( token );
}
else if( propertyType.IsEntityType )
{
DereferenceEntity( token, (EntityType) propertyType, q );
}
else if( propertyType.IsPersistentCollectionType )
{
DereferenceCollection( token, ( (PersistentCollectionType) propertyType).Role, q );
}
else if( token != null )
{
throw new QueryException( "dereferenced: " + currentProperty );
}
}
}
}
private void DoToken( string token, QueryTranslator q )
{
if( q.IsName( StringHelper.Root( token ) ) ) //path expression
{
DoPathExpression( q.Unalias( token ), q );
}
else if( token.StartsWith( ParserHelper.HqlVariablePrefix ) ) //named query parameter
{
q.AddNamedParameter( token.Substring( 1 ) );
// this is only a temporary parameter to help with the parsing of hql -
// when the type becomes known then this will be converted to its real
// parameter type.
AppendToken( q, new SqlString( new object[ ] {new Parameter( StringHelper.SqlParameter )} ) );
}
else if( token.Equals( StringHelper.SqlParameter ) )
{
//if the token is a "?" then we have a Parameter so convert it to a SqlCommand.Parameter
// instead of appending a "?" to the WhereTokens
q.AppendWhereToken( new SqlString( new object[ ] {new Parameter( StringHelper.SqlParameter)} ) );
}
else
{
IQueryable persister = q.GetPersisterUsingImports( token );
if( persister != null ) // the name of a class
{
object discrim = persister.DiscriminatorSQLValue;
if ( InFragment.Null == discrim || InFragment.NotNull == discrim )
{
throw new QueryException( "subclass test not allowed for null or not null discriminator" );
}
AppendToken( q, discrim.ToString() );
}
else
{
object constant;
string fieldName = null;
string typeName = null;
string importedName = null;
int indexOfDot = token.IndexOf( StringHelper.Dot );
// don't even bother to do the lookups if the indexOfDot is not
// greater than -1. This will save all the string modifications.
// This allows us to resolve to the full type before obtaining the value e.g. FooStatus.OFF -> NHibernate.Model.FooStatus.OFF
if( indexOfDot > -1 )
{
fieldName = StringHelper.Unqualify( token );
typeName = StringHelper.Qualifier( token );
importedName = q.factory.GetImportedClassName( typeName );
}
if( indexOfDot > - 1 &&
( constant = ReflectHelper.GetConstantValue( importedName, fieldName ) ) != null )
{
// need to get the NHibernate Type so we can convert the Enum or field from
// a class into it's string representation for hql.
IType type;
try
{
type = TypeFactory.HeuristicType( constant.GetType().AssemblyQualifiedName );
}
catch( MappingException me )
{
throw new QueryException( me );
}
if ( type == null )
{
throw new QueryException( string.Format( "Could not determin the type of: {0}", token ) );
}
try
{
AppendToken( q, ( ( ILiteralType ) type ).ObjectToSQLString( constant ) );
}
catch( Exception e )
{
throw new QueryException( "Could not format constant value to SQL literal: " + token, e );
}
}
else
{
//anything else
string negatedToken = negated ? ( string ) negations[ token.ToLower( System.Globalization.CultureInfo.InvariantCulture ) ] : null;
if( negatedToken != null && ( !betweenSpecialCase || !"or".Equals( negatedToken ) ) )
{
AppendToken( q, negatedToken );
}
else
{
AppendToken( q, token );
}
}
}
}
}