/// <summary>
///
/// </summary>
/// <param name="q"></param>
/// <param name="token"></param>
protected virtual void AppendToken( QueryTranslator q, string token )
{
if( expectingIndex > 0 )
{
pathExpressionParser.LastCollectionElementIndexValue = token;
}
else
{
// a String.Empty can get passed in here. If that occurs
// then don't create a new SqlString for it - just ignore
// it since it adds nothing to the sql being generated.
if( token != null && token.Length > 0 )
{
q.AppendWhereToken( new SqlString( token ) );
}
}
}
/// <summary>
///
/// </summary>
/// <param name="q"></param>
/// <param name="token"></param>
protected virtual void AppendToken( QueryTranslator q, SqlString token )
{
if( expectingIndex > 0 )
{
pathExpressionParser.LastCollectionElementIndexValue = token.ToString();
}
else
{
q.AppendWhereToken( token );
}
}
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 );
}
}
}
}
}