C# QueryTranslator.GetPersisterUsingImports方法代码示例

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

//.........这里部分代码省略.........
				{
					// (AS is always optional, for consistency 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)