private void DoToken(string token, QueryTranslator q)
{
SessionFactoryHelper helper = new SessionFactoryHelper(q.Factory);
if (q.IsName(StringHelper.Root(token))) //path expression
{
DoPathExpression(q.Unalias(token), q);
}
else if (token.StartsWith(ParserHelper.HqlVariablePrefix)) //named query parameter
{
var name = 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, q.GetNamedParameter(name));
}
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
AppendToken(q, q.GetPositionalParameter());
}
else
{
IQueryable persister = q.GetPersisterUsingImports(token);
if (persister != null) // the name of a class
{
string 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);
}
else
{
object constant;
string fieldName = null;
System.Type importedType = 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);
string typeName = StringHelper.Qualifier(token);
importedType = helper.GetImportedClass(typeName);
}
if (indexOfDot > -1 && importedType != null &&
(constant = ReflectHelper.GetConstantValue(importedType, 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, q.Factory.Dialect));
}
catch (Exception e)
{
throw new QueryException("Could not format constant value to SQL literal: " + token, e);
}
}
else
{
//anything else
string negatedToken = null;
if (negated)
{
negations.TryGetValue(token.ToLowerInvariant(), out negatedToken);
}
if (negatedToken != null && (!betweenSpecialCase || !"or".Equals(negatedToken)))
{
AppendToken(q, negatedToken);
}
else
{
AppendToken(q, token);
}
}
}
}
}
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;
}
}
}
}