whereparser.java

JSP+SQL编写的人力资源管理系统

		//take note when this is a boolean expression
		if ( BOOLEAN_OPERATORS.contains(lcToken) ) {
			booleanTests.removeLast();
			booleanTests.addLast(Boolean.TRUE);
		}
		
		if ( lcToken.equals("not") ) {
			nots.addLast(
				new Boolean( !( (Boolean) nots.removeLast() ).booleanValue() )
			);
			negated = !negated;
			return; //NOTE: early return
		}
		
		//process a token, mapping OO path expressions to SQL expressions
		doToken(token, q);
		
		//Open any extra brackets we might need.
		if ( !betweenSpecialCase && EXPRESSION_OPENERS.contains(lcToken) ) {
			openExpression(q, lcToken);
		}
		
		//Cope with special cases of AND, NOT, )
		specialCasesAfter(lcToken);
		
	}
	
	public void start(QueryTranslator q) throws QueryException {
		token(StringHelper.OPEN_PAREN, q);
	}
	
	public void end(QueryTranslator q) throws QueryException {
		if (expectingPathContinuation) {
			expectingPathContinuation=false;
			PathExpressionParser.CollectionElement element = pathExpressionParser.lastCollectionElement();
			if ( element.elementColumns.length!=1 ) throw new QueryException("path expression ended in composite collection element");
			appendToken( q, element.elementColumns[0] );
			addToCurrentJoin(element);
		}
		token(StringHelper.CLOSE_PAREN, q);
	}
	
	private void closeExpression(QueryTranslator q, String lcToken) {
		if ( ( (Boolean) booleanTests.removeLast() ).booleanValue() ) { //it was a boolean expression
			
			if ( booleanTests.size()>0 ) {
				// the next one up must also be
				booleanTests.removeLast();
				booleanTests.addLast(Boolean.TRUE);
			}
			
			// Add any joins
			appendToken(q, ( joins.removeLast() ).toString() );
			
		}
		else {
			StringBuffer join = (StringBuffer) joins.removeLast();
			( (StringBuffer) joins.getLast() ).append( join.toString() );
		}
		
		if ( ( (Boolean) nots.removeLast() ).booleanValue() ) negated = !negated;
		
		if ( !StringHelper.CLOSE_PAREN.equals(lcToken) ) appendToken(q, StringHelper.CLOSE_PAREN);
	}
	
	private void openExpression(QueryTranslator q, String lcToken) {
		nots.addLast(Boolean.FALSE);
		booleanTests.addLast(Boolean.FALSE);
		joins.addLast( new StringBuffer() );
		if ( !StringHelper.OPEN_PAREN.equals(lcToken) ) appendToken(q, StringHelper.OPEN_PAREN);
	}
		
	private void preprocess(String token, QueryTranslator q) throws QueryException {
		// ugly hack for cases like "foo.bar.collection.elements" 
		// (multi-part path expression ending in elements or indices)
		String[] tokens = StringHelper.split(".", token, true);
		if ( 
			tokens.length>5 &&
			( "elements".equals( tokens[tokens.length-1] ) || "indices".equals( tokens[tokens.length-1] ) )
		) {
			pathExpressionParser.start(q);
			for( int i=0; i<tokens.length-3; i++ ) {
				pathExpressionParser.token( tokens[i], q);
			}
			pathExpressionParser.token(null, q);
			pathExpressionParser.end(q);
			addJoin( pathExpressionParser.getWhereJoin(), q );
			pathExpressionParser.ignoreInitialJoin();
		}
	}
	
	private void doPathExpression(String token, QueryTranslator q) throws QueryException {
		
		preprocess(token, q);
		
		StringTokenizer tokens = new StringTokenizer(token, ".", true);
		pathExpressionParser.start(q);
		while( tokens.hasMoreTokens() ) {
			pathExpressionParser.token( tokens.nextToken(), q);
		}
		pathExpressionParser.end(q);
		if ( pathExpressionParser.isCollectionValued() ) {
			openExpression(q, StringHelper.EMPTY_STRING);
			appendToken( q, pathExpressionParser.getCollectionSubquery() );
			closeExpression(q, StringHelper.EMPTY_STRING);
			// this is ugly here, but needed because its a subquery
			q.addQuerySpace( 
				q.getCollectionPersister( pathExpressionParser.getCollectionRole() ).getCollectionSpace() 
			);
		}
		else {
			if ( pathExpressionParser.isExpectingCollectionIndex() ) {
				expectingIndex++;
			}
			else {
				addJoin( pathExpressionParser.getWhereJoin(), q );
				appendToken( q, pathExpressionParser.getWhereColumn() );
			}
		}
	}
	
	private void addJoin(JoinFragment ojf, QueryTranslator q) {
		JoinFragment fromClause = q.createJoinFragment(true);
		fromClause.addJoins( ojf.toFromFragmentString(), StringHelper.EMPTY_STRING );
		q.addJoin( pathExpressionParser.getName(), fromClause );
		addToCurrentJoin( ojf.toWhereFragmentString() );
	}
	
	private void doToken(String token, QueryTranslator q) throws QueryException {
		if ( q.isName( StringHelper.root(token) ) ) { //path expression
			doPathExpression( q.unalias(token), q);
		}
		else if ( token.startsWith(ParserHelper.HQL_VARIABLE_PREFIX) ) { //named query parameter
			q.addNamedParameter( token.substring(1) );
			appendToken(q, "?");
		}
		else {
			Queryable persister = q.getPersisterUsingImports(token);
			if ( persister!=null ) { // the name of a class
				final Object discrim = persister.getDiscriminatorSQLValue();
				if ( InFragment.NULL==discrim || InFragment.NOT_NULL==discrim ) {
					throw new QueryException("subclass test not allowed for null or not null discriminator");
				}
				appendToken( q, discrim.toString() );
			}
			else {
				Object constant;
				if (
					token.indexOf(StringHelper.DOT)>-1 &&
					( constant=ReflectHelper.getConstantValue(token) )!=null
				) {
					Type type;
					try {
						type = TypeFactory.heuristicType( constant.getClass().getName() );
					}
					catch (MappingException me) {
						throw new QueryException(me);
					}
					if (type==null) throw new QueryException("Could not determine type of: " + token);
					try {
						appendToken(q, ( (LiteralType) 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.get( token.toLowerCase() ) : null;
					if ( negatedToken!=null && ( !betweenSpecialCase || !"or".equals(negatedToken) ) ) {
						appendToken(q, negatedToken);
					}
					else {
						appendToken(q, token);
					}
				}
			}
		}
	}
	
	private void addToCurrentJoin(String sql) {
		( (StringBuffer) joins.getLast() ).append(sql);
	}
	
	private void addToCurrentJoin(PathExpressionParser.CollectionElement ce) {
		addToCurrentJoin( ce.joinFragment.toWhereFragmentString() + ce.indexValue.toString() );
	}
	
	private void specialCasesBefore(String lcToken) {
		if ( lcToken.equals("between") || lcToken.equals("not between") ) {
			betweenSpecialCase = true;
		}
	}
	
	private void specialCasesAfter(String lcToken) {
		if ( betweenSpecialCase && lcToken.equals("and") ) {
			betweenSpecialCase = false;
		}
	}
	
	void appendToken(QueryTranslator q, String token) {
		if (expectingIndex>0) {
			pathExpressionParser.setLastCollectionElementIndexValue(token);
		}
		else {
			q.appendWhereToken(token);
		}
	}
	
	private boolean continuePathExpression(String token, QueryTranslator q) throws QueryException {
		
		expectingPathContinuation = false;
			
		PathExpressionParser.CollectionElement element = pathExpressionParser.lastCollectionElement();
			
		if ( token.startsWith(".") ) { // the path expression continues after a ]
				
			doPathExpression( getElementName(element, q) + token, q ); // careful with this!
				
			addToCurrentJoin(element);
			return true; //NOTE: EARLY EXIT!
				
		}

		else { // the path expression ends at the ]
			if ( element.elementColumns.length!=1 ) {
				throw new QueryException("path expression ended in composite collection element");
			}
			appendToken( q, element.elementColumns[0] );
			addToCurrentJoin(element);
			return false;
		}
	}
}