querytranslator.java

人力资源管理信息系统 论文和源代码 人力资源管理系统由人事管理、考勤管理、招聘管理、培训管理、系统管理5部分组成

		returnedTypes.add(name);
	}
	
	void addSelectScalar(Type type) {
		scalarTypes.add(type);
	}
	
	void appendWhereToken(String token) {
		whereTokens.add(token);
	}
	
	void appendHavingToken(String token) {
		havingTokens.add(token);
	}
	
	void appendOrderByToken(String token) {
		orderByTokens.add(token);
	}
	
	void appendGroupByToken(String token) {
		groupByTokens.add(token);
	}
	
	void appendScalarSelectToken(String token) {
		scalarSelectTokens.add(token);
	}
	
	void appendScalarSelectTokens(String[] tokens) {
		scalarSelectTokens.add(tokens);
	}
	
	void addJoin(String name, JoinFragment newjoin) {
		JoinFragment oldjoin = (JoinFragment) joins.get(name);
		if (oldjoin==null) {
			joins.put(name, newjoin);
		}
		else {
			oldjoin.addCondition( newjoin.toWhereFragmentString() );
			if ( oldjoin.toFromFragmentString().indexOf( newjoin.toFromFragmentString().trim() ) < 0 ) {
				throw new AssertionFailure("bug in query parser: " + queryString);
				//TODO: what about the toFromFragmentString() ????
			}
		}
	}
	
	void addNamedParameter(String name) {
		if (superQuery!=null) superQuery.addNamedParameter(name);
		Integer loc = new Integer(parameterCount++);
		Object o = namedParameters.get(name);
		if (o==null) {
			namedParameters.put(name, loc);
		}
		else if (o instanceof Integer) {
			ArrayList list = new ArrayList(4);
			list.add(o);
			list.add(loc);
			namedParameters.put(name, list);
		}
		else {
			( (ArrayList) o ).add(loc);
		}
	}
	
	protected int[] getNamedParameterLocs(String name) throws QueryException {
		Object o = namedParameters.get(name);
		if (o==null) {
			QueryException qe = new QueryException("Named parameter does not appear in Query: " + name);
			qe.setQueryString(queryString);
			throw qe;
		}
		if (o instanceof Integer) {
			return new int[] { ( (Integer) o ).intValue() };
		}
		else {
			return ArrayHelper.toIntArray( (ArrayList) o );
		}
	}
	
	private static String scalarName(int x, int y) {
		return new StringBuffer()
			.append('x')
			.append(x)
			.append(StringHelper.UNDERSCORE)
			.append(y)
			.append(StringHelper.UNDERSCORE)
			.toString();
	}
	
	private void renderSQL() throws QueryException, MappingException {
		
		final int rtsize;
		if ( returnedTypes.size()==0 && scalarTypes.size()==0 ) {
			//ie no select clause in HQL
			returnedTypes = fromTypes;
			rtsize = returnedTypes.size();
		}
		else {
			rtsize = returnedTypes.size();
			Iterator iter = entitiesToFetch.iterator();
			while ( iter.hasNext() ) {
				returnedTypes.add( iter.next() );
			}
		}
		int size = returnedTypes.size();
		persisters = new Queryable[size];
		names = new String[size];
		owners = new int[size];
		suffixes = new String[size];
		includeInSelect = new boolean[size];
		for ( int i=0; i<size; i++ ) {
			String name = (String) returnedTypes.get(i);
			//if ( !isName(name) ) throw new QueryException("unknown type: " + name);
			persisters[i] = getPersisterForName(name);
			// TODO: cannot use generateSuffixes() - it handles the initial suffix differently.
			suffixes[i] = (size==1) ? 
				StringHelper.EMPTY_STRING : 
				Integer.toString(i) + StringHelper.UNDERSCORE;
			names[i] = name;
			includeInSelect[i] = !entitiesToFetch.contains(name);
			if ( includeInSelect[i] ) selectLength++;
			if ( name.equals(collectionOwnerName) ) collectionOwnerColumn = i;
			String oneToOneOwner = (String) oneToOneOwnerNames.get(name);
			owners[i] = (oneToOneOwner==null) ? -1 : returnedTypes.indexOf(oneToOneOwner);
		}
		
		if ( ArrayHelper.isAllNegative(owners) ) owners = null;
		
		String scalarSelect = renderScalarSelect(); //Must be done here because of side-effect! yuck...
		
		int scalarSize = scalarTypes.size();
		hasScalars = scalarTypes.size()!=rtsize;
		
		returnTypes = new Type[scalarSize];
		for ( int i=0; i<scalarSize; i++ ) {
			returnTypes[i] = (Type) scalarTypes.get(i);
		}
		
		QuerySelect sql = new QuerySelect( factory.getDialect() );
		sql.setDistinct(distinct);
		
		if ( !shallowQuery ) {
			renderIdentifierSelect(sql);
			renderPropertiesSelect(sql);
		}
		
		if ( collectionPersister!=null ) {
			sql.addSelectFragmentString( collectionPersister.multiselectClauseFragment(fetchName) );
		}
		
		if ( hasScalars || shallowQuery ) sql.addSelectFragmentString(scalarSelect);
		
		//TODO: for some dialiects it would be appropriate to add the renderOrderByPropertiesSelect() to other select strings
		mergeJoins( sql.getJoinFragment() );

		sql.setWhereTokens( whereTokens.iterator() );
		
		sql.setGroupByTokens( groupByTokens.iterator() );
		sql.setHavingTokens( havingTokens.iterator() );
		sql.setOrderByTokens( orderByTokens.iterator() );
		
		if ( collectionPersister!=null && collectionPersister.hasOrdering() ) {
			sql.addOrderBy( collectionPersister.getSQLOrderByString(fetchName) );
		}
		
		scalarColumnNames = generateColumnNames(returnTypes, factory);
		
		// initialize the Set of queried identifier spaces (ie. tables)
		Iterator iter = collections.values().iterator();
		while ( iter.hasNext() ) {
			CollectionPersister p = getCollectionPersister( (String) iter.next() );
			addQuerySpace( p.getCollectionSpace() );
		}
		iter = typeMap.keySet().iterator();
		while ( iter.hasNext() ) {
			Queryable p = getPersisterForName( (String) iter.next() );
			Serializable[] spaces = p.getPropertySpaces();
			for ( int i=0; i<spaces.length; i++ ) addQuerySpace( spaces[i] );
		}
		
		sqlString = sql.toQueryString();
		
		if (holderClass!=null) holderConstructor = ReflectHelper.getConstructor(holderClass, returnTypes);
		
		if (hasScalars) {
			actualReturnTypes = returnTypes;
		}
		else {
			actualReturnTypes = new Type[selectLength];
			int j=0;
			for (int i=0; i<persisters.length; i++) {
				if ( includeInSelect[i] ) actualReturnTypes[j++] = Hibernate.entity( persisters[i].getMappedClass() );
			}
		}
				
	}
	
	private void renderIdentifierSelect(QuerySelect sql) {
		int size = returnedTypes.size();
		
		for ( int k=0; k<size; k++ ) {
			String name = (String) returnedTypes.get(k);
			String suffix = size==1 ? 
				StringHelper.EMPTY_STRING : 
				Integer.toString(k) + StringHelper.UNDERSCORE;
			sql.addSelectFragmentString( persisters[k].identifierSelectFragment(name, suffix) );
		}
		
	}
	
	/*private String renderOrderByPropertiesSelect() {
		StringBuffer buf = new StringBuffer(10);
		
		//add the columns we are ordering by to the select ID select clause
		Iterator iter = orderByTokens.iterator();
		while ( iter.hasNext() ) {
			String token = (String) iter.next();
			if ( token.lastIndexOf(".") > 0 ) {
				//ie. it is of form "foo.bar", not of form "asc" or "desc"
				buf.append(StringHelper.COMMA_SPACE).append(token);
			}
		}
		
		return buf.toString();
	}*/
	
	private void renderPropertiesSelect(QuerySelect sql) {
		int size = returnedTypes.size();
		for ( int k=0; k<size; k++ ) {
			String suffix = (size==1) ? 
				StringHelper.EMPTY_STRING : 
				Integer.toString(k) + StringHelper.UNDERSCORE;
			String name = (String) returnedTypes.get(k) ;
			sql.addSelectFragmentString( persisters[k].propertySelectFragment(name, suffix) );
		}
	}
	
	/**
	 * WARNING: side-effecty
	 */
	private String renderScalarSelect() {
		
		boolean isSubselect = superQuery!=null;
		
		StringBuffer buf = new StringBuffer(20);
		
		if ( scalarTypes.size()==0 ) {
			//ie. no select clause
			int size = returnedTypes.size();
			for ( int k=0; k<size; k++ ) {
				
				scalarTypes.add( Hibernate.entity(
					persisters[k].getMappedClass()
				) );
				
				String[] idColumnNames = persisters[k].getIdentifierColumnNames();
				for (int i=0; i<idColumnNames.length; i++) {
					buf.append( returnedTypes.get(k) ).append(StringHelper.DOT).append( idColumnNames[i] );
					if (!isSubselect) buf.append(" as ").append( scalarName(k, i) );
					if (i!=idColumnNames.length-1 || k!=size-1 ) buf.append(StringHelper.COMMA_SPACE);
				}
				
			}
			
		}
		else {
			//there _was_ a select clause
			Iterator iter = scalarSelectTokens.iterator();
			int c=0;
			boolean nolast=false; //real hacky...
			while ( iter.hasNext() ) {
				Object next = iter.next();
				if (next instanceof String) {
					String token = (String) next;
					String lc = token.toLowerCase();
					if ( lc.equals(StringHelper.COMMA_SPACE) ) {
						if (nolast) {
							nolast=false;
						}
						else {
							if (!isSubselect) buf.append(" as ").append( scalarName(c++, 0) );
						}
					}
					buf.append(token);
					if ( lc.equals("distinct") || lc.equals("all") ) {
						buf.append(' ');
					}
				}
				else {
					nolast=true;
					String[] tokens = (String[]) next;
					for ( int i=0; i<tokens.length; i++ ) {
						buf.append(tokens[i]);
						if (!isSubselect) buf.append(" as ").append( scalarName(c, i) );
						if (i!=tokens.length-1) buf.append(StringHelper.COMMA_SPACE);
					}
					c++;
				}
			}
			if (!isSubselect && !nolast) buf.append(" as ").append( scalarName(c++, 0) );
			
		}
		
		return buf.toString();
	}
	
	private void mergeJoins(JoinFragment ojf) throws MappingException, QueryException {
		
		Iterator iter = joins.entrySet().iterator();
		while ( iter.hasNext() ) {
			Map.Entry me = (Map.Entry) iter.next();
			String name = (String) me.getKey();
			JoinFragment join = (JoinFragment) me.getValue();
			
			if ( typeMap.containsKey(name) ) {
			
				Queryable p = getPersisterForName(name);
				boolean includeSubclasses = returnedTypes.contains(name) && !isShallowQuery();

				boolean isCrossJoin = crossJoins.contains(name);
				ojf.addFragment(join);
				ojf.addJoins(
					p.fromJoinFragment(name, isCrossJoin, includeSubclasses), 
					p.queryWhereFragment(name, isCrossJoin, includeSubclasses)
				);

			}
			else if ( collections.containsKey(name) ) {
				ojf.addFragment(join);
			}
			else {
				//name from a super query (a bit inelegant that it shows up here)
			}
			
		}
		
	}
	
	public final Set getQuerySpaces() {
		return querySpaces;
	}
	
	/**
	 * Is this query called by scroll() or iterate()?
	 * @return true if it is, false if it is called by find() or list()
	 */
	boolean isShallowQuery() {
		return shallowQuery;
	}
	
	void addQuerySpace(Serializable table) {
		querySpaces.add(table);
		if (superQuery!=null) superQuery.addQuerySpace(table);
	}
	
	void setDistinct(boolean distinct) {
		this.distinct = distinct;
	}
	
	boolean isSubquery() {
		return superQuery!=null;
	}
	
	/**
	 * Overrides method from Loader
	 */
	protected CollectionPersister getCollectionPersister() {
		return collectionPersister;
	}