abstractqueryimpl.java

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

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

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

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

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

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

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

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

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

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

	public Query setParameter(String name, Object val, Type type) {
		if( !actualNamedParameters.contains(name) ) {
			 throw new IllegalArgumentException("Parameter " + name + " does not exist as a named parameter in [" + getQueryString() + "]");
		}
		else {
			 namedParameters.put(name, new TypedValue(type, val) );
			 return this;
		}
	}

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

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

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

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

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

	public Query setBigDecimal(int position, BigDecimal number) {
		setParameter(position, number, Hibernate.BIG_DECIMAL);
		return this;
	}

	public Query setBigDecimal(String name, BigDecimal number) {
		setParameter(name, number, Hibernate.BIG_DECIMAL);
		return this;
	}

	public Query setParameter(int position, Object val) throws HibernateException {
		setParameter( position, val, guessType(val) );
		return this;
	}

	public Query setParameter(String name, Object val) throws HibernateException {
		setParameter( name, val, guessType(val) );
		return this;
	}

	private Type guessType(Object param) throws HibernateException {
		Class clazz = HibernateProxyHelper.getClass(param);
		return guessType(clazz);
	}

	private Type guessType(Class clazz) throws HibernateException {
		String typename = clazz.getName();
		Type type = TypeFactory.heuristicType(typename);
		boolean serializable = type!=null && type instanceof SerializableType;
		if (type==null || serializable) {
			try {
				session.getFactory().getPersister(clazz);
			}
			catch (MappingException me) {
				if (serializable) {
					return type;
				}
				else {
					throw new HibernateException("Could not determine a type for class: " + typename);
				}
			}
			return Hibernate.entity(clazz);
		}
		else {
			return type;
		}
	}


	public Type[] getReturnTypes() throws HibernateException {
		return session.getFactory().getReturnTypes(queryString);
	}

	public Query setParameterList(String name, Collection vals, Type type) throws HibernateException {
		if( !actualNamedParameters.contains(name) ) {
			   throw new IllegalArgumentException("Parameter " + name + " does not exist as a named parameter in [" + getQueryString() + "]");
		}
		namedParameterLists.put( name, new TypedValue(type, vals) );
		return this;
	}

	protected String bindParameterLists(Map namedParamsCopy) {
		String query = this.queryString;
		Iterator iter = namedParameterLists.entrySet().iterator();
		while ( iter.hasNext() ) {
			Map.Entry me = (Map.Entry) iter.next();
			query = bindParameterList( query, (String) me.getKey(), (TypedValue) me.getValue(), namedParamsCopy );
		}
		return query;
	}

	private String bindParameterList(String query, String name, TypedValue typedList, Map namedParamsCopy) {
		Collection vals = (Collection) typedList.getValue();
		Type type = typedList.getType();
		StringBuffer list = new StringBuffer(16);
		Iterator iter = vals.iterator();
		int i=0;
		while ( iter.hasNext() ) {
			String alias = name + i++ + StringHelper.UNDERSCORE;
			namedParamsCopy.put(alias, new TypedValue( type, iter.next() ) );
			list.append( ParserHelper.HQL_VARIABLE_PREFIX + alias );
			if ( iter.hasNext() ) list.append(StringHelper.COMMA_SPACE);
		}
		return StringHelper.replace( query, ParserHelper.HQL_VARIABLE_PREFIX + name, list.toString(), true );
	}

	public Query setParameterList(String name, Collection vals) throws HibernateException {
		if (vals==null) {
			throw new QueryException("Collection must be not null!");
		}
		
		if(vals.size()==0) {
			setParameterList(name, vals, null);
		} 
		else {
			setParameterList(name, vals, guessType( vals.iterator().next() ) );
		}
		
		return this;
	}

	public String[] getNamedParameters() throws HibernateException {
		return (String[]) actualNamedParameters.toArray(new String[actualNamedParameters.size()]);
	}

	private void initParameterBookKeeping() {
		StringTokenizer st = new StringTokenizer(queryString, ParserHelper.HQL_SEPARATORS);
		Set result = new HashSet();

		while ( st.hasMoreTokens() ) {
			String string = st.nextToken();
			if( string.startsWith(ParserHelper.HQL_VARIABLE_PREFIX) ) {
				result.add( string.substring(1) );
			}
		}

		actualNamedParameters = result;
		positionalParameterCount = StringHelper.countUnquoted(queryString, '?');
	}

	public Query setProperties(Object bean) throws HibernateException {
		Class clazz = bean.getClass();
		String[] params = getNamedParameters();
		for (int i = 0; i < params.length; i++) {
			String namedParam = params[i];
			try {
				Getter getter = ReflectHelper.getGetter(clazz, namedParam);
				setParameter( namedParam, getter.get(bean), guessType( getter.getReturnType() ) );
			}
			catch (PropertyNotFoundException pnfe) {}
		}
		return this;
	}


	public Query setParameterList(String name, Object[] vals, Type type)
		throws HibernateException {
		return setParameterList(name, Arrays.asList(vals), type);
	}

	public Query setParameterList(String name, Object[] vals)
		throws HibernateException {
		return setParameterList( name, Arrays.asList(vals) );
	}

	public void setLockMode(String alias, LockMode lockMode) {
		lockModes.put(alias, lockMode);
	}

	Map getLockModes() {
		return lockModes;
	}

	SessionImplementor getSession() {
		return session;
	}

	public Object uniqueResult() throws HibernateException {
		return uniqueElement( list() );
	}

	static Object uniqueElement(List list) throws NonUniqueResultException {
		int size = list.size();
		if (size==0) return null;
		Object first = list.get(0);
		for ( int i=1; i<size; i++ ) {
			if ( list.get(i)!=first ) {
				throw new NonUniqueResultException( list.size() );
			}
		}
		return first;
	}

	protected RowSelection getRowSelection() {
		return selection;
	}

	public Type[] typeArray() {
		return (Type[]) getTypes().toArray(ArrayHelper.EMPTY_TYPE_ARRAY);
	}
	public Object[] valueArray() {
		return getValues().toArray();
	}
	
	public QueryParameters getQueryParameters(Map namedParams) {
		return new QueryParameters( 
			typeArray(), 
			valueArray(), 
			namedParams, 
			getLockModes(), 
			getSelection(), 
			cacheable, 
			cacheRegion
		);
	}

	public Query setCacheable(boolean cacheable) {
		this.cacheable = cacheable;
		return this;
	}
	
	public Query setCacheRegion(String cacheRegion) {
		this.cacheRegion = cacheRegion.trim();
		return this;
	}

}