Подтвердить что ты не робот

Передача пустого списка в качестве параметра в запрос JPA вызывает ошибку

Если я передаю пустой список в запрос JPA, я получаю сообщение об ошибке. Например:

List<Municipality> municipalities = myDao.findAll();  // returns empty list
em.createQuery("SELECT p FROM Profile p JOIN p.municipality m WHERE m IN (:municipalities)")
    .setParameter("municipalities", municipalities)
    .getResultList();

Поскольку список пуст, Hibernate генерирует это в SQL как "IN()", что дает мне ошибку в базе данных Hypersonic.

Есть билет для этого в отслеживание проблем с Hibernate, но там не так много комментариев/действий. Я не знаю о поддержке в других продуктах ORM или в спецификации JPA.

Мне не нравится идея вручную проверять нулевые объекты и пустые списки каждый раз. Есть ли общеизвестный подход/расширение? Как вы справляетесь с этими ситуациями?

4b9b3361

ОТВЕТЫ

Ответ 1

В соответствии с разделом 4.6.8 В выражениях из спецификации JPA 1.0:

В списке, разделенном запятыми, должен быть хотя бы один элемент, который определяет набор значений для выражения IN.

Другими словами, независимо от возможности Hibernate анализировать запрос и передавать IN(), независимо от поддержки этого синтаксиса конкретными базами данных (PosgreSQL не соответствует задаче Jira), вы должны использовать динамический запрос здесь, если вы хотите, чтобы ваш код был переносимым (и я обычно предпочитаю использовать API критериев для динамических запросов).

Ответ 2

После отсутствия фактического решения в качестве ответов я создал прокси-класс для обработки этих ситуаций. Идея состоит в том, чтобы по возможности сохранить собственный синтаксис.

ПРЕДУПРЕЖДЕНИЕ: Это незавершенный и очень опасный подход. Нижеприведенный код вовсе не означает полное решение и, вполне возможно, содержит циллионы ошибок и страшные случаи.

При этом класс BlankAwareQuery завершает запрос javax.persistence и инициализируется EntityManager и основной строкой запроса (которая не может содержать пустые списки или списки перечислений).

BlankAwareQuery query = new BlankAwareQuery(em, "SELECT p FROM Profile p");

После создания класса динамические части вставляются с помощью

query.from("p.address a");
query.where("a IN (:addresses)");

Параметры вставляются, как всегда:

query.setParameter("addresses", addresses);

Дело в том, что класс удаляет эти (их из-часть) из запроса, если они являются пустыми списками или манипулируют ими, если они являются списками перечислений.

Затем вызовите:

query.getResultList();

Итак, например:

List<Profile> profiles = new BlankAwareQuery(em, "SELECT p FROM Profile p")
    .from("p.address a JOIN a.municipality m").where("m IN (:municipalities)")
    .where("p.gender IN (:genders)")
    .where("p.yearOfBirth > :minYear")
    .where("p.yearOfBirth < :maxYear")
    .from("p.platforms f").where("f IN (:platforms)")
    .setParameter("municipalities", municipalities)
    .setParameter("genders", genders)
    .setParameter("minYear", minYear)
    .setParameter("maxYear", maxYear)
    .setParameter("platforms", platforms)
    .getResultList();

Фактический код (код использует Lombok для @Data и @NonNull аннотаций и Apache commons lang для StringUtils):

public class BlankAwareQuery {

    private @Data class Parameter {
        private @NonNull String fieldName;
        private @NonNull Object value;
    }

    private @Data class ClausePair {
        private @NonNull String from;
        private @NonNull String where;
    }

    private EntityManager em;

    private List<String> select = Lists.newArrayList();
    private List<ClausePair> whereFrom = Lists.newArrayList();
    private String from;
    private List<Parameter> parameters = Lists.newArrayList();
    Query query;

    public BlankAwareQuery(EntityManager em, String query) {

        this.em = em;

        /** Select **/
        int selectStart = StringUtils.indexOf(query, "SELECT ") + 7;
        int selectEnd = StringUtils.indexOf(query, " FROM ");
        select(StringUtils.substring(query, selectStart, selectEnd));

        /** From **/
        int fromStart = selectEnd + 6;
        int fromEnd = StringUtils.indexOf(query, " WHERE ");
        if (fromEnd == -1) fromEnd = query.length();
        from(StringUtils.substring(query, fromStart, fromEnd));

        /** Where **/
        String where = "";
        if (StringUtils.contains(query, " WHERE ")) {
            where = StringUtils.substring(query, fromEnd + 7);
        }
        where(where);
    }

    private BlankAwareQuery select(String s) {
        select.add(s);
        return this;
    }

    public BlankAwareQuery from(String s) {
        from = s;
        return this;
    }

    public BlankAwareQuery where(String s) {
        ClausePair p = new ClausePair(from, s);
        whereFrom.add(p);
        from = "";
        return this;
    }

    public BlankAwareQuery setParameter(String fieldName, Object value) {

        /** Non-empty collection -> include **/
        if (value != null && value instanceof List<?> && !((List<?>) value).isEmpty()) {

            /** List of enums -> parse open (JPA doesn't support defining list of enums as in (:blaa) **/
            if (((List<?>) value).get(0) instanceof Enum<?>) {

                List<String> fields = Lists.newArrayList();

                /** Split parameters into individual entries **/
                int i = 0;
                for (Enum<?> g : (List<Enum<?>>) value) {
                    String fieldSingular = StringUtils.substring(fieldName, 0, fieldName.length() - 1) + i;
                    fields.add(":" + fieldSingular);
                    parameters.add(new Parameter(fieldSingular, g));
                    i++;
                }

                /** Split :enums into (:enum1, :enum2, :enum3) strings **/
                for (ClausePair p : whereFrom) {
                    if (p.getWhere().contains(":" + fieldName)) {
                        int start = StringUtils.indexOf(p.getWhere(), ":" + fieldName);
                        int end = StringUtils.indexOfAny(StringUtils.substring(p.getWhere(), start + 1), new char[] {')', ' '});
                        String newWhere = StringUtils.substring(p.getWhere(), 0, start) + StringUtils.join(fields, ", ") + StringUtils.substring(p.getWhere(), end + start + 1);
                        p.setWhere(newWhere);
                    }
                }
            }
            /** Normal type which doesn't require customization, just add it **/ 
            else {
                parameters.add(new Parameter(fieldName, value));
            }
        }

        /** Not to be included -> remove from and where pair from query **/
        else {
            for (Iterator<ClausePair> it = whereFrom.iterator(); it.hasNext();) {
                ClausePair p = it.next();
                if (StringUtils.contains(p.getWhere(), fieldName)) {
                    it.remove();
                }
            }
        }

        return this;
    }

    private String buildQueryString() {

        List<String> from = Lists.newArrayList();
        List<String> where = Lists.newArrayList();

        for (ClausePair p : whereFrom) {
            if (!p.getFrom().equals("")) from.add(p.getFrom());
            if (!p.getWhere().equals("")) where.add(p.getWhere());
        }

        String selectQuery = StringUtils.join(select, ", ");
        String fromQuery = StringUtils.join(from, " JOIN ");
        String whereQuery = StringUtils.join(where, " AND ");

        String query = "SELECT " + selectQuery + " FROM " + fromQuery + (whereQuery == "" ? "" : " WHERE " + whereQuery);

        return query;
    }

    public Query getQuery() {
        query = em.createQuery(buildQueryString());
        setParameters();
        return query;
    }

    private void setParameters() {
        for (Parameter par : parameters) {
            query.setParameter(par.getFieldName(), par.getValue());
        }
    }

    public List getResultList() {
        return getQuery().getResultList();
    }

    public Object getSingleResult() {
        return getQuery().getSingleResult();
    }
}

Ответ 3

Решение:

if (municipalities==null || municipalities.isEmpty())
    .setParameter("municipalities", "''")
else
    .setParameter("municipalities", municipalities)

Ответ 4

Если вы используете аннотации Spring/hibernate, то одним из самых простых способов работы с этим является наличие двух параметров. Сначала давайте определим нашу аннотацию JPA:

        + "AND (p.myVarin :state OR :nullCheckMyVar is null) "

Затем передайте эти параметры как обычно:

    @Param("myVarin") List<Integers> myVarin,
    @Param("nullCheckMyVar") Integer nullCheckMyVar,

Наконец, во время вызова службы вы можете сделать следующее:

    Integer nullCheckInteger = null;
    if (myVarIn != null && !myVarIn.isEmpty()) {
        // we can use any integer
        nullCheckInteger = 1;
    }
    repo.callService(myVarIn, nullCheckInteger);

И затем передайте эти два парма в звонок.

Что это делает? Если myVarIn не является нулевым и заполненным, мы можем указать "все" как 1! = Null. В противном случае мы переходим в наш список, а null имеет значение null и поэтому игнорируется. Это либо выбирает "все", когда пусто, либо что-то, когда оно не пустое.

Ответ 5

Поскольку вы запрашиваете идентификаторы последовательности DB, которые обычно начинаются с 1, вы можете добавить 0 в список

if (excludeIds.isEmpty()) {
    excludeIds.add(new Long("0"));
}
List<SomeEntity> retval = someEntityRepo.findByIdNotIn(excludeIds);

Может быть, -1 тоже работает. Небольшая работа для использования jpa repos.