querytranslator.cs

NHibernate NET开发者所需的

		internal string CreateNameFor(string type)
		{
			string name = StringHelper.UnqualifyEntityName(type); // NH: the default EntityName is the FullName of the class
			return StringHelper.GenerateAlias(name, NextCount());
		}

		internal string CreateNameForCollection(string role)
		{
			return StringHelper.GenerateAlias(role, NextCount());
		}

		internal string GetType(string name)
		{
			string type;
			if (!typeMap.TryGetValue(name, out type) && superQuery != null)
			{
				type = superQuery.GetType(name);
			}
			return type;
		}

		internal string GetRole(string name)
		{
			string role;
			if (!collections.TryGetValue(name, out role) && superQuery != null)
			{
				role = superQuery.GetRole(name);
			}
			return role;
		}

		internal bool IsName(string name)
		{
			return aliasNames.ContainsKey(name) ||
			       typeMap.ContainsKey(name) ||
			       collections.ContainsKey(name) ||
			       (superQuery != null && superQuery.IsName(name));
		}

		public IPropertyMapping GetPropertyMapping(string name)
		{
			IPropertyMapping decorator = GetDecoratedPropertyMapping(name);
			if (decorator != null)
			{
				return decorator;
			}

			string type = GetType(name);
			if (type == null)
			{
				string role = GetRole(name);
				if (role == null)
				{
					throw new QueryException(string.Format("alias not found: {0}", name));
				}
				return GetCollectionPersister(role);
			}
			else
			{
				IQueryable persister = GetPersister(type);
				if (persister == null)
				{
					throw new QueryException(string.Format("Persistent class not found for entity named: {0}", type));
				}
				return persister;
			}
		}

		public IPropertyMapping GetDecoratedPropertyMapping(string name)
		{
			IPropertyMapping result;
			decoratedPropertyMappings.TryGetValue(name, out result);
			return result;
		}

		public void DecoratePropertyMapping(string name, IPropertyMapping mapping)
		{
			decoratedPropertyMappings.Add(name, mapping);
		}

		internal IQueryable GetPersisterForName(string name)
		{
			string type = GetType(name);
			IQueryable persister = GetPersister(type);
			if (persister == null)
			{
				throw new QueryException("Persistent class not found for entity named: " + type);
			}

			return persister;
		}

		internal IQueryable GetPersisterUsingImports(string className)
		{
			return SessionFactoryHelper.FindQueryableUsingImports(Factory, className);
		}

		internal IQueryable GetPersister(string clazz)
		{
			try
			{
				return (IQueryable) Factory.GetEntityPersister(clazz);
			}
			catch (Exception)
			{
				throw new QueryException("Persistent class not found for entity named: " + clazz);
			}
		}

		internal IQueryableCollection GetCollectionPersister(string role)
		{
			try
			{
				return (IQueryableCollection) Factory.GetCollectionPersister(role);
			}
			catch (InvalidCastException)
			{
				throw new QueryException(string.Format("collection role is not queryable: {0}", role));
			}
			catch (Exception)
			{
				throw new QueryException(string.Format("collection role not found: {0}", role));
			}
		}

		internal void AddType(string name, string type)
		{
			typeMap[name] = type;
		}

		internal void AddCollection(string name, string role)
		{
			collections[name]= role;
		}

		internal void AddFrom(string name, string type, JoinSequence joinSequence)
		{
			AddType(name, type);
			AddFrom(name, joinSequence);
		}

		internal void AddFromCollection(string name, string collectionRole, JoinSequence joinSequence)
		{
			//register collection role
			AddCollection(name, collectionRole);
			AddJoin(name, joinSequence);
		}

		internal void AddFrom(string name, JoinSequence joinSequence)
		{
			fromTypes.Add(name);
			AddJoin(name, joinSequence);
		}

		internal void AddFromClass(string name, IQueryable classPersister)
		{
			JoinSequence joinSequence = new JoinSequence(Factory)
				.SetRoot(classPersister, name);
			AddFrom(name, classPersister.EntityName, joinSequence);
		}

		internal void AddSelectClass(string name)
		{
			returnedTypes.Add(name);
		}

		internal void AddSelectScalar(IType type)
		{
			scalarTypes.Add(type);
		}

		internal void AppendWhereToken(SqlString token)
		{
			whereTokens.Add(token);
		}

		internal void AppendHavingToken(SqlString token)
		{
			havingTokens.Add(token);
		}

		internal void AppendOrderByToken(string token)
		{
			if (StringHelper.SqlParameter.Equals(token))
				orderByTokens.Add(SqlString.Parameter);
			else
				orderByTokens.Add(new SqlString(token));
		}

		internal void AppendOrderByParameter()
		{
			orderByTokens.Add(SqlString.Parameter);
		}

		internal void AppendGroupByToken(string token)
		{
			groupByTokens.Add(new SqlString(token));
		}

		internal void AppendGroupByParameter()
		{
			groupByTokens.Add(SqlString.Parameter);
		}

		internal void AppendScalarSelectToken(string token)
		{
			scalarSelectTokens.Add(new SqlString(token));
		}

		internal void AppendScalarSelectTokens(string[] tokens)
		{
			scalarSelectTokens.Add(new SqlString(tokens));
		}

		internal void AppendScalarSelectParameter()
		{
			scalarSelectTokens.Add(SqlString.Parameter);
		}

		internal void AddJoin(string name, JoinSequence joinSequence)
		{
			if (!joins.ContainsKey(name))
			{
				joins.Add(name, joinSequence);
			}
		}

		internal void AddNamedParameter(string name)
		{
			if (superQuery != null)
			{
				superQuery.AddNamedParameter(name);
			}

			// want the param index to start at 0 instead of 1
			//int loc = ++parameterCount;
			int loc = parameterCount++;
			List<int> o;
			if (!namedParameters.TryGetValue(name, out o))
			{
				List<int> list = new List<int>(4);
				list.Add(loc);
				namedParameters[name] = list;
			}
			else
			{
				o.Add(loc);
			}
		}

		public override int[] GetNamedParameterLocs(string name)
		{
			List<int> o;
			if (!namedParameters.TryGetValue(name, out o))
			{
				QueryException qe = new QueryException("Named parameter does not appear in Query: " + name);
				qe.QueryString = queryString;
				throw qe;
			}
			return o.ToArray();
		}

		public static string ScalarName(int x, int y)
		{
			return new StringBuilder()
				.Append('x')
				.Append(x)
				.Append(StringHelper.Underscore)
				.Append(y)
				.Append(StringHelper.Underscore)
				.ToString();
		}

		private void RenderSql()
		{
			int rtsize;
			if (returnedTypes.Count == 0 && scalarTypes.Count == 0)
			{
				//ie no select clause in HQL
				returnedTypes = fromTypes;
				rtsize = returnedTypes.Count;
			}
			else
			{
				rtsize = returnedTypes.Count;
				foreach (string entityName in entitiesToFetch)
				{
					returnedTypes.Add(entityName);
				}
			}

			int size = returnedTypes.Count;
			persisters = new IQueryable[size];
			names = new string[size];
			owners = new int[size];
			ownerAssociationTypes = new EntityType[size];
			suffixes = new string[size];
			includeInSelect = new bool[size];
			for (int i = 0; i < size; i++)
			{
				string name = returnedTypes[i];
				//if ( !IsName(name) ) throw new QueryException("unknown type: " + name);
				persisters[i] = GetPersisterForName(name);
				suffixes[i] = (size == 1) ? String.Empty : i.ToString() + StringHelper.Underscore;
				names[i] = name;
				includeInSelect[i] = !entitiesToFetch.Contains(name);
				if (includeInSelect[i])
				{
					selectLength++;
				}
				string oneToOneOwner;
				owners[i] = !oneToOneOwnerNames.TryGetValue(name, out oneToOneOwner) ? -1 : returnedTypes.IndexOf(oneToOneOwner);
				IAssociationType oat;
				if (uniqueKeyOwnerReferences.TryGetValue(name, out oat))
					ownerAssociationTypes[i] = (EntityType) oat;
			}

			fetchedCollections.InitializeCollectionOwnerColumns(returnedTypes);

			if (ArrayHelper.IsAllNegative(owners))
			{
				owners = null;
			}

			SqlString scalarSelect = RenderScalarSelect(); //Must be done here because of side-effect! yuck...

			int scalarSize = scalarTypes.Count;
			hasScalars = scalarTypes.Count != rtsize;

			returnTypes = new IType[scalarSize];
			for (int i = 0; i < scalarSize; i++)
			{
				returnTypes[i] = scalarTypes[i];
			}

			QuerySelect sql = new QuerySelect(Factory.Dialect);
			sql.Distinct = distinct;

			if (!shallowQuery)
			{
				RenderIdentifierSelect(sql);
				RenderPropertiesSelect(sql);
			}

			fetchedCollections.AddSelectFragmentString(sql);

			if (hasScalars || shallowQuery)
			{
				sql.AddSelectFragmentString(scalarSelect);
			}

			// TODO: for some dialects it would be appropriate to add the renderOrderByPropertiesSelect() to other select strings
			MergeJoins(sql.JoinFragment);

			// HQL functions in whereTokens, groupByTokens, havingTokens and orderByTokens aren't rendered
			RenderFunctions(whereTokens);
			sql.SetWhereTokens((ICollection)whereTokens);

			RenderFunctions(groupByTokens);
			sql.SetGroupByTokens((ICollection)groupByTokens);

			RenderFunctions(havingTokens);
			sql.SetHavingTokens((ICollection)havingTokens);

			RenderFunctions(orderByTokens);
			sql.SetOrderByTokens((ICollection)orderByTokens);

			fetchedCollections.AddOrderBy(sql);

			scalarColumnNames = GenerateColumnNames(returnTypes, Factory);

			// initialize the set of queried identifer spaces (ie. tables)
			foreach (string name in collections.Values)
			{
				ICollectionPersister p = GetCollectionPersister(name);
				AddQuerySpaces(p.CollectionSpaces);
			}
			foreach (string name in typeMap.Keys)
			{
				IQueryable p = GetPersisterForName(name);
				AddQuerySpaces(p.QuerySpaces);
			}

			sqlString = sql.ToQuerySqlString();

			try
			{
				if (holderClass != null)
				{
					holderConstructor = ReflectHelper.GetConstructor(holderClass, returnTypes);
				}
			}
			catch (Exception nsme)
			{
				throw new QueryException("could not find constructor for: " + holderClass.Name, nsme);
			}

			if (hasScalars)
			{
				actualReturnTypes = returnTypes;
			}
			else
			{
				actualReturnTypes = new IType[selectLength];
				int j = 0;
				for (int i = 0; i < persisters.Length; i++)
				{
					if (includeInSelect[i])
					{
						actualReturnTypes[j++] = NHibernateUtil.Entity(persisters[i].EntityName);
					}
				}
			}
		}

		private void RenderIdentifierSelect(QuerySelect sql)
		{
			int size = returnedTypes.Count;

			for (int k = 0; k < size; k++)
			{
				string name = returnedTypes[k];
				string suffix = size == 1 ? String.Empty : k.ToString() + StringHelper.Underscore;
				sql.AddSelectFragmentString(new SqlString(persisters[k].IdentifierSelectFragment(name, suffix)));
			}
		}

		private void RenderPropertiesSelect(QuerySelect sql)
		{
			int size = returnedTypes.Count;
			for (int k = 0; k < size; k++)
			{
				string suffix = (size == 1) ? String.Empty : k.ToString() + StringHelper.Underscore;
				string name = (string) returnedTypes[k];
				sql.AddSelectFragmentString(new SqlString(persisters[k].PropertySelectFragment(name, suffix, false)));
			}
		}