JPA getSingleResult () ou null

Eu tenho um insertOrUpdatemétodo que insere um Entityquando não existe ou atualizá-lo, se existir. Para habilitar isso, eu tenho que findByIdAndForeignKey, se ele retornou nullinserir, se não for, atualizar. O problema é como verifico se ele existe? Então eu tentei getSingleResult. Mas lança uma exceção se o

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;
}

mas getSingleResultjoga um Exception.

obrigado

Lançar uma exceção é como getSingleResult()indica que ela não pode ser encontrada. Pessoalmente, não suporto esse tipo de API. Força o tratamento de exceções espúrias sem nenhum benefício real. Você só precisa agrupar o código em um bloco try-catch.

Como alternativa, você pode consultar uma lista e ver se está vazia. Isso não lança uma exceção. Na verdade, como você não está fazendo uma pesquisa de chave primária tecnicamente, pode haver vários resultados (mesmo que um, ambos ou a combinação de suas chaves ou restrições estrangeiras tornem isso impossível na prática), portanto essa é provavelmente a solução mais apropriada.

Encapsulei a lógica no seguinte 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();
    }
}

Tente isso no Java 8:

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

Aqui está uma boa opção para fazer isso:

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);
}

O Spring possui um método utilitário para isso:

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

Eu fiz (no Java 8):

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

No JPA 2.2 , em vez de .getResultList()verificar se a lista está vazia ou criando um fluxo, você pode retornar o fluxo e obter o primeiro elemento.

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

Se você deseja usar o mecanismo try / catch para lidar com esse problema .. ele pode ser usado para agir como se / outro. Usei o try / catch para adicionar um novo registro quando não encontrei um 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); 
}

Aqui está uma versão digitada / genérica, com base na implementação 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);
}

Existe uma alternativa que eu recomendaria:

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

Isso protege contra a exceção do ponteiro nulo, garante que apenas 1 resultado seja retornado.

Então não faça isso!

Você tem duas opções:

1. Execute uma seleção para obter a COUNT do seu conjunto de resultados e somente extraia os dados se essa contagem for diferente de zero; ou

2. Use o outro tipo de consulta (que obtém um conjunto de resultados) e verifique se possui 0 ou mais resultados. Ele deve ter 1, então retire-o da sua coleção de resultados e pronto.

Eu aceitaria a segunda sugestão, de acordo com Cletus. Oferece melhor desempenho do que (potencialmente) 2 consultas. Também menos trabalho.

Combinando os bits úteis das respostas existentes (limitando o número de resultados, verificando se o resultado é único) e usando o nome do método estabelecido (Hibernate), obtemos:

/**
 * 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);
}

O método não documentado uniqueResultOptionalem org.hibernate.query.Query deve fazer o truque. Em vez de ter que pegar um, NoResultExceptionvocê pode simplesmente ligar query.uniqueResultOptional().orElse(null).

Eu resolvi isso usando List<?> myList = query.getResultList();e verificando se myList.size()é igual a zero.

Aqui está a mesma lógica sugerida por outras pessoas (obtenha o resultadoList, retorne seu único elemento ou nulo), usando o Google Guava e um TypedQuery.

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

Observe que o Guava retornará a IllegalArgumentException não intuitiva se o conjunto de resultados tiver mais de um resultado. (A exceção faz sentido para os clientes de getOnlyElement (), pois leva a lista de resultados como argumento, mas é menos compreensível para os clientes de getSingleResultOrNull ().)

Aqui está outra extensão, desta vez em Scala.

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

Com este cafetão:

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)
}

Veja este código:

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

Quando findFirst()é chamado, talvez seja possível lançar uma NullPointerException.

a melhor abordagem é:

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

Portanto, toda a solução "tentar reescrever sem exceção" nesta página tem um problema menor. Não está lançando a exceção NonUnique, nem em alguns casos errados (veja abaixo).

Penso que a solução adequada é (talvez) esta:

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;
}

É retornado com null se houver 0 elemento na lista, retornando não exclusivo se houver elementos diferentes na lista, mas não retornando não exclusivo quando um dos seus selecionados não foi projetado corretamente e retorna o mesmo objeto mais de uma vez.

Sinta-se livre para comentar.

Consegui isso obtendo uma lista de resultados e verificando se ela está vazia

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

É tão irritante que getSingleResult()lança exceções

Lances:

1. NoResultException - se não houver resultado
2. NonUniqueResultException - se houver mais de um resultado e alguma outra exceção, você poderá obter mais informações na documentação deles

Isso funciona para mim:

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