Ruhezustand - Abfragesprache

Hibernate Query Language (HQL) ist eine objektorientierte Abfragesprache, ähnlich wie SQL, aber anstatt Tabellen und Spalten zu bearbeiten, arbeitet HQL mit persistenten Objekten und ihren Eigenschaften. HQL-Abfragen werden von Hibernate in herkömmliche SQL-Abfragen übersetzt, die wiederum Aktionen für die Datenbank ausführen.

Sie können SQL-Anweisungen zwar direkt mit Hibernate unter Verwendung von Native SQL verwenden, ich würde jedoch empfehlen, HQL nach Möglichkeit zu verwenden, um Probleme mit der Datenbankportabilität zu vermeiden und die SQL-Generierungs- und Caching-Strategien von Hibernate zu nutzen.

Bei Schlüsselwörtern wie SELECT, FROM und WHERE usw. wird nicht zwischen Groß- und Kleinschreibung unterschieden, bei Eigenschaften wie Tabellen- und Spaltennamen wird in HQL zwischen Groß- und Kleinschreibung unterschieden.

FROM-Klausel

Du wirst benutzen FROMKlausel, wenn Sie vollständige persistente Objekte in den Speicher laden möchten. Es folgt die einfache Syntax der Verwendung der FROM-Klausel:

String hql = "FROM Employee";
Query query = session.createQuery(hql);
List results = query.list();

Wenn Sie einen Klassennamen in HQL vollständig qualifizieren müssen, geben Sie einfach den Paket- und Klassennamen wie folgt an:

String hql = "FROM com.hibernatebook.criteria.Employee";
Query query = session.createQuery(hql);
List results = query.list();

AS-Klausel

Das ASKlausel kann verwendet werden, um den Klassen in Ihren HQL-Abfragen Aliase zuzuweisen, insbesondere wenn Sie lange Abfragen haben. Zum Beispiel wäre unser vorheriges einfaches Beispiel das Folgende:

String hql = "FROM Employee AS E";
Query query = session.createQuery(hql);
List results = query.list();

Das AS Das Schlüsselwort ist optional und Sie können den Alias ​​auch direkt nach dem Klassennamen wie folgt angeben:

String hql = "FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

SELECT-Klausel

Das SELECTKlausel bietet mehr Kontrolle über die Ergebnismenge als die from-Klausel. Wenn Sie anstelle des vollständigen Objekts nur wenige Eigenschaften von Objekten erhalten möchten, verwenden Sie die SELECT-Klausel. Es folgt die einfache Syntax der Verwendung der SELECT-Klausel, um nur das Feld first_name des Employee-Objekts abzurufen.

String hql = "SELECT E.firstName FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

Es ist hier bemerkenswert, dass Employee.firstName ist eine Eigenschaft des Employee-Objekts und kein Feld der EMPLOYEE-Tabelle.

WO-Klausel

Wenn Sie die spezifischen Objekte eingrenzen möchten, die aus dem Speicher zurückgegeben werden, verwenden Sie die WHERE-Klausel. Es folgt die einfache Syntax der Verwendung der WHERE-Klausel:

String hql = "FROM Employee E WHERE E.id = 10";
Query query = session.createQuery(hql);
List results = query.list();

ORDER BY-Klausel

Um die Ergebnisse Ihrer HQL-Abfrage zu sortieren, müssen Sie die verwenden ORDER BYKlausel. Sie können die Ergebnisse nach einer beliebigen Eigenschaft für die Objekte in der Ergebnismenge sortieren, entweder aufsteigend (ASC) oder absteigend (DESC). Es folgt die einfache Syntax der Verwendung der ORDER BY-Klausel:

String hql = "FROM Employee E WHERE E.id > 10 ORDER BY E.salary DESC";
Query query = session.createQuery(hql);
List results = query.list();

Wenn Sie nach mehr als einer Eigenschaft sortieren möchten, fügen Sie einfach die zusätzlichen Eigenschaften am Ende der order by-Klausel hinzu, die wie folgt durch Kommas getrennt sind:

String hql = "FROM Employee E WHERE E.id > 10 " +
             "ORDER BY E.firstName DESC, E.salary DESC ";
Query query = session.createQuery(hql);
List results = query.list();

GROUP BY-Klausel

Mit dieser Klausel kann Hibernate Informationen aus der Datenbank abrufen und basierend auf einem Wert eines Attributs gruppieren und das Ergebnis normalerweise verwenden, um einen Gesamtwert einzuschließen. Es folgt die einfache Syntax der Verwendung der GROUP BY-Klausel:

String hql = "SELECT SUM(E.salary), E.firtName FROM Employee E " +
             "GROUP BY E.firstName";
Query query = session.createQuery(hql);
List results = query.list();

Benannte Parameter verwenden

Hibernate unterstützt benannte Parameter in seinen HQL-Abfragen. Dies erleichtert das Schreiben von HQL-Abfragen, die Eingaben des Benutzers akzeptieren, und Sie müssen sich nicht gegen SQL-Injection-Angriffe verteidigen. Es folgt die einfache Syntax zur Verwendung benannter Parameter:

String hql = "FROM Employee E WHERE E.id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("employee_id",10);
List results = query.list();

UPDATE-Klausel

Massenaktualisierungen sind für HQL mit Hibernate 3 neu und löschen die Arbeit in Hibernate 3 anders als in Hibernate 2. Die Abfrageoberfläche enthält jetzt eine Methode namens executeUpdate () zum Ausführen von HQL UPDATE- oder DELETE-Anweisungen.

Das UPDATEKlausel kann verwendet werden, um eine oder mehrere Eigenschaften eines oder mehrerer Objekte zu aktualisieren. Es folgt die einfache Syntax der Verwendung der UPDATE-Klausel:

String hql = "UPDATE Employee set salary = :salary "  + 
             "WHERE id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("salary", 1000);
query.setParameter("employee_id", 10);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

DELETE-Klausel

Das DELETEKlausel kann verwendet werden, um ein oder mehrere Objekte zu löschen. Es folgt die einfache Syntax der Verwendung der DELETE-Klausel:

String hql = "DELETE FROM Employee "  + 
             "WHERE id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("employee_id", 10);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

INSERT-Klausel

HQL unterstützt INSERT INTOKlausel nur, wenn Datensätze von einem Objekt in ein anderes Objekt eingefügt werden können. Es folgt die einfache Syntax der Verwendung der INSERT INTO-Klausel:

String hql = "INSERT INTO Employee(firstName, lastName, salary)"  + 
             "SELECT firstName, lastName, salary FROM old_employee";
Query query = session.createQuery(hql);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

Aggregierte Methoden

HQL unterstützt eine Reihe von Aggregatmethoden, ähnlich wie SQL. Sie funktionieren in HQL genauso wie in SQL. Im Folgenden finden Sie eine Liste der verfügbaren Funktionen:

Sr.Nr.	Funktionen & Beschreibung
1	avg(property name) Der Durchschnitt des Wertes einer Immobilie
2	count(property name or *) Die Häufigkeit, mit der eine Eigenschaft in den Ergebnissen vorkommt
3	max(property name) Der Maximalwert der Eigenschaftswerte
4	min(property name) Der Mindestwert der Eigenschaftswerte
5	sum(property name) Die Gesamtsumme der Eigenschaftswerte

Das distinctDas Schlüsselwort zählt nur die eindeutigen Werte im Zeilensatz. Die folgende Abfrage gibt nur eine eindeutige Anzahl zurück -

String hql = "SELECT count(distinct E.firstName) FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

Paginierung mit Abfrage

Es gibt zwei Methoden der Abfrageschnittstelle für die Paginierung.

Sr.Nr.	Methode & Beschreibung
1	Query setFirstResult(int startPosition) Diese Methode verwendet eine Ganzzahl, die die erste Zeile in Ihrer Ergebnismenge darstellt, beginnend mit Zeile 0.
2	Query setMaxResults(int maxResult) Diese Methode weist Hibernate an, eine feste Nummer abzurufen maxResults von Objekten.

Mit den beiden oben genannten Methoden können wir eine Paging-Komponente in unserer Web- oder Swing-Anwendung erstellen. Das folgende Beispiel können Sie erweitern, um 10 Zeilen gleichzeitig abzurufen:

String hql = "FROM Employee";
Query query = session.createQuery(hql);
query.setFirstResult(1);
query.setMaxResults(10);
List results = query.list();