JPA getSingleResult () o nulo

Tengo un insertOrUpdatemétodo que inserta un Entitycuando no existe o lo actualizo si lo hace. Para habilitar esto, tengo que hacerlo findByIdAndForeignKey, si devuelve nullinsertar, si no, actualizar. El problema es cómo verifico si existe. Entonces lo intenté getSingleResult. Pero arroja una excepción si el

public Profile findByUserNameAndPropertyName(String userName, String propertyName) {
    String namedQuery = Profile.class.getSimpleName() + ".findByUserNameAndPropertyName";
    Query query = entityManager.createNamedQuery(namedQuery);
    query.setParameter("name", userName);
    query.setParameter("propName", propertyName);
    Object result = query.getSingleResult();
    if (result == null) return null;
    return (Profile) result;
}

pero getSingleResultlanza un Exception.

Gracias

Lanzar una excepción es cómo getSingleResult()indica que no se puede encontrar. Personalmente no soporto este tipo de API. Fuerza el manejo de excepciones espurias sin beneficio real. Solo tiene que envolver el código en un bloque try-catch.

Alternativamente, puede consultar una lista y ver si está vacía. Eso no arroja una excepción. En realidad, dado que técnicamente no está haciendo una búsqueda de clave primaria, podría haber múltiples resultados (incluso si uno, ambos o la combinación de sus claves externas o restricciones lo hacen imposible en la práctica), por lo que esta es probablemente la solución más adecuada.

Encapsulé la lógica en el siguiente método auxiliar.

public class JpaResultHelper {
    public static Object getSingleResultOrNull(Query query){
        List results = query.getResultList();
        if (results.isEmpty()) return null;
        else if (results.size() == 1) return results.get(0);
        throw new NonUniqueResultException();
    }
}

Prueba esto en Java 8:

Optional first = query.getResultList().stream().findFirst();

Aquí hay una buena opción para hacer esto:

public static <T> T getSingleResult(TypedQuery<T> query) {
    query.setMaxResults(1);
    List<T> list = query.getResultList();
    if (list == null || list.isEmpty()) {
        return null;
    }

    return list.get(0);
}

Spring tiene un método de utilidad para esto:

TypedQuery<Profile> query = em.createNamedQuery(namedQuery, Profile.class);
...
return org.springframework.dao.support.DataAccessUtils.singleResult(query.getResultList());

He hecho (en Java 8):

query.getResultList().stream().findFirst().orElse(null);

Desde JPA 2.2 , en lugar de .getResultList()verificar si la lista está vacía o crear una secuencia, puede devolver la secuencia y tomar el primer elemento.

.getResultStream()
.findFirst()
.orElse(null);

Si desea utilizar el mecanismo try / catch para manejar este problema ... entonces puede usarse para actuar como si / si no. Utilicé try / catch para agregar un nuevo registro cuando no encontré uno existente.

try {  //if part

    record = query.getSingleResult();   
    //use the record from the fetched result.
}
catch(NoResultException e){ //else part
    //create a new record.
    record = new Record();
    //.........
    entityManager.persist(record); 
}

Aquí hay una versión tipificada / genérica, basada en la implementación de Rodrigo IronMan:

 public static <T> T getSingleResultOrNull(TypedQuery<T> query) {
    query.setMaxResults(1);
    List<T> list = query.getResultList();
    if (list.isEmpty()) {
        return null;
    }
    return list.get(0);
}

Hay una alternativa que recomendaría:

Query query = em.createQuery("your query");
List<Element> elementList = query.getResultList();
return CollectionUtils.isEmpty(elementList ) ? null : elementList.get(0);

Esta protección contra la excepción de puntero nulo garantiza que solo se devuelva 1 resultado.

¡Entonces no hagas eso!

Tienes dos opciones:

1. Ejecute una selección para obtener el CONTEO de su conjunto de resultados y solo extraiga los datos si este conteo no es cero; o

2. Use el otro tipo de consulta (que obtiene un conjunto de resultados) y verifique si tiene 0 o más resultados. Debería tener 1, así que retíralo de tu colección de resultados y listo.

Me gustaría ir con la segunda sugerencia, de acuerdo con Cletus. Ofrece un mejor rendimiento que (potencialmente) 2 consultas. También menos trabajo.

Combinando los bits útiles de las respuestas existentes (limitando el número de resultados, verificando que el resultado sea único) y usando el nombre del método estabilshed (Hibernate), obtenemos:

/**
 * Return a single instance that matches the query, or null if the query returns no results.
 *
 * @param query query (required)
 * @param <T> result record type
 * @return record or null
 */
public static <T> T uniqueResult(@NotNull TypedQuery<T> query) {
    List<T> results = query.setMaxResults(2).getResultList();
    if (results.size() > 1) throw new NonUniqueResultException();
    return results.isEmpty() ? null : results.get(0);
}

El método no documentado uniqueResultOptionalen org.hibernate.query.Query debería hacer el truco. En lugar de tener que atrapar a un NoResultExceptionsolo puede llamar query.uniqueResultOptional().orElse(null).

Resolví esto usando List<?> myList = query.getResultList();y comprobando si myList.size()es igual a cero.

Aquí está la misma lógica que otros sugirieron (obtenga la lista de resultados, devuelva su único elemento o nulo), utilizando Google Guava y TypedQuery.

public static <T> getSingleResultOrNull(final TypedQuery<T> query) {
    return Iterables.getOnlyElement(query.getResultList(), null); 
}

Tenga en cuenta que Guava devolverá la IllegalArgumentException no intuitiva si el conjunto de resultados tiene más de un resultado. (La excepción tiene sentido para los clientes de getOnlyElement (), ya que toma la lista de resultados como argumento, pero es menos comprensible para los clientes de getSingleResultOrNull ()).

Aquí hay otra extensión, esta vez en Scala.

customerQuery.getSingleOrNone match {
  case Some(c) => // ...
  case None    => // ...
}

Con este chulo:

import javax.persistence.{NonUniqueResultException, TypedQuery}
import scala.collection.JavaConversions._

object Implicits {

  class RichTypedQuery[T](q: TypedQuery[T]) {

    def getSingleOrNone : Option[T] = {

      val results = q.setMaxResults(2).getResultList

      if (results.isEmpty)
        None
      else if (results.size == 1)
        Some(results.head)
      else
        throw new NonUniqueResultException()
    }
  }

  implicit def query2RichQuery[T](q: TypedQuery[T]) = new RichTypedQuery[T](q)
}

Mira este código:

return query.getResultList().stream().findFirst().orElse(null);

Cuando findFirst()se llama tal vez se puede lanzar una NullPointerException.

El mejor enfoque es:

return query.getResultList().stream().filter(Objects::nonNull).findFirst().orElse(null);

Por lo tanto, toda la solución "tratar de reescribir sin excepción" en esta página tiene un problema menor. O no arroja una excepción no única, ni la arroja en algunos casos incorrectos también (ver más abajo).

Creo que la solución adecuada es (tal vez) esto:

public static <L> L getSingleResultOrNull(TypedQuery<L> query) {
    List<L> results = query.getResultList();
    L foundEntity = null;
    if(!results.isEmpty()) {
        foundEntity = results.get(0);
    }
    if(results.size() > 1) {
        for(L result : results) {
            if(result != foundEntity) {
                throw new NonUniqueResultException();
            }
        }
    }
    return foundEntity;
}

Se devuelve con nulo si hay 0 elementos en la lista, se devuelve no único si hay elementos diferentes en la lista, pero no se devuelve no único cuando uno de los seleccionados no está diseñado correctamente y devuelve el mismo objeto más de una vez.

Siéntase libre de comentar.

Lo logré obteniendo una lista de resultados y luego verificando si está vacía

public boolean exist(String value) {
        List<Object> options = getEntityManager().createNamedQuery("AppUsers.findByEmail").setParameter('email', value).getResultList();
        return !options.isEmpty();
    }

Es tan molesto que getSingleResult()arroja excepciones

Lanza

1. NoResultException - si no hay resultado
2. NonUniqueResultException: si hay más de un resultado y alguna otra excepción de la que puede obtener más información de su documentación

Eso me funciona:

Optional<Object> opt = Optional.ofNullable(nativeQuery.getSingleResult());
return opt.isPresent() ? opt.get() : null;