public void LookupConstant(DotNode node)
{
string text = ASTUtil.GetPathText(node);
IQueryable persister = _walker.SessionFactoryHelper.FindQueryableUsingImports(text);
if (persister != null)
{
// the name of an entity class
string discrim = persister.DiscriminatorSQLValue;
node.DataType = persister.DiscriminatorType;
if (InFragment.Null == discrim || InFragment.NotNull == discrim)
{
throw new InvalidPathException("subclass test not allowed for null or not null discriminator: '" + text + "'");
}
else
{
SetSQLValue(node, text, discrim); //the class discriminator value
}
}
else
{
Object value = ReflectHelper.GetConstantValue(text);
if (value == null)
{
throw new InvalidPathException("Invalid path: '" + text + "'");
}
else
{
SetConstantValue(node, text, value);
}
}
}
private void HandleDotStructure(IASTNode dotStructureRoot)
{
var expression = ASTUtil.GetPathText(dotStructureRoot);
var constant = ReflectHelper.GetConstantValue(expression, _sfi);
if (constant != null)
{
dotStructureRoot.ClearChildren();
dotStructureRoot.Type = HqlSqlWalker.JAVA_CONSTANT;
dotStructureRoot.Text = expression;
}
}
private void ProcessText()
{
if (!_processedText)
{
if (_factory == null)
{
throw new InvalidOperationException();
}
_constantValue = ReflectHelper.GetConstantValue(base.Text, _factory);
_heuristicType = TypeFactory.HeuristicType(_constantValue.GetType());
_processedText = true;
}
}
public void GetConstantValueEnum()
{
object result = ReflectHelper.GetConstantValue(typeof(FooStatus), "ON");
Assert.AreEqual(1, (int)result, "Should have found value of 1");
}
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);
}
}
}
}
}