sessionimpl.java

介绍了hibernate的入门有一些基本常用的事例

	private FilterTranslator getFilterTranslator(
			Object collection, 
			String filter, 
			QueryParameters parameters, 
			boolean scalar)
	throws HibernateException {

		if ( collection == null ) throw new NullPointerException( "null collection passed to filter" );

		if ( log.isTraceEnabled() ) {
			log.trace( "filter: " + filter );
			parameters.traceParameters(factory);
		}

		CollectionEntry entry = persistenceContext.getCollectionEntryOrNull(collection);
		final CollectionPersister roleBeforeFlush = (entry == null) ? null : entry.getLoadedPersister();

		FilterTranslator filterTranslator;
		if ( roleBeforeFlush == null ) {
			// if it was previously unreferenced, we need
			// to flush in order to get its state into the
			// database to query
			flush();
			entry = persistenceContext.getCollectionEntryOrNull(collection);
			CollectionPersister roleAfterFlush = (entry == null) ? null : entry.getLoadedPersister();
			if ( roleAfterFlush == null ) throw new QueryException( "The collection was unreferenced" );
			filterTranslator = factory.getFilter( filter, roleAfterFlush.getRole(), scalar, getEnabledFilters() );
		}
		else {
			// otherwise, we only need to flush if there are
			// in-memory changes to the queried tables
			filterTranslator = factory.getFilter( filter, roleBeforeFlush.getRole(), scalar, getEnabledFilters() );
			if ( autoFlushIfRequired( filterTranslator.getQuerySpaces() ) ) {
				// might need to run a different filter entirely after the flush
				// because the collection role may have changed
				entry = persistenceContext.getCollectionEntryOrNull(collection);
				CollectionPersister roleAfterFlush = (entry == null) ? null : entry.getLoadedPersister();
				if ( roleBeforeFlush != roleAfterFlush ) {
					if ( roleAfterFlush == null ) throw new QueryException( "The collection was dereferenced" );
					filterTranslator = factory.getFilter( filter, roleAfterFlush.getRole(), scalar, getEnabledFilters() );
				}
			}
		}

		parameters.getPositionalParameterValues()[0] = entry.getLoadedKey();
		parameters.getPositionalParameterTypes()[0] = entry.getLoadedPersister().getKeyType();

		return filterTranslator;
	}

	public List listFilter(Object collection, String filter, QueryParameters queryParameters) 
	throws HibernateException {

		String[] concreteFilters = QuerySplitter.concreteQueries( filter, factory );
		FilterTranslator[] filters = new FilterTranslator[concreteFilters.length];

		for ( int i = 0; i < concreteFilters.length; i++ ) {
			filters[i] = getFilterTranslator( collection, concreteFilters[i], queryParameters, false );
		}

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

		List results = CollectionHelper.EMPTY_LIST;
		try {
			for ( int i = 0; i < concreteFilters.length; i++ ) {
				List currentResults = filters[i].list( this, queryParameters );
				currentResults.addAll(results);
				results = currentResults;
			}
		}
		finally {
			dontFlushFromFind--;
		}
		return results;

	}

	public Iterator iterateFilter(Object collection, String filter, QueryParameters queryParameters) 
	throws HibernateException {

		String[] concreteFilters = QuerySplitter.concreteQueries(filter, factory);
		FilterTranslator[] filters = new FilterTranslator[concreteFilters.length];

		for ( int i=0; i<concreteFilters.length; i++ ) {
			filters[i] = getFilterTranslator( collection, concreteFilters[i], queryParameters, true );
		}

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

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

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

		return many ? new JoinedIterator(results) : result;

	}

	public Criteria createCriteria(Class persistentClass, String alias) {
		return new CriteriaImpl( persistentClass.getName(), alias, this );
	}

	public Criteria createCriteria(String entityName, String alias) {
		return new CriteriaImpl(entityName, alias, this);
	}

	public Criteria createCriteria(Class persistentClass) {
		return new CriteriaImpl( persistentClass.getName(), this );
	}

	public Criteria createCriteria(String entityName) {
		return new CriteriaImpl(entityName, this);
	}

	public ScrollableResults scroll(CriteriaImpl criteria, ScrollMode scrollMode) {
		String entityName = criteria.getEntityOrClassName();
		CriteriaLoader loader = new CriteriaLoader(
				getOuterJoinLoadable(entityName),
				factory,
				criteria,
				entityName,
		        getEnabledFilters()
		);
		autoFlushIfRequired( loader.getQuerySpaces() );
		dontFlushFromFind++;
		try {
			return loader.scroll(this, scrollMode);
		}
		finally {
			dontFlushFromFind--;
		}
	}

	public List list(CriteriaImpl criteria) throws HibernateException {

		String[] implementors = factory.getImplementors( criteria.getEntityOrClassName() );
		int size = implementors.length;

		CriteriaLoader[] loaders = new CriteriaLoader[size];
		Set spaces = new HashSet();
		for( int i=0; i <size; i++ ) {

			loaders[i] = new CriteriaLoader(
					getOuterJoinLoadable( implementors[i] ),
					factory,
					criteria,
					implementors[i],
			        getEnabledFilters()
			);

			spaces.addAll( loaders[i].getQuerySpaces() );

		}

		autoFlushIfRequired(spaces);

		List results = Collections.EMPTY_LIST;
		dontFlushFromFind++;
		try {
			for( int i=0; i<size; i++ ) {
				final List currentResults = loaders[i].list(this);
				currentResults.addAll(results);
				results = currentResults;
			}
		}
		finally {
			dontFlushFromFind--;
		}

		return results;
	}

	private OuterJoinLoadable getOuterJoinLoadable(String entityName) throws MappingException {
		EntityPersister persister = factory.getEntityPersister(entityName);
		if ( !(persister instanceof OuterJoinLoadable) ) {
			throw new MappingException( "class persister is not OuterJoinLoadable: " + entityName );
		}
		return ( OuterJoinLoadable ) persister;
	}

	public boolean contains(Object object) {
		if ( object instanceof HibernateProxy ) {
			//do not use proxiesByKey, since not all
			//proxies that point to this session's
			//instances are in that collection!
			LazyInitializer li = ( (HibernateProxy) object ).getHibernateLazyInitializer();
			if ( li.isUninitialized() ) {
				//if it is an uninitialized proxy, pointing
				//with this session, then when it is accessed,
				//the underlying instance will be "contained"
				return li.getSession()==this;
			}
			else {
				//if it is initialized, see if the underlying
				//instance is contained, since we need to 
				//account for the fact that it might have been
				//evicted
				object = li.getImplementation();
			}
		}
		return persistenceContext.isEntryFor(object);
	}
	
	public SQLQuery createSQLQuery(String sql) {
		return new SQLQueryImpl(sql, this);
	}

	public Query createSQLQuery(String sql, String returnAlias, Class returnClass) {
		return new SQLQueryImpl(sql, new String[] { returnAlias }, new Class[] { returnClass }, this);
	}

	public Query createSQLQuery(String sql, String returnAliases[], Class returnClasses[]) {
		return new SQLQueryImpl(sql, returnAliases, returnClasses, this);
	}

	public ScrollableResults scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters) 
	throws HibernateException {

		if ( log.isTraceEnabled() ) {
			log.trace( "scroll SQL query: " + customQuery.getSQL() );
		}

		CustomLoader loader = new CustomLoader( customQuery, getFactory() );

		autoFlushIfRequired( loader.getQuerySpaces() );

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

	// basically just an adapted copy of find(CriteriaImpl)
	public List listCustomQuery(CustomQuery customQuery, QueryParameters queryParameters) 
	throws HibernateException {

		if ( log.isTraceEnabled() ) log.trace( "SQL query: " + customQuery.getSQL() );
		
		CustomLoader loader = new CustomLoader( customQuery, getFactory() );

		autoFlushIfRequired( loader.getQuerySpaces() );

		dontFlushFromFind++;
		try {
			return loader.list(this, queryParameters);
		}
		finally {
			dontFlushFromFind--;
		}
	}

	public SessionFactory getSessionFactory() {
		return factory;
	}
	
	public void initializeCollection(PersistentCollection collection, boolean writing) 
	throws HibernateException {
		listeners.getInitializeCollectionEventListener()
			.onInitializeCollection( new InitializeCollectionEvent(collection, this) );
	}

	public String bestGuessEntityName(Object object) {
		if (object instanceof HibernateProxy) {
			object = ( (HibernateProxy) object ).getHibernateLazyInitializer().getImplementation();
		}
		EntityEntry entry = persistenceContext.getEntry(object);
		if (entry==null) {
			return guessEntityName(object);
		}
		else {
			return entry.getPersister().getEntityName();
		}
	}
	
	public String getEntityName(Object object) {
		if (object instanceof HibernateProxy) {
			if ( !persistenceContext.containsProxy( object ) ) {
				throw new TransientObjectException("proxy was not associated with the session");
			}
			object = ( (HibernateProxy) object ).getHibernateLazyInitializer().getImplementation();
		}

		EntityEntry entry = persistenceContext.getEntry(object);
		if (entry==null) throwTransientObjectException(object);
		return entry.getPersister().getEntityName();
	}

	private void throwTransientObjectException(Object object) throws HibernateException {
		throw new TransientObjectException(
				"object references an unsaved transient instance - save the transient instance before flushing: " +
				guessEntityName(object)
		);
	}

	public String guessEntityName(Object object) throws HibernateException {
		String entity = interceptor.getEntityName(object);
		if ( entity == null ) {
			if ( object instanceof Map ) {
				entity = (String) ( (Map) object ).get( "type" );
				if ( entity == null ) throw new HibernateException( "could not determine type of dynamic entity" );
			}
			else if ( object instanceof Element ) {
				return ( (Element) object ).getName();
			}
			else {
				entity = object.getClass().getName();
			}
		}
		return entity;
	}

	public void cancelQuery() throws HibernateException {
		getBatcher().cancelLastQuery();
	}

	public Interceptor getInterceptor() {
		return interceptor;
	}

	public int getDontFlushFromFind() {
		return dontFlushFromFind;
	}

	public String toString() {
		StringBuffer buf = new StringBuffer(500)
			.append( getClass().getName() )
			.append('(');
		if ( isOpen() ) {
			buf.append(persistenceContext)
				.append(" ")
				.append(actionQueue);
		}
		else {
			buf.append("<closed>");
		}
		return buf.append(')').toString();
	}

	public SessionEventListenerConfig getListeners() {
		return listeners;
	}

	public ActionQueue getActionQueue() {
		return actionQueue;
	}
	
	public PersistenceContext getPersistenceContext() {
		return persistenceContext;
	}
}