395 lines
11 KiB
Plaintext
Executable File
395 lines
11 KiB
Plaintext
Executable File
package com.fp.persistence.commondb;
|
|
|
|
import java.math.BigDecimal;
|
|
import java.sql.Date;
|
|
import java.sql.SQLException;
|
|
import java.sql.Timestamp;
|
|
import java.text.ParseException;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import javax.persistence.EntityManager;
|
|
import javax.persistence.NoResultException;
|
|
import javax.persistence.Parameter;
|
|
import javax.persistence.Query;
|
|
|
|
import org.apache.log4j.Logger;
|
|
import org.hibernate.HibernateException;
|
|
|
|
import com.fp.common.exception.CommonException;
|
|
import com.fp.common.logger.APPLogger;
|
|
import com.fp.dto.hb.Log;
|
|
import com.fp.persistence.commondb.exception.CommondbException;
|
|
|
|
/**
|
|
* @author jorge
|
|
*
|
|
*/
|
|
public class HqlStatement {
|
|
|
|
/**
|
|
* Map auxiliar empleado para el manejo de Parametros
|
|
*/
|
|
private Map<String, Object> map;
|
|
|
|
/**
|
|
* Sentencia HQL a ejecutar
|
|
*/
|
|
private String sentence;
|
|
|
|
/**
|
|
* EntityManager de hibernate empleada en la consulta
|
|
*/
|
|
private EntityManager em;
|
|
|
|
/**
|
|
* Indicador de si la consulta requiere manejar Cache
|
|
*/
|
|
private boolean cacheAbled = false;
|
|
|
|
/**
|
|
* Indicador de si la consulta es de Lectura solamente
|
|
*/
|
|
private boolean readonly = false;
|
|
|
|
/**
|
|
* Pagina en la que se encuentra la consulta
|
|
*/
|
|
private Integer page = null;
|
|
|
|
/**
|
|
* Numero de registros por pagina
|
|
*/
|
|
private Integer recordperpage = null;
|
|
|
|
private Integer i = null;
|
|
|
|
/**
|
|
* Referencia al Log
|
|
*/
|
|
private Logger log = APPLogger.getLogger();
|
|
|
|
/**
|
|
* Entrega el valor de page.
|
|
*
|
|
* @return page.
|
|
*/
|
|
public Integer getPage() {
|
|
return this.page;
|
|
}
|
|
|
|
/**
|
|
* Fija el valor de page.
|
|
*
|
|
* @param pPage.
|
|
*/
|
|
public void setPage(Integer pPage) {
|
|
this.page = pPage;
|
|
}
|
|
|
|
/**
|
|
* Entrega el valor de recordperpage.
|
|
*
|
|
* @return recordperpage.
|
|
*/
|
|
public Integer getRecordperpage() {
|
|
return this.recordperpage;
|
|
}
|
|
|
|
/**
|
|
* Fija el valor de recordperpage.
|
|
*
|
|
* @param pRecordperpage.
|
|
*/
|
|
public void setRecordperpage(Integer pRecordperpage) {
|
|
this.recordperpage = pRecordperpage;
|
|
}
|
|
|
|
/**
|
|
* Crea una nueva instancia de UtilHB
|
|
*
|
|
* @throws CommonException
|
|
*
|
|
*/
|
|
public HqlStatement() throws CommondbException {
|
|
this(null);
|
|
}
|
|
|
|
/**
|
|
* Crea una nueva instancia con una sentencia a ejecutar.
|
|
*
|
|
* @param pSentence Sentencia a ejecutar
|
|
* @param pLockMode Tipo de Bloqueo Pesismista
|
|
* @param pLocktime Tiempo de espera para un bloqueo pesimista.
|
|
* @throws CommonException
|
|
* @throws Exception
|
|
*/
|
|
public HqlStatement(String pSentence) throws CommondbException {
|
|
this.sentence = pSentence;
|
|
this.map = new HashMap<String, Object>();
|
|
this.em = PersistenceHelper.getEntityManager();
|
|
}
|
|
|
|
/**
|
|
* Fija un criterio string de la sentencia. El nombre del parametro debe ser igual al del where de la sentencia.
|
|
*
|
|
* @param pParameter
|
|
* @param pString
|
|
*/
|
|
public void setString(String pParameter, String pString) {
|
|
this.map.put(pParameter, pString);
|
|
}
|
|
|
|
/**
|
|
* Fija un criterio Data a la sentencia. El nombre del parametro debe ser igual al del where de la sentencia.
|
|
*
|
|
* @param pParameter
|
|
* @param pDate
|
|
*/
|
|
public void setDate(String pParameter, Date pDate) {
|
|
this.map.put(pParameter, pDate);
|
|
}
|
|
|
|
/**
|
|
* Fija un criterio Timestamp a la sentencia. El nombre del parametro debe ser igual al del where de la sentencia.
|
|
*
|
|
* @param pParameter
|
|
* @param pTimestamp
|
|
*/
|
|
public void setTimestamp(String pParameter, Timestamp pTimestamp) {
|
|
this.map.put(pParameter, pTimestamp);
|
|
}
|
|
|
|
/**
|
|
* Fija un criterio Integer a la sentencia. El nombre del parametro debe ser igual al del where de la sentencia.
|
|
*
|
|
* @param pParameter
|
|
* @param pInteger
|
|
*/
|
|
public void setInteger(String pParameter, Integer pInteger) {
|
|
if (pInteger == null) {
|
|
this.map.put(pParameter, Integer.class);
|
|
} else {
|
|
this.map.put(pParameter, pInteger);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Fija un criterio Long a la sentencia. El nombre del parametro debe ser igual al del where de la sentencia.
|
|
*
|
|
* @param pParameter
|
|
* @param pLong
|
|
*/
|
|
public void setLong(String pParameter, Long pLong) {
|
|
if (pLong == null) {
|
|
this.map.put(pParameter, Long.class);
|
|
} else {
|
|
this.map.put(pParameter, pLong);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fija un criterio BigDecimal a la sentencia. El nombre del parametro debe ser igual al del where de la sentencia.
|
|
*
|
|
* @param pParameter
|
|
* @param pBigdecimal
|
|
*/
|
|
public void setBigDecimal(String pParameter, BigDecimal pBigdecimal) {
|
|
if (pBigdecimal == null) {
|
|
this.map.put(pParameter, BigDecimal.class);
|
|
} else {
|
|
this.map.put(pParameter, pBigdecimal);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Setea valores de parametros definidos previamente en una sentencia.
|
|
*
|
|
* @param pMparamters Map con el nombre del parametro y el valor del mismo.
|
|
* @throws Exception
|
|
*/
|
|
public void setParametersValue(Map<String, Object> pMparamters) {
|
|
Iterator<String> itr = pMparamters.keySet().iterator();
|
|
while (itr.hasNext()) {
|
|
String key = itr.next();
|
|
Object value = pMparamters.get(key);
|
|
if (value instanceof String) {
|
|
this.setString(key, (String) value);
|
|
}
|
|
if (value instanceof Integer) {
|
|
this.setInteger(key, (Integer) value);
|
|
}
|
|
if (value instanceof Long) {
|
|
this.setLong(key, (Long) value);
|
|
}
|
|
if (value instanceof BigDecimal) {
|
|
this.setBigDecimal(key, (BigDecimal) value);
|
|
}
|
|
if (value instanceof Date) {
|
|
this.setDate(key, (Date) value);
|
|
}
|
|
if (value instanceof Timestamp) {
|
|
this.setTimestamp(key, (Timestamp) value);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retorna: un entity si la sentencia retorna un entity, si es un conjunto de campos de una o mas tablas retorna un
|
|
* Array.
|
|
* <ol>
|
|
* <li>Objeto que contiene una entidad si la sentencia retorna un entity <br>
|
|
* sentencia ==> from com.test.Test as t where t.pk.c1 = :valor1</li>
|
|
* <li>Array que contiene una entidad si la sentencia retorna mas de un campo <br>
|
|
* sentencia ==> select t.c1,t.c2...t.c3 from com.test.Test as t</li>
|
|
* <li>Array que contiene una entidades o campos cuando existe junturas. sentencia ==> from com.test.Test a,from
|
|
* com.test.Testuno b where a.pk=b.pk and b.pk.lenguage = 'ES'</li>
|
|
* </ol>
|
|
*
|
|
* @return
|
|
* @throws CommonException
|
|
* @throws HibernateException
|
|
* @throws ParseException
|
|
* @throws Exception
|
|
*/
|
|
public Object getObject() throws HibernateException, CommondbException, ParseException, SQLException, Exception {
|
|
Object obj = null;
|
|
try {
|
|
obj = this.execute().getSingleResult();
|
|
} catch (NoResultException e) {
|
|
return obj;
|
|
}
|
|
if (this.readonly) {
|
|
this.em.detach(obj);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public <T> T getObject(@SuppressWarnings("unused")
|
|
Class<T> pType) throws HibernateException, CommondbException, ParseException, SQLException, Exception {
|
|
T obj = null;
|
|
try {
|
|
obj = (T) this.execute().getSingleResult();
|
|
} catch (NoResultException e) {
|
|
return obj;
|
|
}
|
|
if (this.readonly) {
|
|
this.em.detach(obj);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* Ejecuta una sentencia.
|
|
*
|
|
* @return
|
|
* @throws CommonException
|
|
* @throws ParseException
|
|
* @throws Exception
|
|
*/
|
|
@SuppressWarnings("rawtypes")
|
|
public Query execute() throws CommondbException, ParseException, Exception {
|
|
if (this.sentence == null) {
|
|
throw new CommondbException("COMMONDB-0007", "SENTENCIA INVALIDA");
|
|
}
|
|
// Query qry=(QueryImpl)em.createQuery(sentence);
|
|
APPLogger.getLogger().debug("Sentencia ==> " + this.sentence);
|
|
Query qry = this.em.createQuery(this.sentence);
|
|
Set<Parameter<?>> param = qry.getParameters();
|
|
// String[]param=qry.getNamedParameters();
|
|
for (Parameter par : param) {
|
|
String parameter = par.getName();
|
|
Object obj = this.map.get(parameter);
|
|
if (obj == null) {
|
|
throw new CommondbException("COMMONDB-0008", "VALOR NO ENVIADO {0}", parameter);
|
|
}
|
|
qry.setParameter(parameter, obj);
|
|
}
|
|
if ((this.page != null) && (this.recordperpage != null) && (this.page >= 0) && (this.recordperpage > 0)) {
|
|
if (this.page > 1) {
|
|
qry.setFirstResult((this.page - 1) * this.recordperpage);
|
|
}
|
|
qry.setMaxResults(this.recordperpage);
|
|
}
|
|
return qry;
|
|
}
|
|
|
|
/**
|
|
* Fija una sentencia a ejecutar.
|
|
*
|
|
* @param pSentence
|
|
*/
|
|
public void setSentence(String pSentence) {
|
|
this.map.clear();
|
|
this.sentence = pSentence;
|
|
}
|
|
|
|
/**
|
|
* Entrega la sentencia a ejecutar.
|
|
*
|
|
* @return
|
|
*/
|
|
public String getSentence() {
|
|
return this.sentence;
|
|
}
|
|
|
|
/**
|
|
* Marca la setencia para cache.
|
|
*
|
|
* @param cacheAbled
|
|
*/
|
|
public void setCacheAbled(boolean cacheAbled) {
|
|
this.cacheAbled = cacheAbled;
|
|
}
|
|
|
|
/**
|
|
* Indica si la sentencia esta marcada para cache.
|
|
*
|
|
* @return
|
|
*/
|
|
public boolean isCacheAbled() {
|
|
return this.cacheAbled;
|
|
}
|
|
|
|
/**
|
|
* Fija la sentencia en readonly.
|
|
*
|
|
* @param readonly
|
|
*/
|
|
public void setReadonly(boolean readonly) {
|
|
this.readonly = readonly;
|
|
}
|
|
|
|
/**
|
|
* Indica si la sentencia a ejecutar es solo de lectura.
|
|
*
|
|
* @return
|
|
*/
|
|
public boolean isReadonly() {
|
|
return this.readonly;
|
|
}
|
|
|
|
/**
|
|
* Entrega el valor de: i
|
|
*
|
|
* @return Integer
|
|
*/
|
|
public Integer getI() {
|
|
return this.i;
|
|
}
|
|
|
|
/**
|
|
* Fija el valor de: i
|
|
*
|
|
* @param i value to set
|
|
*/
|
|
public void setI(Integer i) {
|
|
this.i = i;
|
|
}
|
|
|
|
}
|