public void Token( string token, QueryTranslator q )
		{
			if( q.IsName( StringHelper.Root( token ) ) )
			{
				ParserHelper.Parse( pathExpressionParser, q.Unalias( token ), ParserHelper.PathSeparators, q );
				q.AppendGroupByToken( pathExpressionParser.WhereColumn );
				pathExpressionParser.AddAssociation( q );
			}
			else
			{
				q.AppendGroupByToken( token );
			}
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="token"></param>
		/// <param name="q"></param>
		public void Token( string token, QueryTranslator q )
		{
			if( q.IsName( StringHelper.Root( token ) ) )
			{
				ParserHelper.Parse( pathExpressionParser, q.Unalias( token ), ParserHelper.PathSeparators, q );
				q.AppendOrderByToken( pathExpressionParser.WhereColumn );
				pathExpressionParser.AddAssociation( q );
			}
			else if ( token.StartsWith( ParserHelper.HqlVariablePrefix ) )
			{
				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
			{
				q.AppendOrderByToken( token );
			}
		}
		public void Token( string token, QueryTranslator q )
		{
			if( token != null )
			{
				path += token;
			}

			string alias = q.GetPathAlias( path );
			if( alias != null )
			{
				Reset( q ); //reset the dotcount (but not the path)
				currentName = alias; //after reset!
				currentPropertyMapping = q.GetPropertyMapping( currentName );
				if( !ignoreInitialJoin )
				{
					JoinFragment ojf = q.GetPathJoin( path );
					join.AddCondition( ojf.ToWhereFragmentString ); //after reset!
					// we don't need to worry about any condition in the ON clause
					// here (toFromFragmentString), since anything in the ON condition 
					// is already applied to the whole query
				}
			}
			else if( ".".Equals( token ) )
			{
				dotcount++;
			}
			else
			{
				if( dotcount == 0 )
				{
					if( !continuation )
					{
						if( !q.IsName( token ) )
						{
							throw new QueryException( "undefined alias or unknown mapping: " + token );
						}
						currentName = token;
						currentPropertyMapping = q.GetPropertyMapping( currentName );
					}
				}
				else if( dotcount == 1 )
				{
					if( currentName != null )
					{
						currentProperty = token;
					}
					else if( collectionName != null )
					{
						//IQueryableCollection p = q.GetCollectionPersister( collectionRole );
						//DoCollectionProperty( token, p, collectionName );
						continuation = false;
					}
					else
					{
						throw new QueryException( "unexpected" );
					}
				}
				else
				{ // dotcount>=2

					// Do the corresponding RHS
					IType propertyType = PropertyType;

					if( propertyType == null )
					{
						throw new QueryException( "unresolved property: " + currentProperty );
					}

					if( propertyType.IsComponentType )
					{
						DereferenceComponent( token );
					}
					else if( propertyType.IsEntityType )
					{
						DereferenceEntity( token, (EntityType) propertyType, q );
					}
					else if( propertyType.IsPersistentCollectionType )
					{
						DereferenceCollection( token, ( (PersistentCollectionType) propertyType).Role, q );
					}
					else if( token != null )
					{
						throw new QueryException( "dereferenced: " + currentProperty );
					}
				}
			}
		}
		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 );
						}
					}
				}
			}
		}