sessionimpl.java

来自「hibernate-3.0.5 中文文档」· Java 代码 · 共 1,527 行 · 第 1/4 页

	public Object getFilterParameterValue(String filterParameterName) {
        String[] parsed = parseFilterParameterName(filterParameterName);
		FilterImpl filter = (FilterImpl) enabledFilters.get( parsed[0] );
		if (filter == null) {
			throw new IllegalArgumentException("Filter [" + parsed[0] + "] currently not enabled");
		}
		return filter.getParameter( parsed[1] );
	}

	public Type getFilterParameterType(String filterParameterName) {
		String[] parsed = parseFilterParameterName(filterParameterName);
		FilterDefinition filterDef = factory.getFilterDefinition( parsed[0] );
		if (filterDef == null) {
			throw new IllegalArgumentException("Filter [" + parsed[0] + "] not defined");
		}
		Type type = filterDef.getParameterType( parsed[1] );
		if (type == null) {
			// this is an internal error of some sort...
			throw new InternalError("Unable to locate type for filter parameter");
		}
		return type;
	}

	public Map getEnabledFilters() {
		// First, validate all the enabled filters...
		//TODO: this implementation has bad performance
		Iterator itr = enabledFilters.values().iterator();
		while ( itr.hasNext() ) {
			final Filter filter = (Filter) itr.next();
			filter.validate();
		}
		return enabledFilters;
	}

	private String[] parseFilterParameterName(String filterParameterName) {
		int dot = filterParameterName.indexOf('.');
		if (dot <= 0) {
			throw new IllegalArgumentException("Invalid filter-parameter name format"); // TODO: what type?
		}
		String filterName = filterParameterName.substring(0, dot);
		String parameterName = filterParameterName.substring(dot+1);
		return new String[] {filterName, parameterName};
	}


	/**
	 * Retrieve a list of persistent objects using a hibernate query
	 */
	public List find(String query) throws HibernateException {
		return list( query, new QueryParameters() );
	}

	public List find(String query, Object value, Type type) throws HibernateException {
		return list( query, new QueryParameters(type, value) );
	}

	public List find(String query, Object[] values, Type[] types) throws HibernateException {
		return list( query, new QueryParameters(types, values) );
	}

	public List list(String query, QueryParameters queryParameters) throws HibernateException {

		if ( log.isTraceEnabled() ) {
			log.trace( "find: " + query );
			queryParameters.traceParameters(factory);
		}

		queryParameters.validateParameters();
		QueryTranslator[] q = getQueries(query, false);

		List results = CollectionHelper.EMPTY_LIST;

		dontFlushFromFind++;   //stops flush being called multiple times if this method is recursively called

		//execute the queries and return all result lists as a single list
		boolean success = false;
		try {
			for ( int i = 0; i < q.length; i++ ) {
				List currentResults = q[i].list(this, queryParameters);
				currentResults.addAll(results);
				results = currentResults;
			}
			success = true;
		}
		finally {
			dontFlushFromFind--;
			afterOperation(success);
		}
		return results;
	}

	public int executeUpdate(String query, QueryParameters queryParameters) throws HibernateException {

		if ( log.isTraceEnabled() ) {
			log.trace( "executeUpdate: " + query );
			queryParameters.traceParameters(factory);
		}

		queryParameters.validateParameters();
		QueryTranslator[] queryTranslators = getQueries(query, false);
		
		int result = 0;
		boolean success = false;
		try {
			for (int i=0; i<queryTranslators.length; i++) {
				result += queryTranslators[i].executeUpdate( queryParameters, this );
			}
			success = true;
		}
		finally {
			afterOperation(success);
		}
		return result;
	}

	private QueryTranslator[] getQueries(String query, boolean scalar) throws HibernateException {

		// take the union of the query spaces (ie. the queried tables)
		QueryTranslator[] q = factory.getQuery( query, scalar, getEnabledFilters() );
		return prepareQueries(q);

	}

	private QueryTranslator[] prepareQueries(QueryTranslator[] q) {
		HashSet qs = new HashSet();
		for ( int i = 0; i < q.length; i++ ) {
			qs.addAll( q[i].getQuerySpaces() );
		}

		autoFlushIfRequired(qs);

		return q;
	}

	public Iterator iterate(String query) throws HibernateException {
		return iterate( query, new QueryParameters() );
	}

	public Iterator iterate(String query, Object value, Type type) throws HibernateException {
		return iterate( query, new QueryParameters(type, value) );
	}

	public Iterator iterate(String query, Object[] values, Type[] types) throws HibernateException {
		return iterate( query, new QueryParameters(types, values) );
	}

	public Iterator iterate(String query, QueryParameters queryParameters) throws HibernateException {

		if ( log.isTraceEnabled() ) {
			log.trace( "iterate: " + query );
			queryParameters.traceParameters(factory);
		}

		queryParameters.validateParameters();
		QueryTranslator[] q = getQueries(query, true);

		if ( q.length == 0 ) return EmptyIterator.INSTANCE;

		Iterator result = null;
		Iterator[] results = null;
		boolean many = q.length > 1;
		if (many) results = new Iterator[q.length];

		dontFlushFromFind++; //stops flush being called multiple times if this method is recursively called

		try {

			//execute the queries and return all results as a single iterator
			for ( int i = 0; i < q.length; i++ ) {
				result = q[i].iterate(queryParameters, this);
				if (many) results[i] = result;
			}

			return many ? new JoinedIterator(results) : result;

		}
		finally {
			dontFlushFromFind--;
		}
	}

	public ScrollableResults scroll(String query, QueryParameters queryParameters) throws HibernateException {

		if ( log.isTraceEnabled() ) {
			log.trace( "scroll: " + query );
			queryParameters.traceParameters( factory );
		}

		QueryTranslator[] q = factory.getQuery( query, false, getEnabledFilters() );
		if ( q.length != 1 ) throw new QueryException( "implicit polymorphism not supported for scroll() queries" );
		autoFlushIfRequired( q[0].getQuerySpaces() );

		dontFlushFromFind++; //stops flush being called multiple times if this method is recursively called
		try {
			return q[0].scroll(queryParameters, this);
		}
		finally {
			dontFlushFromFind--;
		}
	}

	public int delete(String query) throws HibernateException {
		return delete( query, ArrayHelper.EMPTY_OBJECT_ARRAY, ArrayHelper.EMPTY_TYPE_ARRAY );
	}

	public int delete(String query, Object value, Type type) throws HibernateException {
		return delete( query, new Object[]{value}, new Type[]{type} );
	}

	public int delete(String query, Object[] values, Type[] types) throws HibernateException {
		if ( query == null ) {
			throw new IllegalArgumentException("attempt to perform delete-by-query with null query");
		}

		if ( log.isTraceEnabled() ) {
			log.trace( "delete: " + query );
			if ( values.length != 0 ) {
				log.trace( "parameters: " + StringHelper.toString( values ) );
			}
		}

		List list = find( query, values, types );
		int deletionCount = list.size();
		for ( int i = 0; i < deletionCount; i++ ) {
			delete( list.get( i ) );
		}

		return deletionCount;
	}

	public Query createFilter(Object collection, String queryString) {
		CollectionFilterImpl filter = new CollectionFilterImpl(queryString, collection, this);
		filter.setComment(queryString);
		return filter;
	}
	
	public Query createQuery(String queryString) {
		QueryImpl query = new QueryImpl(queryString, this);
		query.setComment(queryString);
		return query;
	}

	private Query createQuery(String queryString, FlushMode queryFlushMode) {
		QueryImpl query = new QueryImpl(queryString, queryFlushMode, this);
		query.setComment(queryString);
		return query;
	}
	
	public Query getNamedQuery(String queryName) throws MappingException {
		NamedQueryDefinition nqd = factory.getNamedQuery(queryName);
		final Query query;
		if ( nqd != null ) {
			query = createQuery( 
					nqd.getQueryString(), 
					nqd.getFlushMode()
			);
			query.setComment("named HQL query " + queryName);
		}
		else {
			NamedSQLQueryDefinition nsqlqd = factory.getNamedSQLQuery( queryName );
			if (nsqlqd==null) {
				throw new MappingException("Named query not known: " + queryName);
			}
			query = new SQLQueryImpl(nsqlqd, this);
			nqd = nsqlqd;
			query.setComment("named native SQL query " + queryName);
		}
		query.setCacheable( nqd.isCacheable() );
		query.setCacheRegion( nqd.getCacheRegion() );
		if ( nqd.getTimeout()!=null ) query.setTimeout( nqd.getTimeout().intValue() );
		if ( nqd.getFetchSize()!=null ) query.setFetchSize( nqd.getFetchSize().intValue() );
		return query;
	}

	public Object instantiate(String entityName, Serializable id) throws HibernateException {
		return instantiate( factory.getEntityPersister(entityName), id );
	}

	/**
	 * give the interceptor an opportunity to override the default instantiation
	 */
	public Object instantiate(EntityPersister persister, Serializable id) throws HibernateException {
		Object result = interceptor.instantiate( persister.getEntityName(), entityMode, id );
		if ( result == null ) result = persister.instantiate( id, entityMode );
		return result;
	}

	public EntityMode getEntityMode() {
		return entityMode;
	}

	public void setFlushMode(FlushMode flushMode) {
		if ( log.isTraceEnabled() ) log.trace("setting flush mode to: " + flushMode);
		this.flushMode = flushMode;
	}
	
	public FlushMode getFlushMode() {
		return flushMode;
	}

	public CacheMode getCacheMode() {
		return cacheMode;
	}
	
	public void setCacheMode(CacheMode cacheMode) {
		if ( log.isTraceEnabled() ) log.trace("setting cache mode to: " + cacheMode);
		this.cacheMode= cacheMode; 
	}

	public Transaction beginTransaction() throws HibernateException {
		if ( !isRootSession ) {
			log.warn("Transaction started on non-root session");
		}
		Transaction tx = jdbcContext.beginTransaction();
		interceptor.afterTransactionBegin(tx);
		return tx;
	}

	public EntityPersister getEntityPersister(final String entityName, final Object object) {
		if (entityName==null) {
			return factory.getEntityPersister( guessEntityName(object) );
		}
		else {
			return factory.getEntityPersister( entityName ).getSubclassEntityPersister( object, getFactory(), entityMode );
		}
	}

	// not for internal use:
	public Serializable getIdentifier(Object object) throws HibernateException {
		if ( object instanceof HibernateProxy ) {
			LazyInitializer li = ( (HibernateProxy) object ).getHibernateLazyInitializer();
			if ( li.getSession() != this ) {
				throw new TransientObjectException( "The proxy was not associated with this session" );
			}
			return li.getIdentifier();
		}
		else {
			EntityEntry entry = persistenceContext.getEntry(object);
			if ( entry == null ) {
				throw new TransientObjectException( "The instance was not associated with this session" );
			}
			return entry.getId();
		}
	}

	/**
	 * Get the id value for an object that is actually associated with the session. This
	 * is a bit stricter than getEntityIdentifierIfNotUnsaved().
	 */
	public Serializable getEntityIdentifier(Object object) {
		if ( object instanceof HibernateProxy ) {
			return getProxyIdentifier(object);
		}
		else {
			EntityEntry entry = persistenceContext.getEntry(object);
			return entry != null ? entry.getId() : null;
		}
	}
	
	private Serializable getProxyIdentifier(Object proxy) {
		return ( (HibernateProxy) proxy ).getHibernateLazyInitializer().getIdentifier();
	}

	public Collection filter(Object collection, String filter) throws HibernateException {
		return listFilter( collection, filter, new QueryParameters( new Type[1], new Object[1] ) );
	}

	public Collection filter(Object collection, String filter, Object value, Type type) throws HibernateException {
		return listFilter( collection, filter, new QueryParameters( new Type[]{null, type}, new Object[]{null, value} ) );
	}

	public Collection filter(Object collection, String filter, Object[] values, Type[] types) 
	throws HibernateException {
		Object[] vals = new Object[values.length + 1];
		Type[] typs = new Type[types.length + 1];
		System.arraycopy( values, 0, vals, 1, values.length );
		System.arraycopy( types, 0, typs, 1, types.length );
		return listFilter( collection, filter, new QueryParameters( typs, vals ) );
	}

	/**