Project: hibernate-ogm
/*
 * Hibernate, Relational Persistence for Idiomatic Java 
 * 
 * JBoss, Home of Professional Open Source 
 * Copyright 2011 Red Hat Inc. and/or its affiliates and other contributors 
 * as indicated by the @authors tag. All rights reserved. 
 * See the copyright.txt in the distribution for a 
 * full listing of individual contributors. 
 * 
 * This copyrighted material is made available to anyone wishing to use, 
 * modify, copy, or redistribute it subject to the terms and conditions 
 * of the GNU Lesser General Public License, v. 2.1. 
 * This program is distributed in the hope that it will be useful, but WITHOUT A 
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A 
 * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details. 
 * You should have received a copy of the GNU Lesser General Public License, 
 * v.2.1 along with this distribution; if not, write to the Free Software 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
 * MA  02110-1301, USA. 
 */
package org.hibernate.ogm.jpa.impl; 
 
import java.util.Map; 
import javax.persistence.EntityManager; 
import javax.persistence.EntityManagerFactory; 
import javax.persistence.EntityTransaction; 
import javax.persistence.FlushModeType; 
import javax.persistence.LockModeType; 
import javax.persistence.Query; 
import javax.persistence.TypedQuery; 
import javax.persistence.criteria.CriteriaBuilder; 
import javax.persistence.criteria.CriteriaQuery; 
import javax.persistence.metamodel.Metamodel; 
 
import org.hibernate.HibernateException; 
import org.hibernate.Session; 
import org.hibernate.SessionFactory; 
import org.hibernate.ejb.HibernateEntityManagerFactory; 
import org.hibernate.engine.spi.SessionFactoryImplementor; 
import org.hibernate.engine.spi.SessionImplementor; 
import org.hibernate.event.spi.EventSource; 
import org.hibernate.ogm.exception.NotSupportedException; 
import org.hibernate.ogm.hibernatecore.impl.OgmSession; 
import org.hibernate.ogm.hibernatecore.impl.OgmSessionFactory; 
 
/**
 * Delegates most method calls to the underlying EntityManager 
 * however, queries are handled differently 
 * 
 * @author Emmanuel Bernard <[email protected]
 */
 
public class OgmEntityManager implements EntityManager { 
 private final EntityManager hibernateEm; 
 private final OgmEntityManagerFactory factory; 
 
 public OgmEntityManager(OgmEntityManagerFactory factory, EntityManager hibernateEm) { 
  this.hibernateEm = hibernateEm; 
  this.factory = factory; 
 
 
 @Override 
 public void persist(Object entity) { 
  hibernateEm.persist( entity ); 
 
 
 @Override 
 public <T> T merge(T entity) { 
  return hibernateEm.merge( entity ); 
 
 
 @Override 
 public void remove(Object entity) { 
  hibernateEm.remove( entity ); 
 
 
 @Override 
 public <T> T find(Class<T> entityClass, Object primaryKey) { 
  return hibernateEm.find( entityClass, primaryKey ); 
 
 
 @Override 
 public <T> T find(Class<T> entityClass, Object primaryKey, Map<String, Object> properties) { 
  return hibernateEm.find( entityClass, primaryKey, properties ); 
 
 
 @Override 
 public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode) { 
  return hibernateEm.find( entityClass, primaryKey, lockMode ); 
 
 
 @Override 
 public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode, Map<String, Object> properties) { 
  return hibernateEm.find( entityClass, primaryKey, lockMode, properties ); 
 
 
 @Override 
 public <T> T getReference(Class<T> entityClass, Object primaryKey) { 
  return hibernateEm.getReference( entityClass, primaryKey ); 
 
 
 @Override 
 public void flush() { 
  hibernateEm.flush(); 
 
 
 @Override 
 public void setFlushMode(FlushModeType flushMode) { 
  hibernateEm.setFlushMode( flushMode ); 
 
 
 @Override 
 public FlushModeType getFlushMode() { 
  return hibernateEm.getFlushMode(); 
 
 
 @Override 
 public void lock(Object entity, LockModeType lockMode) { 
  hibernateEm.lock( entity, lockMode ); 
 
 
 @Override 
 public void lock(Object entity, LockModeType lockMode, Map<String, Object> properties) { 
  hibernateEm.lock( entity, lockMode, properties ); 
 
 
 @Override 
 public void refresh(Object entity) { 
  hibernateEm.refresh( entity ); 
 
 
 @Override 
 public void refresh(Object entity, Map<String, Object> properties) { 
  hibernateEm.refresh( entity, properties ); 
 
 
 @Override 
 public void refresh(Object entity, LockModeType lockMode) { 
  hibernateEm.refresh( entity, lockMode ); 
 
 
 @Override 
 public void refresh(Object entity, LockModeType lockMode, Map<String, Object> properties) { 
  hibernateEm.refresh( entity, lockMode, properties ); 
 
 
 @Override 
 public void clear() { 
  hibernateEm.clear(); 
 
 
 @Override 
 public void detach(Object entity) { 
  hibernateEm.detach( entity ); 
 
 
 @Override 
 public boolean contains(Object entity) { 
  return hibernateEm.contains( entity ); 
 
 
 @Override 
 public LockModeType getLockMode(Object entity) { 
  return hibernateEm.getLockMode( entity ); 
 
 
 @Override 
 public void setProperty(String propertyName, Object value) { 
  hibernateEm.setProperty( propertyName, value ); 
 
 
 @Override 
 public Map<String, Object> getProperties() { 
  return hibernateEm.getProperties(); 
 
 
 @Override 
 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 
   return new LetThroughExecuteUpdateQuery(); 
  
  throw new NotSupportedException( "OGM-21""JP-QL queries are not supported yet" ); 
 
 
 @Override 
 public <T> TypedQuery<T> createQuery(CriteriaQuery<T> criteriaQuery) { 
  throw new NotSupportedException( "OGM-8""criteria queries are not supported yet" ); 
 
 
 @Override 
 public <T> TypedQuery<T> createQuery(String qlString, Class<T> resultClass) { 
  throw new NotSupportedException( "OGM-14""typed queries are not supported yet" ); 
 
 
 @Override 
 public Query createNamedQuery(String name) { 
  throw new NotSupportedException( "OGM-15""named queries are not supported yet" ); 
 
 
 @Override 
 public <T> TypedQuery<T> createNamedQuery(String name, Class<T> resultClass) { 
  throw new NotSupportedException( "OGM-14""typed queries are not supported yet" ); 
 
 
 @Override 
 public Query createNativeQuery(String sqlString) { 
  throw new IllegalStateException( "Hibernate OGM does not support native queries" ); 
 
 
 @Override 
 public Query createNativeQuery(String sqlString, Class resultClass) { 
  throw new IllegalStateException( "Hibernate OGM does not support native queries" ); 
 
 
 @Override 
 public Query createNativeQuery(String sqlString, String resultSetMapping) { 
  throw new IllegalStateException( "Hibernate OGM does not support native queries" ); 
 
 
 @Override 
 public void joinTransaction() { 
  hibernateEm.joinTransaction(); 
 
 
 @Override 
 public <T> T unwrap(Class<T> cls) { 
  final T session = hibernateEm.unwrap( cls ); 
  if ( Session.class.isAssignableFrom( cls ) || SessionImplementor.class.isAssignableFrom( cls ) ) { 
   return (T) buildOgmSession( ( EventSource ) session ); 
  
  throw new HibernateException( "Cannot unwrap the following type: " + cls ); 
 
 
 private OgmSession buildOgmSession(Session session) { 
  final SessionFactory sessionFactory = ( ( HibernateEntityManagerFactory ) hibernateEm.getEntityManagerFactory() ) 
    .getSessionFactory(); 
  final OgmSessionFactory ogmSessionFactory = new OgmSessionFactory( ( SessionFactoryImplementor ) sessionFactory ); 
  return new OgmSession( ogmSessionFactory, (EventSource) session ); 
 
 
 @Override 
 public Object getDelegate() { 
  final Object delegate = hibernateEm.getDelegate(); 
  if ( Session.class.isAssignableFrom( delegate.getClass() ) ) { 
   return buildOgmSession( ( EventSource ) delegate ); 
  
  else { 
   return delegate; 
  
 
 
 @Override 
 public void close() { 
  hibernateEm.close(); 
 
 
 @Override 
 public boolean isOpen() { 
  return hibernateEm.isOpen(); 
 
 
 @Override 
 public EntityTransaction getTransaction() { 
  return hibernateEm.getTransaction(); 
 
 
 @Override 
 public EntityManagerFactory getEntityManagerFactory() { 
  return factory; 
 
 
 @Override 
 public CriteriaBuilder getCriteriaBuilder() { 
  return hibernateEm.getCriteriaBuilder(); 
 
 
 @Override 
 public Metamodel getMetamodel() { 
  return hibernateEm.getMetamodel(); 
 
 
 
}