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);
                        }
                    }
                }
            }
        }