Dao.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package  org.turro.jpa;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.LockModeType;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceUnitUtil;
import javax.persistence.Query;
import org.amic.util.string.MatchReplacer;
import org.turro.annotation.ElephantDao;
import org.turro.elephant.db.WhereClause;
import org.turro.jpa.entity.IDaoEntity;
import org.turro.jpa.query.AbstractJpaQuery;
import org.turro.jpa.query.JpaCriteriaDelete;
import org.turro.jpa.query.JpaCriteriaUpdate;
import org.turro.jpa.query.JpaQuery;
import org.turro.jpa.stream.DaoStream;
import org.turro.reflection.ClassNames;
import org.turro.reflection.Reflections;
import org.turro.sql.IDao;
import org.turro.sql.SqlClause;
 
public abstract class Dao implements IDao {
  
  //private final EntityManager em;
  
  public Dao() {
    //em = createEntityManager();
  }  
 
  @Deprecated
  public Query createQuery(String query) {
    return getEntityManager().createQuery(query);
  }
 
  @Deprecated
  public Query createNamedQuery(String name) {
    return getEntityManager().createNamedQuery(name);
  }
          
  @Deprecated
  public void close() {
//    if(em != null && em.isOpen()) {
//      em.close();
//    }
  }
  
  @Deprecated
  public Dao clear() {
//    if(em != null) {
//      em.clear();
//    }
    return this;
  }
  
  public <T> T find(Class<T> javaClass, Object arg) {
    T t = null;
    if(arg != null) {
      try(DaoManager manager = new DaoManager(this)) {
        t = manager.find(javaClass, arg);
      }
    }
    return t;
  }
          
  public <T> T find(Class<T> javaClass, Object arg, DaoCallback callback) {
    T t = null;
    if(arg != null) {
      try(DaoTransaction transaction = new DaoTransaction(this)) {
        if(callback != null) {
          callback.before(null);
        }
        t = transaction.find(javaClass, arg);
        if(callback != null) {
          callback.after(null, t);
        }
      }
    }
    return t;
  }
  
  public <T> T saveObject(T obj) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      return transaction.saveObject(obj);
    }
  }
  
  public <T extends IDaoEntity> T saveEntity(T entity) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      if(!entity.isEmpty()) {
        entity.prepareSave();
        return transaction.saveObject(entity);
      }
      return entity;
    }
  }
  
  public void persistObject(Object obj) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      transaction.persist(obj);
    }
  }
 
  public void saveEntities(Collection<? extends IDaoEntity> entities) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      for(IDaoEntity entity : entities) {
        if(!entity.isEmpty()) {
          entity.prepareSave();
          transaction.saveObject(entity);
        }
      }
    }
  }
  
  public void saveCollection(Collection objs) {
    saveCollection(objs, null);
  }
  
  public void saveCollection(Collection objs, DaoCallback callback) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      for(Object obj : objs) {
        if(callback != null) {
          callback.before(obj);
        }
        Object newObj = transaction.saveObject(obj);
        if(callback != null) {
          callback.after(obj, newObj);
        }
      }
    }
  }
  
  public void deleteObject(Object obj) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      transaction.remove(transaction.saveObject(obj));
    }
  }
 
  public void deleteEntity(IDaoEntity entity) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      entity.prepareDelete();
      transaction.remove(transaction.saveObject(entity));
    }
  }
 
  public void deleteCollection(Collection objs) {
    deleteCollection(objs, null);
  }
  
  public void deleteCollection(Collection objs, DaoCallback callback) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      for(Object obj : objs) {
        if(callback != null) {
          callback.before(obj);
        }
        transaction.remove(transaction.saveObject(obj));
        if(callback != null) {
          callback.after(obj, null);
        }
      }
    }
  }
  
  public void deleteEntities(Collection<IDaoEntity> entities) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      for(IDaoEntity entity : entities) {
        entity.prepareDelete();
        transaction.remove(transaction.saveObject(entity));
      }
    }
  }
  
  public EntityManager getEntityManager() {
    return null;
  }
 
  @Deprecated
  public EntityManager getCachedEntityManager() {
    return createCachedEntityManager();
  }
 
  public boolean isLoaded(Object o, String attribute) {
    PersistenceUnitUtil puu = getFactory().getPersistenceUnitUtil();
    return puu.isLoaded(o, attribute);
  }
 
  public boolean isNotLoaded(Object o, String attribute) {
    return !isLoaded(o, attribute);
  }
  
  public boolean isLoaded(Object o) {
    PersistenceUnitUtil puu = getFactory().getPersistenceUnitUtil();
    return puu.isLoaded(o);
  }
 
  public boolean isNotLoaded(Object o) {
    return !isLoaded(o);
  }
  
  public <T> List<T> getResultList(JpaQuery<T> jpaQuery) {
    return getResultList(jpaQuery, -1, -1);
  }
  
  public <T> List<T> getResultList(JpaQuery<T> jpaQuery, int max) {
    return getResultList(jpaQuery, -1, max);
  }
  
  public <T> List<T> getResultList(JpaQuery<T> jpaQuery, int start, int max) {
    if(jpaQuery == null) return Collections.EMPTY_LIST;
    try(DaoManager manager = new DaoManager(this)) {
      Query q = manager.createQuery(jpaQuery.query());
      q.setLockMode(LockModeType.NONE);
      if(start > 0) q.setFirstResult(start);
      if(max > 0) q.setMaxResults(max);
      return q.getResultList();
    }
  }
  
  public <T> List<T> getResultList(Class<T> javaClass, String query) {
    WhereClause wc = new WhereClause();
    wc.addClause(query);
    return getResultList(javaClass, wc, -1, -1);
  }
  
  public <T> List<T> getResultList(Class<T> javaClass, String query, int max) {
    WhereClause wc = new WhereClause();
    wc.addClause(query);
    return getResultList(javaClass, wc, -1, max);
  }
  
  public <T> List<T> getResultList(Class<T> javaClass, String query, int start, int max) {
    WhereClause wc = new WhereClause();
    wc.addClause(query);
    return getResultList(javaClass, wc, start, max);
  }
  
  public <T> List<T> getResultList(Class<T> javaClass, WhereClause wc) {
    return getResultList(javaClass, wc, -1, -1);
  }
  
  public <T> List<T> getResultList(Class<T> javaClass, WhereClause wc, int max) {
    return getResultList(javaClass, wc, -1, max);
  }
  
  public <T> List<T> getResultList(Class<T> javaClass, WhereClause wc, int start, int max) {
    if(wc == null) return Collections.EMPTY_LIST;
    try(DaoManager manager = new DaoManager(this)) {
      Query q = manager.createQuery(wc.getClause(), javaClass);
      q.setLockMode(LockModeType.NONE);
      wc.setNamedParameters(q);
      if(start > 0) q.setFirstResult(start);
      if(max > 0) q.setMaxResults(max);
      return q.getResultList();
    }
  }
  
  @Override
  public <T> List<T> getResultList(Class<T> javaClass, SqlClause sc) {
    return getResultList(javaClass, sc, -1, -1);
  }
  
  @Override
  public <T> List<T> getResultList(Class<T> javaClass, SqlClause sc, int max) {
    return getResultList(javaClass, sc, -1, max);
  }
  
  @Override
  public <T> List<T> getResultList(Class<T> javaClass, SqlClause sc, int start, int max) {
    if(sc == null) return Collections.EMPTY_LIST;
    try(DaoManager manager = new DaoManager(this)) {
      Query q = manager.createQuery(sc.clause(), javaClass);
      q.setLockMode(LockModeType.NONE);
      manager.setNamedParameters(q, sc.getNamedValues());
      if(start > 0) q.setFirstResult(start);
      if(max > 0) q.setMaxResults(max);
      return q.getResultList();
    }
  }
  
  public List getResultList(WhereClause wc) {
    return getResultList(wc, -1, -1);
  }
  
  public List getResultList(WhereClause wc, int max) {
    return getResultList(wc, -1, max);
  }
  
  public List getResultList(WhereClause wc, int start, int max) {
    if(wc == null) return Collections.EMPTY_LIST;
    try(DaoManager manager = new DaoManager(this)) {
      Query q = wc.isUseNative() ? 
              manager.createNativeQuery(wc.getClause(), wc.getResultClass()) :
              manager.createQuery(wc.getClause());
      if(!wc.isUseNative()) q.setLockMode(LockModeType.NONE);
      wc.setNamedParameters(q);
      if(start > 0) q.setFirstResult(start);
      if(max > 0) q.setMaxResults(max);
      return q.getResultList();
    }
  }
  
  @Override
  public List getResultList(SqlClause sc) {
    return getResultList(sc, -1, -1);
  }
  
  @Override
  public List getResultList(SqlClause sc, int max) {
    return getResultList(sc, -1, max);
  }
  
  @Override
  public List getResultList(SqlClause sc, int start, int max) {
    if(sc == null) return Collections.EMPTY_LIST;
    try(DaoManager manager = new DaoManager(this)) {
      Query q = manager.createQuery(sc.clause());
      q.setLockMode(LockModeType.NONE);
      manager.setNamedParameters(q, sc.getNamedValues());
      if(start > 0) q.setFirstResult(start);
      if(max > 0) q.setMaxResults(max);
      return q.getResultList();
    }
  }
  
  public List getResultList(String query) {
    return getResultList(query, null);
  }
  
  public List getResultList(String query, int max) {
    return getResultList(query, null, max);
  }
  
  public List getResultList(String query, Object[] pars) {
    return getResultList(query, pars, -1);
  }
  
  public List getResultList(String query, Object[] pars, int max) {
    try(DaoManager manager = new DaoManager(this)) {
      Query q = manager.createQuery(toJpaPositional(query));
      q.setLockMode(LockModeType.NONE);
      if(max > 0) q.setMaxResults(max);
      if(pars != null) {
        for(int i = 0; i < pars.length; i++) {
          q.setParameter(i + 1, pars[i]);
        }
      }
      return q.getResultList();
    }
  }
 
  public Object getSingleResult(WhereClause wc) {
    try(DaoManager manager = new DaoManager(this)) {
      Query q = wc.isUseNative() ? 
              manager.createNativeQuery(wc.getClause()) : 
              manager.createQuery(wc.getClause());
      if(!wc.isUseNative()) q.setLockMode(LockModeType.NONE);
      wc.setNamedParameters(q);
      return q.getSingleResult();
    }
  }
  
  @Override
  public Object getSingleResult(SqlClause sc) {
    try(DaoManager manager = new DaoManager(this)) {
      Query q = manager.createQuery(sc.clause());
      q.setLockMode(LockModeType.NONE);
      manager.setNamedParameters(q, sc.getNamedValues());
      return q.getSingleResult();
    }
  }
  
  public Object getSingleResult(String query) {
    return getSingleResult(query, null);
  }
 
  public Object getSingleResult(String query, Object[] pars) {
    try(DaoManager manager = new DaoManager(this)) {
      Query q = manager.createQuery(toJpaPositional(query));
      q.setLockMode(LockModeType.NONE);
      if(pars != null) {
        for(int i = 0; i < pars.length; i++) {
          q.setParameter(i + 1, pars[i]);
        }
      }
      return q.getSingleResult();
    }
  }
 
  @Override
  public Object getSingleResultOrNull(SqlClause sc) {
    try {
      return getSingleResult(sc);
    } catch(NoResultException ex) {
      return null;
    }
  }
 
  public Object getSingleResultOrNull(WhereClause wc) {
    try {
      return getSingleResult(wc);
    } catch(NoResultException ex) {
      return null;
    }
  }
 
  public Object getSingleResultOrNull(String query) {
    return getSingleResultOrNull(query, null);
  }
 
  public Object getSingleResultOrNull(String query, Object[] pars) {
    try {
      return getSingleResult(query, pars);
    } catch(NoResultException ex) {
      return null;
    }
  }
 
  public Object getSingleNativeResult(String query) {
    return getSingleNativeResult(query, null);
  }
 
  public Object getSingleNativeResult(String query, Object[] pars) {
    try(DaoManager manager = new DaoManager(this)) {
      Query q = manager.createNativeQuery(toJpaPositional(query));
      if(pars != null) {
        for(int i = 0; i < pars.length; i++) {
          q.setParameter(i + 1, pars[i]);
        }
      }
      return q.getSingleResult();
    }
  }
 
  public int executeUpdate(String query) {
    return executeUpdate(query, null);
  }
 
  public int executeUpdate(String query, Object[] pars) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      Query q = transaction.createQuery(toJpaPositional(query));
      if(pars != null) {
        for(int i = 0; i < pars.length; i++) {
          q.setParameter(i + 1, pars[i]);
        }
      }
      int res = q.executeUpdate();
      return res;
    }
  }
 
  public int executeDelete(JpaCriteriaDelete jpaCriteriaDelete) {
    List<JpaCriteriaDelete> list = new ArrayList<>();
    list.add(jpaCriteriaDelete);
    return executeDelete(list);
  }
  
  public int executeDelete(Collection<JpaCriteriaDelete> jpaCriteriaDeletes) {
    if(jpaCriteriaDeletes == null || jpaCriteriaDeletes.isEmpty()) return 0;
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      int res = 0;
      for(JpaCriteriaDelete jpaCriteriaDelete : jpaCriteriaDeletes) {
        Query q = transaction.createQuery(jpaCriteriaDelete.delete());
        res += q.executeUpdate();
      }
      return res;
    }
  }
  
  public int executeUpdate(JpaCriteriaUpdate jpaCriteriaUpdate) {
    List<JpaCriteriaUpdate> list = new ArrayList<>();
    list.add(jpaCriteriaUpdate);
    return executeUpdate(list);
  }
  
  public int executeUpdate(Collection<JpaCriteriaUpdate> jpaCriteriaUpdates) {
    if(jpaCriteriaUpdates == null || jpaCriteriaUpdates.isEmpty()) return 0;
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      int res = 0;
      for(JpaCriteriaUpdate jpaCriteriaUpdate : jpaCriteriaUpdates) {
        Query q = transaction.createQuery(jpaCriteriaUpdate.update());
        res += q.executeUpdate();
      }
      return res;
    }
  }
  
  public int executeUpdate(WhereClause wc) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      Query q = transaction.createQuery(wc.getClause());
      wc.setNamedParameters(q);
      int res = q.executeUpdate();
      return res;
    }
  }
  
  @Override
  public int executeUpdate(SqlClause sc) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      Query q = transaction.createQuery(sc.clause());
      transaction.setNamedParameters(q, sc.getNamedValues());
      int res = q.executeUpdate();
      return res;
    }
  }
 
  @Override
  public int executeNativeUpdate(SqlClause sc, Object... pars) {
    return executeNativeUpdate(sc.clause(), pars);
  }
 
  public int executeNativeUpdate(String query, Object... pars) {
    try(DaoTransaction transaction = new DaoTransaction(this)) {
      Query q = transaction.createNativeQuery(toJpaPositional(query));
      if(pars != null) {
        for(int i = 0; i < pars.length; i++) {
          q.setParameter(i + 1, pars[i]);
        }
      }
      int res = q.executeUpdate();
      return res;
    }
  }
 
  protected abstract EntityManagerFactory getFactory();
  protected abstract EntityManager createEntityManager();
  public abstract String getPath(Object object);
 
  @Deprecated
  protected abstract EntityManager createCachedEntityManager();
 
  public <T> T lazyLoader(Class<T> javaClass, Object proxy, String property) {
    return (T) getSingleResult(
              "select c from " + javaClass.getSimpleName() + 
              " c left join fetch c." + property + " where c = ?",
              new Object[] { proxy });
  }
 
  public static String toJpaPositional(String query) {
    MatchReplacer replacer = new MatchReplacer(Pattern.compile("\\?")) {
      int i = 1;
      @Override public String replacement(MatchResult m) { 
        return "$0" + i++;
      }
    };
    return replacer.replace(query);
  }
 
  /* Pool objects */
  
  private Collection pool;
  
  public void poolObject(Object obj, int poolSize) {
    if(pool == null) {
      pool = new ArrayList();
    }
    pool.add(obj);
    if(pool.size() >= poolSize) {
      saveCollection(pool);
      pool.clear();
    }
  }
  
  public void finishPool() {
    if(pool != null && pool.size() > 0) {
      saveCollection(pool);
    }
    pool = null;
  }
  
  
  /* Streams */
  
  public <T> Stream<T> stream(Class<T> javaClass, String query) {
    return new DaoStream<T>(this, query).stream();
  }
  
  public <T> Stream<T> stream(Class<T> javaClass, String query, int bacthSize) {
    return new DaoStream<T>(this, query).stream(bacthSize);
  }
  
  public <T> Stream<T> stream(Class<T> javaClass, WhereClause wc) {
    return new DaoStream<T>(this, wc).stream();
  }
  
  public <T> Stream<T> stream(Class<T> javaClass, WhereClause wc, int bacthSize) {
    return new DaoStream<T>(this, wc).stream(bacthSize);
  }
  
  @Override
  public <T> Stream<T> stream(Class<T> javaClass, SqlClause sc) {
    return new DaoStream<T>(this, sc).stream();
  }
  
  public <T> Stream<T> stream(Class<T> javaClass, SqlClause sc, int bacthSize) {
    return new DaoStream<T>(this, sc).stream(bacthSize);
  }
  
  public <T> Stream<T> stream(Class<T> javaClass, AbstractJpaQuery<T> query) {
    return new DaoStream<>(this, query).stream();
  }
  
  public <T> Stream<T> stream(Class<T> javaClass, AbstractJpaQuery<T> query, int bacthSize) {
    return new DaoStream<>(this, query).stream(bacthSize);
  }
  
  public <T> void forEach(Class<T> javaClass, String query, Consumer<T> action) {
    new DaoStream<T>(this, query).forEach(action);
  }
  
  public <T> void forEach(Class<T> javaClass, WhereClause wc, Consumer<T> action) {
    new DaoStream<T>(this, wc).forEach(action);
  }
  
  @Override
  public <T> void forEach(Class<T> javaClass, SqlClause sc, Consumer<T> action) {
    new DaoStream<T>(this, sc).forEach(action);
  }
  
  public <T> void forEach(Class<T> javaClass, AbstractJpaQuery<T> query, Consumer<T> action) {
    new DaoStream<>(this, query).forEach(action);
  }
  
  /* Elephant Daos */
  
  public static Dao getDaoByPU(String pu) {
    for(String className : ClassNames.cached().byAnnotation(ElephantDao.class.getName())) {
      Class javaClass = Reflections.of(className).is(Dao.class).returnClass();
      if(javaClass != null) {
        if(((ElephantDao) javaClass.getAnnotation(ElephantDao.class)).pu().equals(pu)) {
          return (Dao) Reflections.of(javaClass).instance();
        }
      }
    }
    return null;
  }
 
}