Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Hibernate OGM, Domain model persistence for NoSQL datastores
   *
   * License: GNU Lesser General Public License (LGPL), version 2.1 or later
   * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
   */
  package org.hibernate.ogm.jpa.impl;
  
  import java.util.List;
 import java.util.Map;
 
 
An OGM specific EntityManager implementation which delegates most method calls to the underlying ORM EntityManager. However, queries are handled differently than the ORM default.

Author(s):
Emmanuel Bernard <emmanuel@hibernate.org>
 
 public class OgmEntityManager implements EntityManager {
 
 	private final EntityManagerImpl hibernateEm;
 	private final OgmEntityManagerFactory factory;
 	private final LockOptions lockOptions = new LockOptions();
 
 	public OgmEntityManager(OgmEntityManagerFactory factoryEntityManagerImpl hibernateEm) {
 		this. = hibernateEm;
 		this. = factory;
 	}
 
 	public void persist(Object entity) {
 		.persistentity );
 	}
 
 	public <T> T merge(T entity) {
 		return .mergeentity );
 	}
 
 	public void remove(Object entity) {
 		.removeentity );
 	}
	public <T> T find(Class<T> entityClassObject primaryKey) {
		return .findentityClassprimaryKey );
	}
	public <T> T find(Class<T> entityClassObject primaryKeyMap<StringObjectproperties) {
		return .findentityClassprimaryKeyproperties );
	}
	public <T> T find(Class<T> entityClassObject primaryKeyLockModeType lockMode) {
		return .findentityClassprimaryKeylockMode );
	}
	public <T> T find(Class<T> entityClassObject primaryKeyLockModeType lockModeMap<StringObjectproperties) {
		return .findentityClassprimaryKeylockModeproperties );
	}
	public <T> T getReference(Class<T> entityClassObject primaryKey) {
		return .getReferenceentityClassprimaryKey );
	}
	public void flush() {
	}
	public void setFlushMode(FlushModeType flushMode) {
		.setFlushModeflushMode );
	}
	}
	public void lock(Object entityLockModeType lockMode) {
		.lockentitylockMode );
	}
	public void lock(Object entityLockModeType lockModeMap<StringObjectproperties) {
		.lockentitylockModeproperties );
	}
	public void refresh(Object entity) {
		.refreshentity );
	}
	public void refresh(Object entityMap<StringObjectproperties) {
		.refreshentityproperties );
	}
	public void refresh(Object entityLockModeType lockMode) {
		.refreshentitylockMode );
	}
	public void refresh(Object entityLockModeType lockModeMap<StringObjectproperties) {
		.refreshentitylockModeproperties );
	}
	public void clear() {
	}
	public void detach(Object entity) {
		.detachentity );
	}
	public boolean contains(Object entity) {
		return .containsentity );
	}
	public LockModeType getLockMode(Object entity) {
		return .getLockModeentity );
	}
	public void setProperty(String propertyNameObject value) {
		.setPropertypropertyNamevalue );
	}
	public Map<StringObjectgetProperties() {
	}
	public Query createQuery(String qlString) {
		//TODO plug the lucene query engine
		//to let the benchmark run let delete from pass
		if ( qlString != null && qlString.toLowerCase().startsWith"delete from" ) ) {
			//pretend you care
		}
		Session session = (SessiongetDelegate();
		return applyPropertiesnew OgmJpaQuery<Object>( session.createQueryqlString ),  ) );
	}
	private Query applyProperties(Query query) {
		}
		Object queryTimeout;
		if ( ( queryTimeout = getProperties().get. ) ) != null ) {
			query.setHint.queryTimeout );
		}
		Object lockTimeout;
		if ( ( lockTimeout = getProperties().get. ) ) != null ) {
			query.setHint.lockTimeout );
		}
		return query;
	}
	public <T> TypedQuery<T> createQuery(CriteriaQuery<T> criteriaQuery) {
		throw new NotSupportedException"OGM-8""criteria queries are not supported yet" );
	}
	public Query createQuery(CriteriaUpdate updateQuery) {
		throw new NotSupportedException"OGM-8""criteria queries are not supported yet" );
	}
	public Query createQuery(CriteriaDelete deleteQuery) {
		throw new NotSupportedException"OGM-8""criteria queries are not supported yet" );
	}
	public <T> TypedQuery<T> createQuery(String qlStringClass<T> resultClass) {
		// do the translation
		Session session = (SessiongetDelegate();
		org.hibernate.Query query = session.createQueryqlString );
		resultClassCheckingresultClassquery );
		// finally, build/return the query instance
		return new OgmJpaQuery<T>( query );
	}
	public Query createNamedQuery(String name) {
		return buildQueryFromNamenamenull );
	}
	private <T> TypedQuery<T> buildQueryFromName(String nameClass<T> resultType) {
		NamedQueryDefinition queryDefinition = sessionFactory.getNamedSQLQueryname );
		if ( queryDefinition == null ) {
			queryDefinition = sessionFactory.getNamedQueryname );
			if ( queryDefinition == null ) {
				throw new IllegalArgumentException"Named query not found: " + name );
			}
			else {
				return createNamedJpqlQueryqueryDefinitionresultType );
			}
		}
		else {
			return createNamedNativeQuery( (NamedSQLQueryDefinitionqueryDefinitionresultType );
		}
	}
	protected <T> TypedQuery<T> createNamedJpqlQuery(NamedQueryDefinition namedQueryDefinitionClass<T> resultType) {
		final org.hibernate.Query query = session.createQuerynamedQueryDefinition );
		if ( resultType != null ) {
			resultClassCheckingresultTypequery );
		}
		return wrapAsJpaQuerynamedQueryDefinitionquery );
	}
	protected <T> TypedQuery<T> wrapAsJpaQuery(NamedQueryDefinition namedQueryDefinitionorg.hibernate.Query hibQuery) {
		final OgmJpaQuery<T> jpaQuery = new OgmJpaQuery<T>( hibQuery );
		applySavedSettingsnamedQueryDefinitionjpaQuery );
		return jpaQuery;
	}
	private <T> TypedQuery<T> createNamedNativeQuery(NamedSQLQueryDefinition sqlDefinitionClass<T> resultType) {
		if ( resultType != null ) {
			resultClassCheckingresultTypesqlDefinition );
		}
		String sqlQueryString = sqlDefinition.getQueryString();
		SQLQuery noSqlQuery = ( (SessiongetDelegate() ).createSQLQuerysqlQueryString );
		if ( sqlDefinition.getQueryReturns() != null ) {
			if ( sqlDefinition.getQueryReturns().length == 1 ) {
				noSqlQuery.addEntity"alias1"rootReturn.getReturnEntityName(), . );
			}
		}
		else if ( sqlDefinition.getResultSetRef() != null ) {
			ResultSetMappingDefinition resultSetMapping = sessionFactory.getResultSetMappingsqlDefinition.getResultSetRef() );
			if ( resultSetMapping == null ) {
				throw new HibernateException"Result set mapping '" + sqlDefinition.getResultSetRef() + "' referenced by query '" + sqlDefinition.getName() + "' does not exist." );
			}
			for (NativeSQLQueryReturn queryReturn : resultSetMapping.getQueryReturns() ) {
				if ( queryReturn instanceof NativeSQLQueryScalarReturn ) {
					noSqlQuery.addScalar( ( (NativeSQLQueryScalarReturnqueryReturn ).getColumnAlias() );
				}
				else if ( queryReturn instanceof NativeSQLQueryRootReturn ) {
					noSqlQuery.addEntity( ( (NativeSQLQueryRootReturnqueryReturn ).getReturnEntityName() );
				}
			}
		}
		return new OgmJpaQuery<T>( noSqlQuery );
	}
	/*
	 *  Copied from org.hibernate.jpa.spi.AbstractEntityManagerImpl
	 */
	protected void resultClassChecking(Class resultTypeNamedSQLQueryDefinition namedQueryDefinition) {
		final NativeSQLQueryReturn[] queryReturns;
		if ( namedQueryDefinition.getQueryReturns() != null ) {
			queryReturns = namedQueryDefinition.getQueryReturns();
		}
		else if ( namedQueryDefinition.getResultSetRef() != null ) {
			final ResultSetMappingDefinition rsMapping = sfi.getResultSetMappingnamedQueryDefinition.getResultSetRef() );
			queryReturns = rsMapping.getQueryReturns();
		}
		else {
			throw new AssertionFailure"Unsupported named query model. Please report the bug in Hibernate EntityManager");
		}
		if ( queryReturns.length > 1 ) {
			throw new IllegalArgumentException"Cannot create TypedQuery for query with more than one return" );
		}
		final NativeSQLQueryReturn nativeSQLQueryReturn = queryReturns[0];
		if ( nativeSQLQueryReturn instanceof NativeSQLQueryRootReturn ) {
			final Class<?> actualReturnedClass;
			final String entityClassName = ( (NativeSQLQueryRootReturnnativeSQLQueryReturn ).getReturnEntityName();
			try {
				actualReturnedClass = sfi.getServiceRegistry().getServiceClassLoaderService.class ).classForNameentityClassName );
			}
			catch ( ClassLoadingException e ) {
				throw new AssertionFailure(
						"Unable to load class [" + entityClassName + "] declared on named native query [" +
								namedQueryDefinition.getName() + "]"
				);
			}
			if ( !resultType.isAssignableFromactualReturnedClass ) ) {
				throw buildIncompatibleExceptionresultTypeactualReturnedClass );
			}
		}
		else if ( nativeSQLQueryReturn instanceof NativeSQLQueryConstructorReturn ) {
			final NativeSQLQueryConstructorReturn ctorRtn = (NativeSQLQueryConstructorReturnnativeSQLQueryReturn;
			if ( !resultType.isAssignableFromctorRtn.getTargetClass() ) ) {
				throw buildIncompatibleExceptionresultTypectorRtn.getTargetClass() );
			}
		}
		else {
			//TODO support other NativeSQLQueryReturn type. For now let it go.
		}
	}
	/*
	 *  Copied from org.hibernate.jpa.spi.AbstractEntityManagerImpl
	 */
	private void resultClassChecking(Class resultClassorg.hibernate.Query hqlQuery) {
		// make sure the query is a select -> HHH-7192
		final SessionImplementor session = unwrapSessionImplementor.class );
		final HQLQueryPlan queryPlan = session.getFactory().getQueryPlanCache()
		if ( queryPlan.getTranslators()[0].isManipulationStatement() ) {
			throw new IllegalArgumentException"Update/delete queries cannot be typed" );
		}
		// do some return type validation checking
		if ( Object[].class.equalsresultClass ) ) {
			// no validation needed
		}
		else if ( Tuple.class.equalsresultClass ) ) {
			TupleBuilderTransformer tupleTransformer = new TupleBuilderTransformerhqlQuery );
			hqlQuery.setResultTransformertupleTransformer );
		}
		else {
			final Class dynamicInstantiationClass = queryPlan.getDynamicInstantiationResultType();
			if ( dynamicInstantiationClass != null ) {
				if ( !resultClass.isAssignableFromdynamicInstantiationClass ) ) {
					throw new IllegalArgumentException"Mismatch in requested result type [" + resultClass.getName() + "] and actual result type ["
dynamicInstantiationClass.getName() + "]" );
				}
			}
			else if ( hqlQuery.getReturnTypes().length == 1 ) {
				// if we have only a single return expression, its java type should match with the requested type
				if ( !resultClass.isAssignableFromhqlQuery.getReturnTypes()[0].getReturnedClass() ) ) {
					throw new IllegalArgumentException"Type specified for TypedQuery [" + resultClass.getName()
"] is incompatible with query return type [" + hqlQuery.getReturnTypes()[0].getReturnedClass() + "]" );
				}
			}
			else {
				throw new IllegalArgumentException"Cannot create TypedQuery for query with more than one return using requested result type ["
resultClass.getName() + "]" );
			}
		}
	}
	/*
	 *  Copied from org.hibernate.jpa.spi.AbstractEntityManagerImpl
	 */
	private IllegalArgumentException buildIncompatibleException(Class<?> resultClassClass<?> actualResultClass) {
				"Type specified for TypedQuery [" + resultClass.getName() +
						"] is incompatible with query return type [" + actualResultClass + "]"
		);
	}
	/*
	 *  Copied from org.hibernate.jpa.spi.AbstractEntityManagerImpl
	 */
	private void applySavedSettings(NamedQueryDefinition namedQueryDefinitionQueryImpl jpaQuery) {
		if ( namedQueryDefinition.isCacheable() ) {
			jpaQuery.setHint.true );
			if ( namedQueryDefinition.getCacheRegion() != null ) {
				jpaQuery.setHint.namedQueryDefinition.getCacheRegion() );
			}
		}
		if ( namedQueryDefinition.getCacheMode() != null ) {
			jpaQuery.setHint.namedQueryDefinition.getCacheMode() );
		}
		if ( namedQueryDefinition.isReadOnly() ) {
			jpaQuery.setHint.true );
		}
		if ( namedQueryDefinition.getTimeout() != null ) {
			jpaQuery.setHint.namedQueryDefinition.getTimeout() * 1000 );
		}
		if ( namedQueryDefinition.getFetchSize() != null ) {
			jpaQuery.setHint.namedQueryDefinition.getFetchSize() );
		}
		if ( namedQueryDefinition.getComment() != null ) {
			jpaQuery.setHint.namedQueryDefinition.getComment() );
		}
		if ( namedQueryDefinition.getFirstResult() != null ) {
			jpaQuery.setFirstResultnamedQueryDefinition.getFirstResult() );
		}
		if ( namedQueryDefinition.getMaxResults() != null ) {
			jpaQuery.setMaxResultsnamedQueryDefinition.getMaxResults() );
		}
		if ( namedQueryDefinition.getLockOptions() != null ) {
			if ( namedQueryDefinition.getLockOptions().getLockMode() != null ) {
				jpaQuery.setLockMode( LockModeTypeHelper.getLockModeTypenamedQueryDefinition.getLockOptions().getLockMode() ) );
			}
		}
		if ( namedQueryDefinition.getFlushMode() != null ) {
			if ( namedQueryDefinition.getFlushMode() == . ) {
			}
			else {
			}
		}
	}
	public <T> TypedQuery<T> createNamedQuery(String nameClass<T> resultClass) {
		return buildQueryFromNamenameresultClass );
	}
	public Query createNativeQuery(String sqlString) {
		SQLQuery q = ( (SessiongetDelegate() ).createSQLQuerysqlString );
		return new OgmJpaQueryq );
	}
	public Query createNativeQuery(String sqlStringClass resultClass) {
		SQLQuery q = ( (SessiongetDelegate() ).createSQLQuerysqlString );
		q.addEntity"alias1"resultClass.getName(), . );
		return new OgmJpaQueryq );
	}
	public Query createNativeQuery(String sqlStringString resultSetMapping) {
		SQLQuery q = ( (SessiongetDelegate() ).createSQLQuerysqlString );
		q.setResultSetMappingresultSetMapping );
		return new OgmJpaQueryq );
	}
		throw new NotSupportedException"OGM-359""Stored procedures are not supported yet" );
	}
		throw new NotSupportedException"OGM-359""Stored procedures are not supported yet" );
	}
	public StoredProcedureQuery createStoredProcedureQuery(String procedureNameClass... resultClasses) {
		throw new NotSupportedException"OGM-359""Stored procedures are not supported yet" );
	}
	public StoredProcedureQuery createStoredProcedureQuery(String procedureNameString... resultSetMappings) {
		throw new NotSupportedException"OGM-359""Stored procedures are not supported yet" );
	}
	public <T> EntityGraph<T> createEntityGraph(Class<T> rootType) {
		throw new IllegalStateException"Hibernate OGM does not support entity graphs" );
	}
	public EntityGraph<?> createEntityGraph(String graphName) {
		throw new IllegalStateException"Hibernate OGM does not support entity graphs" );
	}
	public EntityGraph<?> getEntityGraph(String graphName) {
		throw new IllegalStateException"Hibernate OGM does not support entity graphs" );
	}
	public <T> List<EntityGraph<? super T>> getEntityGraphs(Class<T> entityClass) {
		throw new IllegalStateException"Hibernate OGM does not support entity graphs" );
	}
	public void joinTransaction() {
	}
	public boolean isJoinedToTransaction() {
	}
	public <T> T unwrap(Class<T> cls) {
		final T session = .unwrapcls );
		if ( Session.class.isAssignableFromcls ) || SessionImplementor.class.isAssignableFromcls ) ) {
			return (T) buildOgmSession( (EventSourcesession );
		}
		throw new HibernateException"Cannot unwrap the following type: " + cls );
	}
	private OgmSession buildOgmSession(Session session) {
		final OgmSessionFactory ogmSessionFactory = new OgmSessionFactoryImpl( (SessionFactoryImplementorsessionFactory );
		return new OgmSessionImplogmSessionFactory, (EventSourcesession );
	}
	public Object getDelegate() {
		final Object delegate = .getDelegate();
		if ( Session.class.isAssignableFromdelegate.getClass() ) ) {
			return buildOgmSession( (EventSourcedelegate );
		}
		else {
			return delegate;
		}
	}
	public void close() {
	}
	public boolean isOpen() {
	}
	}
		return ;
	}
	}
	public Metamodel getMetamodel() {
	}

Resembles AbstractEntityManagerImpl#CallbackExceptionMapperImpl, it only adds mappings for OGM-specific exceptions.

Author(s):
Gunnar Morling
	private final class OgmExceptionMapper implements ExceptionMapper {
		private OgmExceptionMapper() {
		}
		public RuntimeException mapStatusCheckFailure(String messageSystemException systemException) {
			throw new PersistenceExceptionmessagesystemException );
		}
			// OGM-specific
			if ( EntityAlreadyExistsException.class.isInstancefailure ) ) {
				throw  new EntityExistsExceptionfailure );
			}
			// Let ORM deal with the others
			else if ( HibernateException.class.isInstancefailure ) ) {
				throw ( (AbstractEntityManagerImpl ).convertfailure );
			}
			else if ( PersistenceException.class.isInstancefailure ) ) {
				throw failure;
			}
			else {
				throw new PersistenceExceptionmessagefailure );
			}
		}
	}
New to GrepCode? Check out our FAQ X