C# QueryTranslator.Unalias方法代码示例

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

		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 if (token.StartsWith(ParserHelper.HqlVariablePrefix))
			{
				q.AddNamedParameter(token.Substring(1));
				q.AppendGroupByParameter();
			}
			else
			{
				q.AppendGroupByToken(token);
			}
		}

		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)
		{
			SessionFactoryHelper helper = new SessionFactoryHelper(q.Factory);
			string lctoken = token.ToLowerInvariant();

			if (first)
			{
				first = false;
				if ("distinct".Equals(lctoken))
				{
					q.Distinct = true;
					return;
				}
				else if ("all".Equals(lctoken))
				{
					q.Distinct = false;
					return;
				}
			}

			if (afterNew)
			{
				afterNew = false;
				holderClass = helper.GetImportedClass(token);
				if (holderClass == null)
				{
					throw new QueryException("class not found: " + token);
				}
				q.HolderClass = holderClass;
				insideNew = true;
			}
			else if (token.Equals(StringHelper.Comma))
			{
				if (readyForAliasOrExpression)
				{
					throw new QueryException("alias or expression expected in SELECT");
				}
				q.AppendScalarSelectToken(StringHelper.CommaSpace);
				readyForAliasOrExpression = true;
			}
			else if ("new".Equals(lctoken))
			{
				afterNew = true;
				readyForAliasOrExpression = false;
			}
			else if (StringHelper.OpenParen.Equals(token))
			{
				parenCount++;
				if (!funcStack.HasFunctions && holderClass != null && !readyForAliasOrExpression)
				{
					//opening paren in new Foo ( ... )
					readyForAliasOrExpression = true;
				}
				else if (funcStack.HasFunctions)
				{
					q.AppendScalarSelectToken(token);
				}
				else
				{
					throw new QueryException("HQL function expected before '(' in SELECT clause.");
				}
				readyForAliasOrExpression = true;
			}
			else if (StringHelper.ClosedParen.Equals(token))
			{
				parenCount--;
				if (parenCount < 0)
				{
					throw new QueryException("'(' expected before ')' in SELECT clause.");
				}

				if (insideNew && !funcStack.HasFunctions && !readyForAliasOrExpression)
				{
					//if we are inside a new Result(), but not inside a nested function
					insideNew = false;
				}
				else if (funcStack.HasFunctions)
				{
					q.AppendScalarSelectToken(token);
					IType scalarType = funcStack.GetReturnType();
					funcStack.Pop();

					// Can't have an alias or expression right after the closing parenthesis of a function call.
					readyForAliasOrExpression = false;

					// if all functions were parsed add the type of the first function in stack
					if (!funcStack.HasFunctions)
						q.AddSelectScalar(scalarType);
				}
			}
			else if (IsHQLFunction(lctoken, q) && token == q.Unalias(token))
			{
				if (!readyForAliasOrExpression && !funcStack.HasFunctions)
				{
					// The syntax control inside a functions is delegated to the render
					throw new QueryException("',' expected before function in SELECT: " + token);
				}
				if (funcStack.HasFunctions && funcStack.FunctionGrammar.IsKnownArgument(lctoken))
				{
					// Some function, like extract, may have KnownArgument with the same name of another function
//.........这里部分代码省略.........

//.........这里部分代码省略.........
				if (insideNew && !aggregate && !ready)
				{
					//if we are inside a new Result(), but not inside a nested function
					insideNew = false;
				}
				else if (aggregate && ready)
				{
					q.AppendScalarSelectToken(token);
					aggregateFuncTokenList.RemoveAt(0);
					if (aggregateFuncTokenList.Count < 1)
					{
						aggregate = false;
						ready = false;
					}
				}
				else
				{
					throw new QueryException("( expected before ) in select");
				}
			}
			else if (countArguments.Contains(lctoken))
			{
				if (!ready || !aggregate)
				{
					throw new QueryException(token + " only allowed inside aggregate function in SELECT");
				}
				q.AppendScalarSelectToken(token);
				if ("*".Equals(token) && !afterAggregatePath)
				{
					q.AddSelectScalar(GetFunction("count", q).ReturnType(NHibernateUtil.Int64, q.Factory));
				} //special case
				afterAggregatePath = false;
			}
			else if (GetFunction(lctoken, q) != null && token == q.Unalias(token))
			{
				// the name of an SQL function
				if (!ready)
				{
					throw new QueryException(", expected before aggregate function in SELECT: " + token);
				}
				aggregate = true;
				afterAggregatePath = false;
				aggregateAddSelectScalar = true;
				aggregateFuncTokenList.Insert(0, lctoken);
				ready = false;
				q.AppendScalarSelectToken(token);
				if (!AggregateHasArgs(lctoken, q))
				{
					q.AddSelectScalar(AggregateType(aggregateFuncTokenList, null, q));
					if (!AggregateFuncNoArgsHasParenthesis(lctoken, q))
					{
						aggregateFuncTokenList.RemoveAt(0);
						if (aggregateFuncTokenList.Count < 1)
						{
							aggregate = false;
							ready = false;
						}
						else
						{
							ready = true;
						}
					}
				}
			}
			else if (aggregate)
			{

//.........这里部分代码省略.........
						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.EntityName);
						q.AddFromClass(entityName, p);
						expectingAs = true;
					}
					else if (token.IndexOf('.') < 0)
					{
						// starts with an alias (old style)