abstractqueryimpl.java

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

//$Id: AbstractQueryImpl.java,v 1.1.2.22 2004/01/29 02:12:17 oneovthafew Exp $
package net.sf.hibernate.impl;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import net.sf.hibernate.Hibernate;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.LockMode;
import net.sf.hibernate.MappingException;
import net.sf.hibernate.NonUniqueResultException;
import net.sf.hibernate.PropertyNotFoundException;
import net.sf.hibernate.Query;
import net.sf.hibernate.QueryException;
import net.sf.hibernate.engine.QueryParameters;
import net.sf.hibernate.engine.RowSelection;
import net.sf.hibernate.engine.SessionImplementor;
import net.sf.hibernate.engine.TypedValue;
import net.sf.hibernate.hql.ParserHelper;
import net.sf.hibernate.property.Getter;
import net.sf.hibernate.proxy.HibernateProxyHelper;
import net.sf.hibernate.type.SerializableType;
import net.sf.hibernate.type.Type;
import net.sf.hibernate.type.TypeFactory;
import net.sf.hibernate.util.ArrayHelper;
import net.sf.hibernate.util.ReflectHelper;
import net.sf.hibernate.util.StringHelper;

/**
 * Abstract implementation of the Query interface
 * @author Gavin King, Max Andersen
 */
public abstract class AbstractQueryImpl implements Query {

	private String queryString;
	private Map lockModes = new HashMap(2);

	private final SessionImplementor session;

	private RowSelection selection;
	private List values = new ArrayList(4);
	private List types = new ArrayList(4);
	private int positionalParameterCount = 0;
	private Set actualNamedParameters = new HashSet(4);
	private Map namedParameters = new HashMap(4);
	private Map namedParameterLists = new HashMap(4);
	private boolean cacheable;
	private String cacheRegion;
	private static final Object UNSET_PARAMETER = new Object() {};
	private static final Object UNSET_TYPE = new Object() {};

	public AbstractQueryImpl(String queryString, SessionImplementor session) {
		this.session = session;
		this.queryString = queryString;
		this.selection = new RowSelection();
		initParameterBookKeeping();
	}

	public final String getQueryString() {
		return queryString;
	}


	protected Map getNamedParams() {
		return new HashMap(namedParameters);
	}

	protected void verifyParameters() throws HibernateException {

		if ( actualNamedParameters.size() != namedParameters.size() + namedParameterLists.size() ) {
			Set missingParams = new HashSet(actualNamedParameters);
			missingParams.removeAll( namedParameterLists.keySet() );
			missingParams.removeAll( namedParameters.keySet() );
			throw new QueryException( "Not all named parameters have been set: " + missingParams, getQueryString() );
		}

		if ( positionalParameterCount!=values.size() ) {
			 throw new QueryException( "Not all positional parameters have been set. Expected " + positionalParameterCount + ", set " + values, getQueryString() );
		}
		
		for (int i = 0; i < values.size(); i++) {
			if(values.get(i)==UNSET_PARAMETER || types.get(i)==UNSET_TYPE) {
				throw new QueryException( "Not all positional parameters have been set. Found unset parameter at position " + i, getQueryString() );
			}
		}
		
		
	}

	protected Map getNamedParameterLists() {
		return namedParameterLists;
	}

	protected List getValues() {
		return values;
	}

	protected List getTypes() {
		return types;
	}

	//TODO: maybe call it getRowSelection() ?
	public RowSelection getSelection() {
		return selection;
	}

	public Query setMaxResults(int maxResults) {
		selection.setMaxRows( new Integer(maxResults) );
		return this;
	}

	public Query setTimeout(int timeout) {
		selection.setTimeout( new Integer(timeout) );
		return this;
	}

	public Query setFirstResult(int firstResult) {
		selection.setFirstRow( new Integer(firstResult) );
		return this;
	}

	public Query setParameter(int position, Object val, Type type) {
		if ( positionalParameterCount==0 ) {
			throw new IllegalArgumentException("No positional parameters in query: " + getQueryString() );
		}
		if ( position<0 || position>positionalParameterCount-1 ) {
			throw new IllegalArgumentException("Positional parameter does not exist: " + position + " in query: " + getQueryString() );
		}
		int size = values.size();
		if ( position<size ) {
			values.set(position, val);
			types.set(position, type);
		}
		else {
			// prepend value and type list with null for any positions before the wanted position.
			for ( int i=0; i<position-size; i++ ) {
				values.add(UNSET_PARAMETER);
				types.add(UNSET_TYPE);
			}
			values.add(val);
			types.add(type);
		}
		return this;
	}

	public Query setString(int position, String val) {
		setParameter(position, val, Hibernate.STRING);
		return this;
	}

	public Query setCharacter(int position, char val) {
		setParameter(position, new Character(val), Hibernate.CHARACTER);
		return this;
	}

	public Query setBoolean(int position, boolean val) {
		setParameter(position, new Boolean(val), Hibernate.BOOLEAN);
		return this;
	}

	public Query setByte(int position, byte val) {
		setParameter(position, new Byte(val), Hibernate.BYTE);
		return this;
	}

	public Query setShort(int position, short val) {
		setParameter(position, new Short(val), Hibernate.SHORT);
		return this;
	}

	public Query setInteger(int position, int val) {
		setParameter(position, new Integer(val), Hibernate.INTEGER);
		return this;
	}

	public Query setLong(int position, long val) {
		setParameter(position, new Long(val), Hibernate.LONG);
		return this;
	}

	public Query setFloat(int position, float val) {
		setParameter(position, new Float(val), Hibernate.FLOAT);
		return this;
	}

	public Query setDouble(int position, double val) {
		setParameter(position, new Double(val), Hibernate.DOUBLE);
		return this;
	}

	public Query setBinary(int position, byte[] val) {
		setParameter(position, val, Hibernate.BINARY);
		return this;
	}

	public Query setText(int position, String val) {
		setParameter(position, val, Hibernate.TEXT);
		return this;
	}

	public Query setSerializable(int position, Serializable val) {
		setParameter(position, val, Hibernate.SERIALIZABLE);
		return this;
	}

	public Query setDate(int position, Date date) {
		setParameter(position, date, Hibernate.DATE);
		return this;
	}

	public Query setTime(int position, Date date) {
		setParameter(position, date, Hibernate.TIME);
		return this;
	}

	public Query setTimestamp(int position, Date date) {
		setParameter(position, date, Hibernate.TIMESTAMP);
		return this;
	}

	public Query setEntity(int position, Object val) {
		setParameter( position, val, Hibernate.entity( HibernateProxyHelper.getClass(val) ) );
		return this;
	}

	public Query setEnum(int position, Object val) throws MappingException {
		setParameter( position, val, Hibernate.enum( val.getClass() ) );
		return this;
	}

	public Query setLocale(int position, Locale locale) {
		setParameter(position, locale, Hibernate.LOCALE);
		return this;
	}

	public Query setCalendar(int position, Calendar calendar) {
		setParameter(position, calendar, Hibernate.CALENDAR);
		return this;
	}

	public Query setCalendarDate(int position, Calendar calendar) {
		setParameter(position, calendar, Hibernate.CALENDAR_DATE);
		return this;
	}

	public Query setBinary(String name, byte[] val) {
		setParameter(name, val, Hibernate.BINARY);
		return this;
	}

	public Query setText(String name, String val) {
		setParameter(name, val, Hibernate.TEXT);
		return this;
	}

	public Query setBoolean(String name, boolean val) {
		setParameter(name, new Boolean(val), Hibernate.BOOLEAN);
		return this;
	}

	public Query setByte(String name, byte val) {
		setParameter(name, new Byte(val), Hibernate.BYTE);
		return this;
	}

	public Query setCharacter(String name, char val) {
		setParameter(name, new Character(val), Hibernate.CHARACTER);
		return this;
	}

	public Query setDate(String name, Date date) {
		setParameter(name, date, Hibernate.DATE);
		return this;
	}