public void Token( string token, QueryTranslator q )
{
// start by looking for HQL keywords....
string lcToken = token.ToLower( System.Globalization.CultureInfo.InvariantCulture );
if( lcToken.Equals( StringHelper.Comma ) )
{
if( !( expectingJoin | expectingAs ) )
{
throw new QueryException( "unexpected token: ," );
}
expectingJoin = false;
expectingAs = false;
}
else if( lcToken.Equals( "join" ) )
{
if( !afterJoinType )
{
if( !( expectingJoin | expectingAs ) )
{
throw new QueryException( "unexpected token: join" );
}
// inner joins can be abbreviated to 'join'
joinType = JoinType.InnerJoin;
expectingJoin = false;
expectingAs = false;
}
else
{
afterJoinType = false;
}
}
else if( lcToken.Equals( "fetch" ) )
{
if( q.IsShallowQuery )
{
throw new QueryException( "fetch may not be used with scroll() or iterate()" );
}
if( joinType == JoinType.None )
{
throw new QueryException( "unexpected token: fetch" );
}
if( joinType == JoinType.FullJoin || joinType == JoinType.RightOuterJoin )
{
throw new QueryException( "fetch may only be used with inner join or left outer join" );
}
afterFetch = true;
}
else if( lcToken.Equals( "outer" ) )
{
// 'outer' is optional and is ignored)
if( !afterJoinType || ( joinType != JoinType.LeftOuterJoin && joinType != JoinType.RightOuterJoin ) )
{
throw new QueryException( "unexpected token: outer" );
}
}
else if( joinTypes.Contains( lcToken ) )
{
if( !( expectingJoin | expectingAs ) )
{
throw new QueryException( "unexpected token: " + token );
}
joinType = ( JoinType ) joinTypes[ lcToken ];
afterJoinType = true;
expectingJoin = false;
expectingAs = false;
}
else if( lcToken.Equals( "class" ) )
{
if( !afterIn )
{
throw new QueryException( "unexpected token: class" );
}
if( joinType != JoinType.None )
{
throw new QueryException( "outer or full join must be followed by path expression" );
}
afterClass = true;
}
else if( lcToken.Equals( "in" ) )
{
if( !expectingIn )
{
throw new QueryException( "unexpected token: in" );
}
afterIn = true;
expectingIn = false;
}
else if( lcToken.Equals( "as" ) )
{
if( !expectingAs )
{
throw new QueryException( "unexpected token: as" );
}
afterAs = true;
expectingAs = false;
}
else
{
if( afterJoinType )
{
throw new QueryException( "join expected: " + token );
}
if( expectingJoin )
{
throw new QueryException( "unexpected token: " + token );
}
if( expectingIn )
{
throw new QueryException( "in expected: " + token );
}
// now anything that is not a HQL keyword
if( afterAs || expectingAs )
{
// (AS is always optional, for consistentcy with SQL/OQL
// process the "new" HQL stype where aliases are assigned
// _after_ the class name or path expression ie using the
// AS construction
if( entityName != null )
{
q.SetAliasName( token, entityName );
}
else
{
throw new QueryException( "unexpected: as " + token );
}
afterAs = false;
expectingJoin = true;
expectingAs = false;
entityName = null;
}
else if( afterIn )
{
// process the "old" HQL style where aliases appear _first
// ie using the IN or IN CLASS constructions
if( alias == null )
{
throw new QueryException( "alias not specified for: " + token );
}
if( joinType != JoinType.None )
{
throw new QueryException( "outer or full join must be followed by path expressions" );
}
if( afterClass )
{
// treat it as a classname
IQueryable p = q.GetPersisterUsingImports( token );
if( p == null )
{
throw new QueryException( "persister not found: " + token );
}
q.AddFromClass( alias, p );
}
else
{
// treat it as a path expression
peParser.JoinType = JoinType.InnerJoin;
peParser.UseThetaStyleJoin = true;
ParserHelper.Parse( peParser, q.Unalias( token ), ParserHelper.PathSeparators, q );
if( !peParser.IsCollectionValued )
{
throw new QueryException( "pathe expression did not resolve to collection: " + token );
}
string nm = peParser.AddFromCollection( q );
q.SetAliasName( alias, nm );
}
alias = null;
afterIn = false;
afterClass = false;
expectingJoin = true;
}
else
{
// handle a path expression or class name that appears
// at the start, in the "new" HQL style or an alias that
// appears at the start in the "old HQL stype
IQueryable p = q.GetPersisterUsingImports( token );
if( p != null )
{
// starts with the name of a mapped class (new style)
if( joinType != JoinType.None )
{
throw new QueryException( "outer or full join must be followed by path expression" );
}
entityName = q.CreateNameFor( p.MappedClass );
q.AddFromClass( entityName, p );
expectingAs = true;
}
else if( token.IndexOf( '.' ) < 0 )
{
// starts with an alias (old style)
// semi-bad thing about this: can't re-alias another alias...
alias = token;
expectingIn = true;
}
else
{
// starts with a path expression (new style)
// force HQL style: from Person p inner join p.cars c
//if (joinType==JoinType.None) throw new QueryException("path expression must be preceded by full, left, right or inner join");
//allow ODMG OQL style: from Person p, p.cars c
if( joinType != JoinType.None )
{
peParser.JoinType = joinType;
}
else
{
peParser.JoinType = JoinType.InnerJoin;
}
peParser.UseThetaStyleJoin = q.IsSubquery;
ParserHelper.Parse( peParser, q.Unalias( token ), ParserHelper.PathSeparators, q );
entityName = peParser.AddFromAssociation( q );
joinType = JoinType.None;
peParser.JoinType = JoinType.InnerJoin;
if( afterFetch )
{
peParser.Fetch( q, entityName );
afterFetch = false;
}
expectingAs = true;
}
}
}
}
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 );
}
}
}
}
}