Hibernate Query Language (HQL) ist eine objektorientierte Abfragesprache, die SQL ähnelt, jedoch nicht Operationen auf Tabellen und Spalten. HQL ist für anhaltende Objekte und ihre Eigenschaften geeignet. HQL -Abfragen werden vom Winterschlaf in herkömmliche SQL -Abfragen konvertiert, die Operationen in der Datenbank im Kreis ausführen.
Obwohl es möglich ist, native SQL direkt mit SQL -Anweisungen und Hibernate zu verwenden, wird empfohlen, HQL zu verwenden, um den Ärger der Datenbank -Portabilität so weit wie möglich zu vermeiden und die Vorteile der SQL -Generation und -Strategien von Hibernate zu übernehmen.
Schlüsselwörter wie SELECT, SELECT, FROM UND WO sind Fallempfindlichkeit, aber Eigenschaften wie Tabellennamen und Spaltennamen werden in HQL-sensitiv unterschieden.
Aus Aussage
Verwenden Sie die From -Klausel, wenn Sie ein vollständiges anhaltendes Objekt in den Speicher laden möchten. Hier ist eine einfache Syntax mit der From -Klausel:
String hql = "From Employee"; Query query = session.createquery (HQL); list reserts = query.list ();Wenn Sie einen Klassennamen in HQL vollständig qualifizieren müssen, geben Sie einfach den folgenden Paket- und Klassennamen an:
String hql = "von com.hibernatebook.Criteria.Amployee"; Query query = session.createquery (HQL); list resultes = query.list ();
Als Aussage
Die AS -Klausel kann verwendet werden, um HQL -Abfragen in einer Klasse zuzuweisen, insbesondere wenn es sehr lange Abfragen gibt. Zum Beispiel sind unsere kurzen Beispiele oben die folgenden:
String hql = "From Employee as E"; query query = session.createquery (HQL); list results = query.list ();
Das AS -Schlüsselwort ist optional und Sie können auch einen Alias direkt im nachfolgenden Klassennamen angeben, wie unten gezeigt:
String hql = "Aus Mitarbeitern e"; query query = session.createquery (HQL); list reserts = query.list ();
Klausel auswählen
Die Auswahlklausel bietet mehr Kontrolle als den Ergebnissatz der From -Klausel. Wenn Sie anstelle des gesamten Objekts mehrere Eigenschaften des Objekts erhalten möchten, verwenden Sie die Auswahlklausel. Hier ist eine einfache Syntax, mit der eine SELECT -Anweisung verwendet werden kann, um das Feld des Mitarbeiterobjekts zu erhalten.
String hql = "SELECT E.FIRSTNAME aus dem Mitarbeiter e"; query query = session.createquery (HQL); listenergebnisse = query.list ();
Es ist erwähnenswert, dass Mitarbeiter hier ein Attribut des Mitarbeiterobjekts ist, nicht ein Feld der Mitarbeitertabelle.
Wo Klausel
Wenn Sie das aus dem Speicher zurückgegebene spezifische Objekt eingrenzen möchten, können Sie die WHERE -Klausel verwenden. Hier ist eine einfache Syntax mit der WHERE -Klausel:
String hql = "Aus Mitarbeitern e wobei E.Id = 10"; Abfrage query = session.createquery (HQL); LIST ERGEBNISSE = query.list ();
Bestellung nach Klausel
Um die Ergebnisse einer HQL -Abfrage zu sortieren, müssen Sie die Bestellung per Klausel verwenden. Sie können die Ergebnisse zum Aufsteigen (ASC) oder zum Abstieg (Desc) im Ergebnis sortieren, indem Sie die Ergebnisse in jedem Attribut des Objekts sortieren. Hier ist eine einfache Syntax mit der Order By -Klausel:
String hql = "Von Mitarbeitern e wobei E.Id> 10 Order von E.Salary Desc"; Query query = session.createquery (HQL); list resultes = query.list ();
Wenn Sie mehr als eine Eigenschaft sortieren möchten, fügen Sie einfach zusätzliche Eigenschaften zum Ende des Befehls hinzu, das durch eine Klausel mit Kommas getrennt ist, wie unten gezeigt:
String hql = "Aus Mitarbeitern e wobei E.Id> 10" + "Order von E.Firstname Desc, E.Salary Desc"; Query Query = Session
Gruppe nach Klausel
Diese Klausel ermöglicht die Extraktion von Informationen aus der Datenbank und der Gruppe der Attributwerte von Hibernate und verwendet das Ergebnis normalerweise, um den Gesamtwert einzuschließen. Hier ist eine einfache Syntax mit der Gruppe nach Klausel:
String hql = "Summe (E.Salary), E.FirtName von Mitarbeiter e" + "Gruppe von E.Firstname"; Query query = session.createquery (HQL); list ergebnisse = query.list ();
Verwenden Sie benannte Parameter
Hibernate wird in seinen HQL -Abfrageparametern unterstützt. Dies erleichtert einfach, Eingaben von Benutzern zu schreiben und zu akzeptieren, ohne sich gegen HQL -Abfragen bei SQL -Injektionsangriffen zu verteidigen. Hier ist eine einfache Syntax mit den benannten Parametern:
String hql = "Aus Mitarbeitern e wobei e.id =: Employee_id"; query query = session.createquery (HQL); query.setParameter ("Employee_id", 10); listenergebnisse = query.list (); Aktualisieren Sie die Klausel
Batch -Updates sind neue HQL mit Hibernate3 und unterschiedliche Löscharbeiten, die gleiche wie Hibernate 3 und Hibernate2. Die Abfrageschnittstelle enthält nun eine Methode namens executeUpdate () zum Ausführen von HQL -Update oder Löschen von Anweisungen.
Die Aktualisierungsklausel kann verwendet werden, um eine oder mehrere Eigenschaften in einem oder mehreren Objekten zu aktualisieren. Hier ist eine einfache Syntax mit der Aktualisierungsklausel:
String hql = "Mitarbeiter des Mitarbeiters set Gehalt =: Gehalt" + "wobei id =: Employee_id"; Query query = session.createquery (HQL); query.setParameter ("Gehalt", 1000); Abfrage.SetParameter ("Mitarbeiter_ID", 10); Klausel löschen
Mit der Löschklausel kann ein oder mehrere Objekte gelöscht werden. Hier ist eine einfache Syntax mit der Löschklausel:
String hql = "aus Mitarbeiter löschen" + "wobei id =: Employee_id"; query query = session.createquery (HQL); query.setParameter ("Employee_id", 10); int result = query.executeUpdate (); system.out.println ("Reihen betroffen:" + Ergebnis); Klausel einfügen
HQL unterstützt Einfügen in Klauseln, in denen nur Datensätze von einem Objekt in ein anderes eingefügt werden können. Hier ist eine einfache Syntax mit dem Einfügen in die Klausel:
String hql = "In Mitarbeiter einfügen (FirstName, LastName, Gehalt)" + "Wählen Sie FirstName, LastName, Gehalt von old_Employee"; query query = session.createquery (HQL); int result = query.executeUpdate ();
Aggregationsmethode
HQL unterstützt mehrere Aggregationsmethoden, ähnlich wie SQL. Sie arbeiten in HQL in SQL und der folgenden Liste der verfügbaren Funktionen auf die gleiche Weise:
Das bestimmte Schlüsselwort berechnet nur eindeutige Werte, die in dieser Zeile festgelegt sind. Die folgende Abfrage gibt nur eine einzigartige Anzahl zurück:
String hql = "SELECT COUNT (DISTECTION E.FIRSTNAME) aus Mitarbeitern e"; Query query = session.createquery (HQL); list reserts = query.list ();
Verwenden von Abfragenpagination
Es gibt zwei Methoden für Pagination -Abfragen -Schnittstellen.
Gemeinsam können Sie eine Paging -Komponente auf einer Website oder einer Swing -Anwendung erstellen. Hier ist ein Beispiel: Sie können es erweitern, um 10 Zeilen zu erhalten:
String hql = "From Employee"; Query query = session.createquery (HQL); query.setFirstresult (1); query.setMaxResults (10); listenergebnisse = query.list ();
Abfragekriterien
Hibernate bietet eine alternative Möglichkeit, Objekte und nacheinander in der RDBMS -Tabelle verfügbare Daten zu bedienen. Eine der Methoden ist die Standard -API, mit der Sie eine Standardprogrammierung für Abfragen einrichten können, mit der Filterregeln und logische Bedingungen angewendet werden können.
Die Sitzungsschnittstelle von Hibernate bietet eine Instanz einer Klasse, mit der ein zurückgegebenes persistierendes Objekt erstellt werden kann, und die Anwendung führt eine bedingte Abfrage zur Methode createcriteria () aus.
Das Folgende ist ein Beispiel für eine einfachste bedingte Abfrage, die einfach jedes Objekt zurückgibt, das der Mitarbeiterklasse entspricht.
Kriterien cr = session.createcriteria (Mitarbeiter.Class); listenergebnisse = cr.list ();
Einschränkungen und Standards:
Sie können die Methode add () verwenden, um eine Restriktionsabfrage mithilfe des Kriterienobjekts hinzuzufügen. Hier ist ein Beispiel für das Hinzufügen einer Grenze mit einem Gehaltsrendite -Rekord von 2000:
Kriterien cr = session.createcriteria (Mitarbeiter.Class); Cr.Add (restriktions.eq ("Gehalt", 2000)); listenergebnisse = cr.list ();Hier sind einige Beispiele, die verschiedene Szenarien abdecken und nach Bedarf verwendet werden können:
Kriterien Cr = Session zaracr.add (restriktions.ike ("firstname", "zara%"); // Fallempfindlichkeit der obigen Einschränkung.Cr.Add (Einschränkungen.Ilike ("FirstName", "Zara%"); // Aufzeichnungen mit dem Gehalt zwischen 1000 und 2000cr.add (Einschränkungen. nullcr.add (Einschränkungen.Isnull ("Gehalt")); // Um zu überprüfen, ob die angegebene Eigenschaft nicht nullcr.add (Einschränkungen "ist. leerecr.add (Beschränkungen.isnotEmpty ("Gehalt")); Sie können erstellen und oder ORS, um die LogicalExpression zu verwenden, um die folgenden Bedingungen einzuschränken: Kriterien Cr = Session.createcriteria (Mitarbeiter.Class); Kriterium Gehalt = Einschränkungen.GT ("Gehalt", 2000); Kriterium name = Restriktionen cr.list ();Obwohl alle oben genannten Bedingungen im vorherigen Tutorial direkt mit HQL eingeführt werden können.
Paging -Nutzungsstandards:
Es gibt auch Standardschnittstellen, zwei Methoden zur Pagination.
Zusammen mit den beiden oben genannten Methoden können wir eine Paging -Komponente auf unserer Website oder auf der Swing -Anwendung erstellen. Hier ist ein Beispiel, das erweitert werden kann, um 10 Zeilen gleichzeitig zu erhalten:
Kriterien cr = Sitzung.Createcriteria (Mitarbeiter.Class); Cr.SetFirstresult (1); Cr.SetMaxResults (10); listenergebnisse = cr.list ();
Ergebnisse sortieren:
Die Standard -API liefert die org.hiNNATE.CRITERION.ORDERSKLASSE Sortiert Ihr Ergebnis, das in aufsteigender oder absteigender Reihenfolge nach den Eigenschaften des Objekts eingestellt ist. In diesem Beispiel wird gezeigt, wie man mit dem Ergebnissatz der Auftragsklasse sortiert:
Kriterien cr = session.createcriteria (Mitarbeiter.CLASS); // Um Aufzeichnungen mit mehr als 2000Cr.Add (Einschränkungen ("Gehalt", 2000); // Aufzeichnungen in absteigender ordercrit.addorder (order.Desc ("Gehalt"); // Aufnahmeaufnahme in ordercrit (ordnungskritisch) (ordnungskritisch) (ordnungskritisch) (ordnungskritisch) (ordnungskritisch) (ordnungskritisch) (ordnungskritisch) (ordnungskritisch) ("ordnungskritisch (ordnungsgericht) () ordn. Vorhersage und Aggregation:
Die Kriterien -API liefert eine org.hibernate.criterion.Projections -Klasse, mit der die durchschnittlichen, maximalen oder minimalen Attributwerte erhalten werden können. Die Prognosenklasse ähnelt der Klassenbeschränkung, da sie mehrere statische Fabrikmethoden zum Erhalten von Projektionsinstanzen bereitstellt. Bietet die
Hier sind einige Beispiele mit unterschiedlichen Schemata, die wie vorgeschrieben verwendet werden können:
Kriterien Cr = Session Property.cr.setProjection (projections.max ("Gehalt")); // mindestens eine Eigenschaft erhalten Kriterien Abfragen Beispiel:
Betrachten Sie die folgende Pojo -Klasse:
Mitarbeiter der öffentlichen Klasse {private int id; private String FirstName; private Zeichenfolge Lastname; privates Int -Gehalt; public Employee () {} public Employee (String fname, String lName, int -Gehalt) {this.firstname = fname; this.lastName = lname; this.Salary = Gehalt; } public int getid () {return id; } public void setId (int id) {this.id = id; } public String getFirstName () {return firstname; } public void setfirstname (String first_name) {this.firstname = first_name; } public String getLastName () {return LastName; } public void setLastName (String last_name) {this.lastName = last_name; } public int getSalary () {Rückgabegehalt; } public void setSalary (Int -Gehalt) {this.Salary = Gehalt; }}Erstellen wir die folgende Mitarbeitertabelle, um das Mitarbeiterobjekt zu speichern:
table -Mitarbeiter erstellen (ID int nicht null auto_increment, First_name varchar (20) Standardnull, last_name varchar (20) Standardnull, Gehalt int Standard Null, Primärschlüssel (ID));
Im Folgenden werden Dateien abgebildet.
<? Tabelle = "Mitarbeiter"> <meta Attribute = "Klasse-De-Scription"> Diese Klasse enthält das Detail der Mitarbeiter. </meta> <id name = "id" type = "int" column = "id"> <generator/> </id> <Eigenschaft name = "FirstName" column = "first_name" type = "String"/> <Eigenschaft name = "lastname" column = "last_name" type
Schließlich erstellen wir die Main () -Methode der Anwendungsklasse, die ausgeführt werden soll, und verwenden die Kriterienabfrage für die Anwendung:
importieren java.util.list; Import Java.util.date; Import Java.util.iterator; import org.hibernate.hibernateException; import org.hibernate.session; import org.hibernate.transaction; import org.hibernate public static void main (string [] args) {try {factory = new configuration (). configure (). BuildSessionFactory (); } catch (throwable ex) {System.err.println ("SessionFactory -Objekt nicht erstellt." + ex); Neue ExecessIninitializerError (Ex) werfen; } ManagyeAmee me = new ManageAmployee (); / * Fügen Sie einige Mitarbeiterdatensätze in die Datenbank hinzu */ Integer empID1 = me.addEmPl ("Zara", "Ali", 2000); Ganzzahl empid2 = me.addOPhPer ("Daisy", "Das", 5000); Ganzzahl empid3 = me.addEmPl ("John", "Paul", 5000); Integer empid4 = me.addOPhPer ("Mohd", "Yasee", 3000); / * Auflisten Sie alle Mitarbeiter auf */ me.listOplomee (); / * Drucken Sie die Gesamtzahl des Mitarbeiters */ me.countoMepoyee (); / * TOATL -Gehalt drucken */ me.totalsalary (); } / * Methode zum Erstellen eines Mitarbeiters in der Datenbank * / public Integer addPelyee (String fname, String lName, int -Gehalt) {Session Session = Factory.OpenSession (); Transaktion TX = NULL; Integer EmployeeId = NULL; try {tx = session.beginTransaction (); Mitarbeiter Mitarbeiter = neuer Mitarbeiter (fname, lname, Gehalt); EmployeEID = (Integer) Sitzung.Save (Mitarbeiter); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E. printstacktrace (); } endlich {Session.close (); } Return EmployeEID; } / * Methode zum Lesen aller Mitarbeiter mit einem Gehalt mehr als 2000 * / public void ListOmPlumes () {Session Session = Factory.OpenSession (); Transaktion TX = NULL; try {tx = session.beginTransaction (); Kriterien Cr = Session.Createcriteria (Mitarbeiter.Class); // Einschränkung hinzufügen. Cr.Add (Restriktions.gt ("Gehalt", 2000)); List Employees = Cr.List (); für (Iterator iterator = Mitarbeiter System.out.print ("Vorname:" + Mitarbeiter.getFirstname ()); System.out.print ("Nachname:" + Mitarbeiter.getLastName ()); System.out.println ("Gehalt:" + Mitarbeiter.getSalary ()); } tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E. printstacktrace (); } endlich {Session.close (); }} / * Methode zum Drucken der Gesamtzahl der Datensätze * / public void countOPPLEMeee () {session session = factory.openSession (); Transaktion TX = NULL; try {tx = session.beginTransaction (); Kriterien Cr = Session.Createcriteria (Mitarbeiter.Class); // Um die Zeile der Reihenzahlen zu erhalten. cr.setProjection (projections.rowcount ()); List rowCount = cr.list (); System.out.println ("Total Coint:" + rowCount.get (0)); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E. printstacktrace (); } endlich {Session.close (); }} / * Methode zum Drucken der Summe von Gehältern * / public void sotalary () {session session = factory.openSession (); Transaktion TX = NULL; try {tx = session.beginTransaction (); Kriterien Cr = Session.Createcriteria (Mitarbeiter.Class); // um totales Gehalt zu bekommen. cr.setProjection (projections.sum ("Gehalt")); Liste tollalary = cr.list (); System.out.println ("Gesamtgehalt:" + Totalalary.get (0)); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E. printstacktrace (); } endlich {Session.close (); }}} Kompilieren und ausführen:
Hier sind die Schritte zum Kompilieren und Ausführen der obigen Anwendung. Bitte stellen Sie sicher, dass Sie vor dem Kompilieren und Ausführen von Pfad und Klassenpfad entsprechend festgelegt haben.
Die folgenden Ergebnisse werden erzielt und der Datensatz in der Mitarbeitertabelle erstellt.
$ java verwaltete Menschenschaft
..... Verschiedene Protokollnachrichten werden hier angezeigt ......... Vorname: Daisy Nachname: Das Gehalt: 5000First Name: John Nachname: Paul Gehalt: 5000First Name: Mohd Nachname: Yasee Gehalt: 3000Total Coint: 4Total Gehalt: 15000
Wenn Sie die Mitarbeitertabelle überprüfen, sollte sie wie folgt aufgezeichnet werden:
MySQL> SELECT * vom Mitarbeiter;
+-------------------------------+| id | First_Name | last_name | Gehalt |+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------