querytranslator.java

通过系统把几乎所有与人力资源相关的数据统一管理

//$Id: QueryTranslator.java,v 1.42.2.33 2004/01/17 23:26:58 oneovthafew Exp $
package net.sf.hibernate.hql;

import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import net.sf.hibernate.AssertionFailure;
import net.sf.hibernate.Hibernate;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.LockMode;
import net.sf.hibernate.MappingException;
import net.sf.hibernate.QueryException;
import net.sf.hibernate.ScrollableResults;
import net.sf.hibernate.collection.CollectionPersister;
import net.sf.hibernate.collection.QueryableCollection;
import net.sf.hibernate.dialect.Dialect;
import net.sf.hibernate.engine.QueryParameters;
import net.sf.hibernate.engine.SessionFactoryImplementor;
import net.sf.hibernate.engine.SessionImplementor;
import net.sf.hibernate.engine.TypedValue;
import net.sf.hibernate.impl.IteratorImpl;
import net.sf.hibernate.impl.ScrollableResultsImpl;
import net.sf.hibernate.loader.Loader;
import net.sf.hibernate.persister.Loadable;
import net.sf.hibernate.persister.PropertyMapping;
import net.sf.hibernate.persister.Queryable;
import net.sf.hibernate.sql.ForUpdateFragment;
import net.sf.hibernate.sql.JoinFragment;
import net.sf.hibernate.sql.QueryJoinFragment;
import net.sf.hibernate.sql.QuerySelect;
import net.sf.hibernate.type.EntityType;
import net.sf.hibernate.type.Type;
import net.sf.hibernate.util.ArrayHelper;
import net.sf.hibernate.util.ReflectHelper;
import net.sf.hibernate.util.StringHelper;

import org.apache.commons.collections.SequencedHashMap;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * An instance of <tt>QueryTranslator</tt> translates a Hibernate 
 * query string to SQL.
 */
public class QueryTranslator extends Loader {
	
	private final String queryString;
	
	private final Map typeMap = new SequencedHashMap();
	private final Map collections = new SequencedHashMap();
	private List returnedTypes = new ArrayList();
	private final List fromTypes = new ArrayList();
	private final List scalarTypes = new ArrayList();
	private final Map namedParameters = new HashMap();
	private final Map aliasNames = new HashMap();
	private final Map oneToOneOwnerNames = new HashMap();
	private final Set crossJoins = new HashSet();
	private final Map decoratedPropertyMappings = new HashMap();
	
	private final List scalarSelectTokens = new ArrayList();
	private final List whereTokens = new ArrayList();
	private final List havingTokens = new ArrayList();
	private final Map joins = new SequencedHashMap();
	private final List orderByTokens = new ArrayList();
	private final List groupByTokens = new ArrayList();
	private final Set querySpaces = new HashSet();
	private final Set entitiesToFetch = new HashSet();
	
	private Queryable[] persisters;
	private int[] owners;
	private String[] names;
	private boolean[] includeInSelect;
	private int selectLength;
	private Type[] returnTypes;
	private Type[] actualReturnTypes;
	private String[][] scalarColumnNames;
	private SessionFactoryImplementor factory;
	private Map tokenReplacements;
	private int nameCount=0;
	private int parameterCount=0;
	private boolean distinct=false;
	private boolean compiled;
	private String sqlString;
	private Class holderClass;
	private Constructor holderConstructor;
	private boolean hasScalars;
	private boolean shallowQuery;
	private QueryTranslator superQuery;
	
	private QueryableCollection collectionPersister;
	private int collectionOwnerColumn = -1;
	private String collectionOwnerName;
	private String fetchName;
	
	private String[] suffixes;
	
	private static final Log log = LogFactory.getLog(QueryTranslator.class);
	
	/**
	 * Construct a query translator
	 */
	public QueryTranslator(String queryString) {
		this.queryString = queryString;
	}
	
	/**
	 * Compile a subquery
	 */
	void compile(QueryTranslator superquery) throws QueryException, MappingException {
		this.factory = superquery.factory;
		this.tokenReplacements = superquery.tokenReplacements;
		this.superQuery = superquery;
		this.shallowQuery = true;
		compile();
	}
	
	
	/**
	 * Compile a "normal" query. This method may be called multiple
	 * times. Subsequent invocations are no-ops.
	 */
	public synchronized void compile(SessionFactoryImplementor factory, Map replacements, boolean scalar) 
	throws QueryException, MappingException {
		if (!compiled) {
			this.factory = factory;
			this.tokenReplacements = replacements;
			this.shallowQuery = scalar;
			compile();
		}
	}
	
	/**
	 * Compile the query (generate the SQL).
	 */
	private void compile() throws QueryException, MappingException {
		
		log.trace("compiling query");
		try {
			ParserHelper.parse( 
				new PreprocessingParser(tokenReplacements), 
				queryString, 
				ParserHelper.HQL_SEPARATORS, 
				this 
			);
			renderSQL();
		}
		catch (QueryException qe) {
			qe.setQueryString(queryString);
			throw qe;
		}
		catch (MappingException me) {
			throw me;
		}
		catch (Exception e) {
			log.debug("unexpected query compilation problem", e);
			QueryException qe = new QueryException("Incorrect query syntax", e);
			qe.setQueryString(queryString);
			throw qe;
		}
		
		postInstantiate();
		
		compiled=true;
		
	}
	
	/**
	 * Persisters for the return values of a <tt>find()</tt> style query.
	 * @return an array of <tt>ClassPersister</tt>s.
	 */
	protected Loadable[] getPersisters() {
		return persisters;
	}
	
	/**
	 * Types of the return values of an <tt>iterate()</tt> style query.
	 * @return an array of <tt>Type</tt>s.
	 */
	public Type[] getReturnTypes() {
		return actualReturnTypes;
	}
	
	private String[][] getScalarColumnNames() {
		return scalarColumnNames;
	}
	
	private static void logQuery(String hql, String sql) {
		if ( log.isDebugEnabled() ) {
			log.debug("HQL: " + hql);
			log.debug("SQL: " + sql);
		}
	}
	
	void setAliasName(String alias, String name) {
		aliasNames.put(alias, name);
	}
	String getAliasName(String alias) {
		String name = (String) aliasNames.get(alias);
		if (name==null) {
			if (superQuery!=null) {
				name = superQuery.getAliasName(alias);
			}
			else {
				name = alias;
			}
		}
		return name;
	}
	
	String unalias(String path) {
		String alias = StringHelper.root(path);
		String name = getAliasName(alias);
		if (name!=null) {
			return name + path.substring( alias.length() );
		}
		else {
			return path;
		}
	}
	
	void addEntityToFetch(String name, String oneToOneOwnerName) {
		addEntityToFetch(name);
		if (oneToOneOwnerName!=null) oneToOneOwnerNames.put(name, oneToOneOwnerName);
	}
	void addEntityToFetch(String name) {
		entitiesToFetch.add(name);
	}
	
	protected String getSQLString() {
		return sqlString;
	}
	
	private int nextCount() {
		return (superQuery==null) ? nameCount++ : superQuery.nameCount++;
	}
	
	String createNameFor(Class type) {
		return generateAlias( type.getName(), nextCount()  );
	}
	
	String createNameForCollection(String role) {
		return generateAlias( role, nextCount() );
	}
	
	Class getType(String name) {
		Class type = (Class) typeMap.get(name);
		if ( type==null && superQuery!=null ) type = superQuery.getType(name);
		return type;
	}
	
	String getRole(String name) {
		String role = (String) collections.get(name);
		if ( role==null && superQuery!=null ) role = superQuery.getRole(name);
		return role;
	}
	
	boolean isName(String name) {
		return aliasNames.containsKey(name) ||
			typeMap.containsKey(name) || 
			collections.containsKey(name) || ( 
				superQuery!=null && superQuery.isName(name) 
			);
	}
	
	PropertyMapping getPropertyMapping(String name) throws QueryException {
		PropertyMapping decorator = getDecoratedPropertyMapping(name);
		if (decorator!=null) return decorator;
		
		Class type = getType(name);
		if (type==null) {
			String role = getRole(name);
			if (role==null) {
				throw new QueryException("alias not found: " + name);
			}
			return getCollectionPersister(role); //.getElementPropertyMapping();
		}
		else {
			Queryable persister = getPersister(type);
			if (persister==null) throw new QueryException( "persistent class not found: " + type.getName() );
			return persister;
		}
	}
	
	PropertyMapping getDecoratedPropertyMapping(String name) {
		return (PropertyMapping) decoratedPropertyMappings.get(name);
	}
	void decoratePropertyMapping(String name, PropertyMapping mapping) {
		decoratedPropertyMappings.put(name, mapping);
	}
	
	Queryable getPersisterForName(String name) throws QueryException {
		Class type = getType(name);
		Queryable persister = getPersister(type);
		if (persister==null) throw new QueryException( "persistent class not found: " + type.getName() );
		return persister;
	}
	
	Queryable getPersisterUsingImports(String className) {
		try {
			return (Queryable) factory.getPersister( factory.getImportedClassName(className) );
		}
		catch (MappingException me) {
			return null;
		}
	}
	
	Queryable getPersister(Class clazz) throws QueryException {
		try {
			return (Queryable) factory.getPersister(clazz);
		}
		catch (Exception e) {
			throw new QueryException( "persistent class not found: " + clazz.getName() );
		}
	}
	
	QueryableCollection getCollectionPersister(String role) throws QueryException {
		try {
			return (QueryableCollection) factory.getCollectionPersister(role);
		}
		catch (ClassCastException cce) {
			throw new QueryException( "collection role is not queryable: " + role );
		}
		catch (Exception e) {
			throw new QueryException( "collection role not found: " + role );
		}
	}
	
	void addType(String name, Class type) {
		typeMap.put(name, type);
	}
	
	void addCollection(String name, String role) {
		collections.put(name, role);
	}
	
	void addFrom(String name, Class type, JoinFragment join) {
		addType(name, type);
		addFrom(name, join);
	}
	
	void addFromCollection(String name, String collectionRole, JoinFragment join) {
		//register collection role
		addCollection(name, collectionRole);
		addJoin(name, join);
	}
	
	void addFrom(String name, JoinFragment join) {
		fromTypes.add(name);
		addJoin(name, join);
	}
	
	void addFromClass(String name, Queryable classPersister) {
		JoinFragment ojf = createJoinFragment(false);
		ojf.addCrossJoin( classPersister.getTableName(), name );
		crossJoins.add(name);
		addFrom(name, classPersister.getMappedClass(), ojf);
	}
	
	void addSelectClass(String name) {