FetchMode Join vs-Anweisung ausgewertet

Ich habe zwei Tabellen Employee und Department folgenden sind die entity-Klassen für beide

Department.java
@Entity
@Table(name = "DEPARTMENT")
public class Department {
    @Id
    @Column(name = "DEPARTMENT_ID")
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer departmentId;
    @Column(name = "DEPARTMENT_NAME")
    private String departmentName;
    @Column(name = "LOCATION")
    private String location;

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "department", orphanRemoval = true)
    @Fetch(FetchMode.SUBSELECT)
    //@Fetch(FetchMode.JOIN)
    private List<Employee> employees = new ArrayList<>();
}


Employee.java
@Entity
@Table(name = "EMPLOYEE")
public class Employee {
    @Id
    @SequenceGenerator(name = "emp_seq", sequenceName = "seq_employee")
    @GeneratedValue(generator = "emp_seq")
    @Column(name = "EMPLOYEE_ID")
    private Integer employeeId;
    @Column(name = "EMPLOYEE_NAME")
    private String employeeName;

    @ManyToOne
    @JoinColumn(name = "DEPARTMENT_ID")
    private Department department;
}

Unten sind die Abfragen, die ausgelöst wird, wenn ich habe em.find(Department.class, 1);

-- fetch mode = fetchmode.join

    SELECT department0_.DEPARTMENT_ID AS DEPARTMENT_ID1_0_0_,
      department0_.DEPARTMENT_NAME    AS DEPARTMENT_NAME2_0_0_,
      department0_.LOCATION           AS LOCATION3_0_0_,
      employees1_.DEPARTMENT_ID       AS DEPARTMENT_ID3_1_1_,
      employees1_.EMPLOYEE_ID         AS EMPLOYEE_ID1_1_1_,
      employees1_.EMPLOYEE_ID         AS EMPLOYEE_ID1_1_2_,
      employees1_.DEPARTMENT_ID       AS DEPARTMENT_ID3_1_2_,
      employees1_.EMPLOYEE_NAME       AS EMPLOYEE_NAME2_1_2_
    FROM DEPARTMENT department0_
    LEFT OUTER JOIN EMPLOYEE employees1_
    ON department0_.DEPARTMENT_ID   =employees1_.DEPARTMENT_ID
    WHERE department0_.DEPARTMENT_ID=?

-- fetch mode = fetchmode."Teilauswahl treffen"

    SELECT department0_.DEPARTMENT_ID AS DEPARTMENT_ID1_0_0_,
      department0_.DEPARTMENT_NAME    AS DEPARTMENT_NAME2_0_0_,
      department0_.LOCATION           AS LOCATION3_0_0_
    FROM DEPARTMENT department0_
    WHERE department0_.DEPARTMENT_ID=?

    SELECT employees0_.DEPARTMENT_ID AS DEPARTMENT_ID3_1_0_,
      employees0_.EMPLOYEE_ID        AS EMPLOYEE_ID1_1_0_,
      employees0_.EMPLOYEE_ID        AS EMPLOYEE_ID1_1_1_,
      employees0_.DEPARTMENT_ID      AS DEPARTMENT_ID3_1_1_,
      employees0_.EMPLOYEE_NAME      AS EMPLOYEE_NAME2_1_1_
    FROM EMPLOYEE employees0_
    WHERE employees0_.DEPARTMENT_ID=?

Ich wollte nur wissen, welche sollten wir lieber FetchMode.JOIN oder FetchMode.SUBSELECT? welches sollten wir uns entscheiden, in welchem Szenario?

InformationsquelleAutor eatSleepCode | 2015-10-07

27

Die UNTERABFRAGE Strategie, die Marmite bezieht, ist im Zusammenhang zu FetchMode.WÄHLEN Sie nicht "Teilauswahl treffen".

Die Ausgabe in der Konsole, die du gepostet hast über fetchmode."Teilauswahl treffen" ist merkwürdig, denn dies ist nicht die Art und Weise, dass funktionieren soll.

Den FetchMode."Teilauswahl treffen"

Verwendung einer untergeordneten select-Abfrage zum laden der zusätzlichen Sammlungen

Hibernate docs:

Wenn man faul Sammlung oder einwertige proxy geholt werden, Hibernate lädt alle von Ihnen, wieder mit der ursprünglichen Abfrage in einer untergeordneten select-Anweisung. Dies funktioniert auf die gleiche Weise wie die batch-fetching, aber ohne die schrittweise laden.

FetchMode.Untergeordneten select-Anweisung sollte wie folgt Aussehen:
```
SELECT <employees columns>
FROM EMPLOYEE employees0_
WHERE employees0_.DEPARTMENT_ID IN
(SELECT department0_.DEPARTMENT_ID FROM DEPARTMENT department0_)
```
Können Sie sehen, dass diese zweite Abfrage bringen wird Speicher alle der Mitarbeiter, gehört zu einigen Departamentos (d.h. Mitarbeiter.department_id ist nicht null), ist es egal, wenn es nicht die Abteilung, die Sie abrufen, die in Ihrem ersten Abfrage.
Das ist also potentiell ein großes Problem, wenn die Tabelle der Mitarbeiter ist groß, weil es sein kann versehentlich das laden einer gesamten Datenbank in den Speicher.

Jedoch, FetchMode.UNTERGEORDNETE reduziert significatly die Anzahl der Abfragen, da braucht nur zwei Abfragen in comparisson auf die N+1 Abfragen der FecthMode.WÄHLEN Sie.

Denken Sie vielleicht, dass FetchMode.MITMACHEN macht noch weniger Abfragen, nur 1, warum also untergeordneten select-Anweisung überhaupt? Nun, es ist wahr, aber auf Kosten von duplizierten Daten und eine schwerere Reaktion.

Wenn eine einwertige proxy abgerufen werden, mit JOIN, die Abfrage abrufen:
```
+---------------+---------+-----------+
| DEPARTMENT_ID | BOSS_ID | BOSS_NAME |
+---------------+---------+-----------+
|             1 |       1 | GABRIEL   |
|             2 |       1 | GABRIEL   |
|             3 |       2 | ALEJANDRO |
+---------------+---------+-----------+
```
Den Mitarbeiterdaten der boss ist dupliziert, wenn er leitet mehr als eine Abteilung und es sind Kosten in der Bandbreite.

Wenn einer faul-Sammlung abgerufen werden, mit JOIN, die Abfrage abrufen:
```
+---------------+---------------+-------------+
| DEPARTMENT_ID | DEPARTMENT_ID | EMPLOYEE_ID |
+---------------+---------------+-------------+
|             1 | Sales         | GABRIEL     |
|             1 | Sales         | ALEJANDRO   |
|             2 | RRHH          | DANILO      |
+---------------+---------------+-------------+
```
Die Abteilung Daten dupliziert werden, wenn es mit mehr als einem Mitarbeiter (der Natürliche Fall).
Wir nicht nur leiden, eine Kosten in der Bandbreite, aber auch wir bekommen doppelte dupliziert Abteilung Objekte und wir müssen einen SATZ oder DISTINCT_ROOT_ENTITY zu de-duplizieren.

Jedoch, doppelte Daten in pos, die eine niedrigere Latenz ist ein guter trade-off in vielen Fällen, wie Markus Winand sagt.

Einen SQL-join ist immer noch effizienter als die verschachtelten Ansatz wählt—auch wenn es führt die gleichen index-lookups—weil es vermeidet eine Menge von Netzwerk-Kommunikation. Es ist noch schneller, wenn der Gesamtbetrag der übertragenen Daten ist größer, weil der Vervielfältigung von Mitarbeiter Attribute für jeden Verkauf. Das ist, weil von den zwei Dimensionen der performance: Antwortzeit und Durchsatz; in computer-Netzwerken rufen wir Ihnen Latenz und Bandbreite. Bandbreite hat nur einen geringen Einfluss auf die Reaktionszeit, aber Latenzen haben einen großen Einfluss. Das bedeutet, dass die Anzahl der Datenbank-Roundtrips ist wichtiger für die Antwortzeit, als die Menge der übertragenen Daten.

So, die wichtigste Frage über die Verwendung von untergeordneten select-Anweisung ist, dass ist schwer zu kontrollieren und beladen können ein ganzes Diagramm mit Entitäten in den Speicher.
Mit Batch-fetching Holen Sie die zugehörige Entität in einer separaten Abfrage, die als UNTERAUSWAHL (damit Sie nicht leiden Duplikate), nach und nach und die meisten wichtig, dass Sie die Abfrage nur mit Personen (damit Sie nicht leiden potenziell laden eine riesige Grafik), weil die IN der Unterabfrage wird gefiltert durch die IDs abgerufen, indem die outter Abfrage).
```
Hibernate: 
    select ...
    from mkyong.stock stock0_

Hibernate: 
    select ...
    from mkyong.stock_daily_record stockdaily0_ 
    where
        stockdaily0_.STOCK_ID in (
            ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
        )
```
(Es kann interessant sein, zu testen, ob die Batch-fetching mit einem sehr hohen batch-Größe handeln würde, wie einer untergeordneten select-Anweisung, aber ohne das Problem der Last auf die gesamte Tabelle)

Ein paar Beiträge zeigen die verschiedenen bezaubernde Strategien und die SQL-logs (sehr wichtig):
Zusammenfassung:
- JOIN: vermeidet das wichtige Thema der N+1 Abfragen, aber es kann abrufen von Daten dupliziert werden.
- Untergeordneten select-Anweisung: vermeidet N+1 zu und nicht das Duplikat Daten, aber es lädt alle Entitäten des zugehörigen Typs in den Speicher.
Die Tabellen erstellt wurden, verwenden ascii-Tabellen.
- Dies ist grob irreführend. Die untergeordneten select-Anweisung wird nicht holt Ihre gesamte Datenbank in den Arbeitsspeicher. Der verlinkte Artikel ist über eine Eigenart, wo untergeordneten select-Anweisung ignoriert paging-Befehle von der übergeordneten, aber es ist immer noch eine untergeordnete.
- Im Nachhinein sehe ich, dass der Punkt, den ich machte war etwas pedantisch. Untergeordneten select-Anweisung abrufen hat ein großes problem mit maxResults macht, dass die beiden im Grunde unvereinbar. Und die Fälle, wo es passieren würde, wäre völlig unerwartet und wahrscheinlich Fortschritte unbemerkt in die Produktion.
InformationsquelleAutor gabrielgiussi
9

Ich würde sagen, es kommt darauf an...

Let nehme an, Sie haben N Mitarbeiter in einer Abteilung, enthält D Byte Daten und einem durchschnittlichen Mitarbeiter aus E-bytes. (Bytes sind die Summe des Attributs Länge mit etwas overhead).

Mithilfe der join Strategie, die Sie durchführen 1 Abfrage und transfers N * (D + E) - Daten.

Mithilfe der Unterabfrage Strategie, die Sie durchführen 1 + N-Abfragen sind, sondern überträgt nur D + N*E-Daten.

In der Regel die N+1 Abfrage - ist die NO GO wenn N groß ist, so wird die VERKNÜPFUNG bevorzugt.

Aber eigentlich müssen Sie überprüfen Sie Ihre Laufleistung zwischen der Anzahl der Abfragen und die Daten übertragen.

Beachten Sie, dass ich nicht unter Berücksichtigung anderer Aspekte, wie die Hibernate-caching.

Zusätzliche subtile Aspekt könnte gültig sein, wenn die Mitarbeiter-Tabelle zu groß ist und Partitionierung - partition pruning auf den index-Zugriff kommt die überlegung, wie gut.

InformationsquelleAutor Marmite Bomber
1

Einen Kunden (financial services) von mir hatte ein ähnliches problem, und er wollte "erwerben die Daten in eine einzelne Abfrage". Gut, ich erklärte, dass es besser ist, mehr als eine Abfrage, aufgrund der folgenden:

Für FetchMode.Sich dem Departement übertragen würden aus der Datenbank in die Anwendung einmal pro Mitarbeiter, da die join-operation resultiert in der Multiplikation der Abteilung pro Mitarbeiter. Wenn Sie 10 Abteilungen mit 100 Mitarbeitern jeder, jede von diesen 10 Abteilungen übertragen werden würde 100 mal innerhalb einer Abfrage, einfaches SQL. Also jede Abteilung, in diesem Fall übertragen wird 99-mal häufiger als nötig, was zu einer Daten-transfer-Aufwand für die Abteilung.

Für Fetchmode zwei untergeordneten select-Abfragen ausgelöst werden, in die Datenbank. Man würde verwendet werden, um die Daten von den 1000 Angestellten, um die 10 Abteilungen. Diese, für mich, klingt sehr viel effizienter. Für sicher, Sie würden sicherstellen, dass die Indizes sind im Ort, so dass die Daten abgerufen werden können, sofort.

Ich würde es vorziehen, FetchMode."Teilauswahl treffen".

Wäre es ein weiterer Fall, falls jede Abteilung hat nur einen Mitarbeiter, sondern, wie der name "Abteilung" suggeriert, wäre dies sehr unwahrscheinlich der Fall sein.

Schlage ich vor, die Messung der Zugriffszeiten auf die diese Theorie unterstützen. Für meine Kunden habe ich Messungen für verschiedene Arten von Zugriffen, und die "Abteilung" Tabelle für meine Kunden, hatte viele weitere Felder (ich habe nicht design, obwohl). So war es bald klar, dass die FetchMode.Teilauswahl treffen war viel schneller.

InformationsquelleAutor michaeak
1

Planky sagte

(1) Dies ist grob irreführend. (2) Die untergeordneten select-Anweisung wird nicht holt Ihre gesamte Datenbank in den Arbeitsspeicher. Der verlinkte Artikel ist über eine Eigenart, wo untergeordneten select-Anweisung (3) ignoriert paging-Befehle von der übergeordneten, (4) aber es ist immer noch eine untergeordnete.
1. Nach Ihrem Kommentar habe ich untersucht, wieder über FetchMode."Teilauswahl treffen", und ich fand heraus, dass meine Antwort nicht ganz korrekt ist.
2. War dies eine hypothetische situation, in der die Hydratation von jeder Entität, die wurde komplett in den Speicher geladen (Mitarbeiter in diesem Fall) wird Ende feuchtigkeitsspendende viele andere Einrichtungen. Das wahre problem ist das laden der gesamten Tabelle sub-ausgewählt, wenn die Tabelle enthält mehrere tausend Zeilen (auch wenn jeder einzelne von denen nicht Holen eifrig anderen Personen aus anderen Tabellen).
3. Ich weiß nicht, was du meinst mit der paging-Befehle aus der übergeordneten.
4. Ja, es ist immer noch eine untergeordnete, aber ich weiß nicht, was Sie versuchen zu zeigen, mit diesem.
Die Ausgabe in der Konsole, die du gepostet hast über fetchmode.Unterauswahl ist merkwürdig, denn dies ist nicht die Art und Weise, dass funktionieren soll.

Dies gilt aber nur, wenn es mehr als Department-Entität hidrated (was bedeutet, dass mehr als ein Mitarbeiter Sammlung nicht initialisierten), ich habe es getestet mit 3.6.10.Final und 4.3.8.Final
In Szenarien, In 2.2 (FetchMode.Untergeordneten select-hidrating 2 von 3 Abteilungen) und 3.2 (FetchMode.Untergeordneten select-hidrating alle Abteilungen), SubselectFetch.toSubselectString gibt die folgenden (die links zu den Hibernate-Klassen sind aus dem 4.3.8.End-tag):
```
select this_.DEPARTMENT_ID from SUBSELECT_DEPARTMENT this_
```
Diese Unterabfrage wird nach dem erstellen der where-Klausel von OneToManyJoinWalker.initStatementString endend mit
```
employees0_.DEPARTMENT_ID in (select this_.DEPARTMENT_ID from SUBSELECT_DEPARTMENT this_)
```
Dann die where-Klausel Hinzugefügt wird, die in CollectionJoinWalker.whereString endend mit
```
select employees0_.DEPARTMENT_ID as DEPARTMENT3_2_1_, employees0_.EMPLOYEE_ID as EMPLOYEE1_1_, employees0_.EMPLOYEE_ID as EMPLOYEE1_3_0_, employees0_.DEPARTMENT_ID as DEPARTMENT3_3_0_, employees0_.EMPLOYEE_NAME as EMPLOYEE2_3_0_ from SUBSELECT_EMPLOYEE employees0_ where employees0_.DEPARTMENT_ID in (select this_.DEPARTMENT_ID from SUBSELECT_DEPARTMENT this_)
```
In dieser Abfrage, in beiden Fällen sind alle Mitarbeiter abgerufen werden und hydratisiert.
Dies ist eindeutig ein Problem im Szenario 2.2, weil wir feuchtigkeitsspendende nur Abteilungen 1 und 2 aber auch Hydratisierung alle Mitarbeiter, auch wenn Sie nicht zu uns gehören zu diesen Dienststellen (in diesem Fall die Mitarbeiter der Abteilung 3).

Wenn es nur eine Abteilung Person hydratisiert in der Sitzung mit seinen Mitarbeitern Sammlung nicht initialisiert, dann die Abfrage wie eatSleepCode schrieb. Überprüfen Sie Szenario 1.2
```
select subselectd0_.department_id as departme1_2_0_, subselectd0_.department_name as departme2_2_0_, subselectd0_.location as location3_2_0_ from subselect_department subselectd0_ where subselectd0_.department_id=?
```
Vom FetchStyle
```
    /**
     * Performs a separate SQL select to load the indicated data.  This can either be eager (the second select is
     * issued immediately) or lazy (the second select is delayed until the data is needed).
     */
    SELECT,
    /**
     * Inherently an eager style of fetching.  The data to be fetched is obtained as part of an SQL join.
     */
    JOIN,
    /**
     * Initializes a number of indicated data items (entities or collections) in a series of grouped sql selects
     * using an in-style sql restriction to define the batch size.  Again, can be either eager or lazy.
     */
    BATCH,
    /**
     * Performs fetching of associated data (currently limited to only collections) based on the sql restriction
     * used to load the owner.  Again, can be either eager or lazy.
     */
    SUBSELECT
```
~~Bis jetzt konnte ich nicht beheben, was das Javadoc bedeutet mit:~~

~~basierend auf der sql-Einschränkung verwendet, um die Belastung der Eigentümer~~

UPDATE
Planky sagte:

Statt, es ist nur noch zum laden der Tabelle am schlimmsten, und sogar dann, nur, wenn Ihre erste Abfrage nicht über eine where-Klausel. Also ich würde sagen, dass mit untergeordneten select-Abfragen können unerwartet laden Sie die gesamte Tabelle, wenn Sie die Begrenzung der Ergebnisse und Sie haben keinen WO die Kriterien.

Dies ist wahr und es ist ein sehr wichtiges detail, das ich getestet habe in der neuen Szenario 4.2

Die Abfrage generiert zu Holen Mitarbeiter ist
```
select employees0_.department_id as departme3_4_1_, employees0_.employee_id as employee1_5_1_, employees0_.employee_id as employee1_5_0_, employees0_.department_id as departme3_5_0_, employees0_.employee_name as employee2_5_0_ from subselect_employee employees0_ where employees0_.department_id in (select this_.department_id from subselect_department this_ where this_.department_name>=?)
```
Die Unterabfrage in der where-Klausel enthält die ursprüngliche Beschränkung this_.department_name>=?, die Vermeidung der Belastung der Mitarbeiter.
Dies ist, was in der javadoc heißt mit

basiert auf der sql-Einschränkung verwendet, um die Belastung der Eigentümer

Alles, was ich gesagt habe über FetchMode.BEITRETEN und die Unterschiede mit FetchMode."Teilauswahl treffen" treu bleibt (und das gilt auch für FetchMode.WÄHLEN Sie).
- Vielen Dank für die Zeit nehmen, zu reagieren. Ich vermute, dass ich übertrieben, wenn ich sagte, es war grob irreführend. Was ich meinte, als ich sagte: "Der verlinkte Artikel ist über eine Eigenart, wo untergeordneten select-Anweisung ignoriert paging-Befehle aus der übergeordneten" ist, dass es beschreibt ein problem bei der Verwendung der limit sql-Konstrukt, welches Häufig für die paging-Ergebnisse.
- Mein Punkt war eigentlich, dass es nicht die Art von problem, die Last der gesamten Datenbank (durch laden alle Vereine—ein problem, das auftreten kann, mit Hibernate, wenn es konfiguriert ist schlecht). Stattdessen, es ist nur noch zum laden der Tabelle am schlimmsten, und auch nur dann, wenn Ihre erste Abfrage nicht über eine where-Klausel. Also ich würde sagen, dass die Verwendung von untergeordneten select-Abfragen können unerwartet laden Sie die gesamte Tabelle, wenn Sie die Begrenzung der Ergebnisse und Sie haben keine, WO Kriterien.
InformationsquelleAutor gabrielgiussi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.