Hibernate HQL присоединяется к выборке, не рекурсивная выборка

Ответ 1

Если вы знаете, что у вас есть только два уровня в вашем дереве, подумайте о том, чтобы присоединиться к более глубокому уровню. Что-то вроде ниже?

SELECT DISTINCT domain FROM Domain domain 
  LEFT OUTER JOIN FETCH domain.operators operators1 
  LEFT OUTER JOIN FETCH domain.networkCodes 
  LEFT OUTER JOIN FETCH operators1.operators operators2 
  LEFT OUTER JOIN FETCH operators1.networkCodes
WHERE domain.domainId = :domainId

Ответ 2

Спящий режим работает с различными стратегиями выборки..!!

Hibernate предоставляет 4 стратегии для извлечения данных:

SELECT

@OneToMany(mappedBy="tableName", cascade=CascadeType.ALL)
@Column(name="id") 
@Fetch(FetchMode.SELECT)

В этом методе запускаются несколько SQL-запросов. Этот первый уволен для извлечения всех записей в родительской таблице. Оставшиеся для записи записей для каждой родительской записи. Это в основном проблема N + 1. Первый запрос извлекает N записей из базы данных, в этот случай N родительских записей. Для каждого родителя возвращается новый запрос Ребенок. Поэтому для N родительских запросов N запросов извлекают информацию из Таблица детей.

JOIN

@OneToMany(mappedBy="tableName", cascade=CascadeType.ALL)
@Column(name="id")
@Fetch(FetchMode.JOIN) 

Это похоже на стратегию выборки SELECT, за исключением того факта, что все извлечение базы данных происходит заранее в JOIN fetch, в отличие от SELECT где это происходит по необходимости. Это может стать важным эффективности.

подвыбор

 @OneToMany(mappedBy="tableName", cascade=CascadeType.ALL)
 @Column(name="id")
 @Fetch(FetchMode.SUBSELECT)

Запущены два SQL. Один для извлечения всех родительских, а второй - SUBSELECT в предложении WHERE для получения всего дочернего элемента, который имеет сопоставление идентификаторов родительских элементов.

ПАРТИИ

@OneToMany(mappedBy="tableName", cascade=CascadeType.ALL)
@Column(name="id")
@@BatchSize(size=2)

Размер партии сопоставляется с числом родителя, чей ребенок извлекается. Таким образом, мы можем указать количество записей, которые будут выбраны за раз. Будут выполняться несколько запросов.!!

один-ко-многим и многие-ко-многим разрешает - join, Select и SubSelect

много-к-одному и один-к-одному позволяет - Join и Select

Hibernate также различает (когда выбраны ассоциации)

1. Непосредственная выборка -

связь, сбор или атрибут извлекаются немедленно, когда Родитель загружен. (Ленивая = "ложь" )

2. Lazy collection fetching -

сбор извлекается, когда приложение вызывает операцию это коллекция. (Это значение по умолчанию для коллекций. (Lazy = "true" )

3. Экстра-ленивый "выбор коллекции -

Доступ к отдельным элементам коллекции осуществляется из базы данных по мере необходимости. Hibernate пытается не собирать всю коллекцию в памяти, если это абсолютно необходимо (подходит для очень больших коллекций) (Ленивый = "экстра" )

4. Получение прокси-сервера -

однозначная ассоциация извлекается, когда метод, отличный от идентификатор getter вызывается на ассоциированный объект. (Ленивый = "прокси" )

5. Без прокси-сервера "-

однозначная связь выбирается, когда переменная экземпляра доступ. По сравнению с выборкой прокси, этот подход менее ленив. (Lazy = "no-proxy" )

6. Lazy выбор атрибута -

атрибут или однозначная связь извлекается, когда экземпляр доступ к переменной. (Ленивая = "истина" )

один-ко-многим и многие-ко-многим позволяет Immediate, Layzy, Extra Lazy

много-к-одному и один-к-одному позволяет Immediate Proxy, No Proxy

Ответ 3

Вы отметили ассоциации EAGER. Итак, что бы вы ни делали в своем запросе, Hibernate загрузит все связанные домены и сетевые коды загруженных доменов. И он будет загружать домены и сетевые коды дополнительных доменов и т.д. И т.д., Пока все нагрузки коллекции не возвратят пустые коллекции или объекты, которые уже были загружены.

Чтобы этого избежать, сделайте свои коллекции ленивыми (как по умолчанию). Тогда загрузка домена с его операторами и его сетевые коды будут загружать именно это.

Ответ 4

Ваше сопоставление EAGER будет считаться автоматически только Hibernate, если вы используете API критериев для запроса.

Если вы используете HQL, вам нужно вручную добавить ключевое слово FETCH в свои JOIN, чтобы заставить Hibernate включать отношения в первый запрос и избежать последующих запросов.

Это спецификация Hibernate и может работать по-другому на других ORM.

Смотрите этот вопрос/ответ для немного другого угла.

Ответ 5

Не задокументировано это хорошо, но попытались ли вы установить FetchMode? Вы можете сделать это, используя API-интерфейс Criteria: domainCriteria.setFetchMode("operators", JOIN) или используйте @Fetch(JOIN) в определении отношения.

Аннотации (и только аннотация, как кажется) также позволяет установить режим выборки SUBSELECT, который должен по крайней мере сдерживать Hibernate для выполнения 3 запросов max. Не зная ваш набор данных, я предполагаю, что это должен быть способ пойти на вас, так как большое жирное соединение над этими столами не кажется слишком здоровым. Лучше всего понять это, я думаю...

Ответ 6

Поскольку вы уже указали FetchType.EAGER для networkCodes и operators, при каждом запросе domain hibernate будет загружать как networkCodes и operators. Вот и вся идея режима EAGER

Таким образом, вы можете изменить свой запрос следующим образом:

private static final String FIND
    = "SELECT DISTINCT domain"
    + " FROM Domain domain"
    + " WHERE domain.domainId = :domainId";

Подробности API здесь

Ура !!

Ответ 7

Мое первое наблюдение заключается в том, что вам не нужно писать запрос HQL, содержащий объединения, если ваши сопоставления говорят, что они должны быть загружены с высокой нагрузкой.

Однако вы можете сообщить Hibernate использовать стратегию выборки как sub select, если вы не хотите использовать объединения.

Hibernate генерирует SQL-запрос для загрузки объектов во время запуска на основе указанных сопоставлений и кэширует его. Однако в вашем случае у вас есть одно-много вложенных отношений с самим собой и произвольная глубина, поэтому похоже, что hibernate не сможет решить перед рукой sql для корректной загрузки. Поэтому ему нужно будет отправить несколько запросов на объединение в зависимости от глубины родительского домена, который вы запрашиваете во время выполнения.

Мне кажется, вы думаете, что HQL и результирующий SQL/(s) в вашем случае могут иметь один к одному, который не является правда. С помощью HQL вы запрашиваете объекты, и orm решает, как загрузить этот объект и его отношения (нетерпеливые/ленивые) на основе или вы можете указать их во время выполнения (например, ленивая ассоциация при сопоставлении может быть переопределена Query api, но не наоборот). Вы можете сказать orm, что загружать (моя маркировка нетерпеливая или ленивая) и как загружать с нетерпением (либо с помощью выбора соединения/суб).

UPDATE

Когда я запускаю следующий запрос в вашей модели домена

SELECT DISTINCT domain FROM Domain domain LEFT OUTER JOIN FETCH domain.operators LEFT OUTER JOIN FETCH domain.networkCodes WHERE domain.domainId = :domainId";

Я вижу, что коллекции networkCode и operator имеют экземпляр PersistentSet (это оболочка Hibernate), и оба имеют инициализированное свойство, которое установлено как true. Также в базовом контексте сеанса я вижу области с доменом и перечисленными операторами. Итак, что заставляет вас думать, что они не загружены?

Так мой домен выглядит как

@Entity
@Table
public class Domain {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(generator = "generator")
    @Column(name = "domain_id")
    private Long domainId;

    @Column(nullable = false, unique = true)   
    private String name;

    @Column(nullable = false)    
    @Enumerated(EnumType.STRING)
    private DomainType type;

    @OneToMany(mappedBy = "domain",cascade = {
            CascadeType.PERSIST,
            CascadeType.MERGE
    }, fetch = FetchType.EAGER)   
    private Set<NetworkCode> networkCodes = new HashSet<NetworkCode>();

    @ManyToMany(mappedBy="parent",fetch = FetchType.EAGER, cascade=CascadeType.ALL)
    private Set<Domain> operators = new HashSet<Domain>();
    // more

    @ManyToOne  
    private Domain parent;

    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


public DomainType getType() {
        return type;
    }

    public void setType(DomainType type) {
        this.type = type;
    }


    public Set<Domain> getOperators() {
        return operators;
    }


    public Long getDomainId() {
        return domainId;
    }


    public void setDomainId(Long domainId) {
        this.domainId = domainId;
    }


    public void setOperators(Set<Domain> operators) {
        this.operators = operators;
    }

    public void addDomain(Domain domain){
        getOperators().add(domain);
        domain.setParent(this);
    }


    public Domain getParent() {
        return parent;
    }


    public void setParent(Domain parent) {
        this.parent = parent;
    }

    public void addNetworkCode(NetworkCode netWorkCode){
        getNetworkCodes().add(netWorkCode);
        netWorkCode.setDomain(this);
    }