Hibernate Query Language (HQL) ist eine objektorientierte Abfragesprache, ähnlich wie SQL, aber anstatt mit Tabellen und Spalten zu arbeiten, eignet sich HQL für persistente Objekte und deren Eigenschaften. HQL-Abfragen werden von Hibernate in herkömmliche SQL-Abfragen umgewandelt, die Vorgänge in der Datenbank ausführen.
Während es möglich ist, SQL-Anweisungen direkt zu verwenden und Hibernate natives SQL zu verwenden, wird die Verwendung von HQL empfohlen, um Probleme bei der Datenbankportabilität so weit wie möglich zu vermeiden und die Vorteile der SQL-Generierungs- und Caching-Strategien von Hibernate zu nutzen.
Bei Schlüsselwörtern wie SELECT, FROM und WHERE wird die Groß-/Kleinschreibung nicht beachtet, aber bei Attributen wie Tabellennamen und Spaltennamen wird in HQL die Groß-/Kleinschreibung beachtet.
FROM-Anweisung
Verwenden Sie die FROM-Klausel, wenn Sie ein vollständiges persistentes 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 results = query.list();
Wenn Sie einen Klassennamen in HQL vollständig qualifizieren müssen, geben Sie einfach das Paket und den Klassennamen wie folgt an:
String hql = "FROM com.hibernatebook.criteria.Employee"; Query query = session.createQuery(hql); List results = query.list();
AS-Anweisung Die
AS-Klausel kann verwendet werden, um HQL-Abfragen, die Klassen zugewiesen sind, mit einem Alias zu versehen, insbesondere wenn es sich um sehr lange Abfragen handelt. Unser vorheriges einfaches Beispiel ist beispielsweise das Folgende:
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 direkt im nachfolgenden Klassennamen einen Alias angeben, wie unten gezeigt:
String hql = "FROM Employee E"; Query query = session.createQuery(hql); List results = query.list();
SELECT-Klausel Die
SELECT-Klausel bietet mehr Kontrolle über die Ergebnismenge als die FROM-Klausel. Wenn Sie mehrere Eigenschaften eines Objekts und nicht des gesamten Objekts abrufen möchten, verwenden Sie die SELECT-Klausel. Hier ist eine einfache Syntax, die eine SELECT-Anweisung verwendet, um nur das FIRST_NAME-Feld eines Employee-Objekts abzurufen:
String hql = "SELECT E.firstName FROM Employee E"; Query query = session.createQuery(hql); List results = query.list();
Es ist erwähnenswert, dass Employee.firstName hier eine Eigenschaft von ist das Employee-Objekt und nicht ein Feld der EMPLOYEE-Tabelle.
WHERE-Klausel
Wenn Sie die spezifischen aus dem Speicher zurückgegebenen Objekte eingrenzen möchten, können Sie die WHERE-Klausel verwenden. Hier ist eine einfache Syntax mit 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 einer HQL-Abfrage zu sortieren, müssen Sie die ORDER BY-Klausel verwenden. Sie können die Ergebnisse im Ergebnissatz in aufsteigender (ASC) oder absteigender (DESC) Reihenfolge nach jeder Eigenschaft im Objekt sortieren. Hier ist eine einfache Syntax mit 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 einem Attribut sortieren möchten, fügen Sie einfach die zusätzlichen Attribute mithilfe von Komma zur BY-Klausel hinzu getrennt am Ende des Befehls, wie unten gezeigt:
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
Diese Klausel ermöglicht es Hibernate, Datenbanken und Gruppen basierend auf dem Wert seiner Eigenschaften abzurufen. Informationen extrahieren und verwenden die Ergebnisse normalerweise, um einen Gesamtwert einzubeziehen. Hier ist eine sehr einfache Syntax mit einer 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();Verwendung benannter Parameter
Hibernate unterstützt benannte Parameter in seiner HQL-Abfrage. Dies macht es einfach, HQL-Abfragen zu schreiben, die Eingaben vom Benutzer akzeptieren, ohne sich gegen SQL-Injection-Angriffe verteidigen zu müssen. Hier ist eine einfache Syntax mit benannten Parametern:
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
Batchaktualisierungen sind neu in HQL mit Hibernate 3, und Löschungen funktionieren in Hibernate 3 anders als in Hibernate2. Die Query-Schnittstelle enthält jetzt eine Methode namensexecuteUpdate() zum Ausführen von HQL UPDATE- oder DELETE-Anweisungen.
Die UPDATE-Klausel kann verwendet werden, um eine oder mehrere Eigenschaften in einem oder mehreren Objekten zu aktualisieren. Das Folgende ist eine einfache Syntax unter 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 Die DELETE-Klausel kann zum Löschen eines oder mehrerer Objekte verwendet werden. Hier ist eine einfache Syntax mit 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);HQL unterstützt die INSERT INTO-Klausel nur dort, wo Datensätze von einem Objekt in ein anderes Objekt eingefügt werden können. Das Folgende ist eine einfache Syntax für die 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);HQL unterstützt mehrere Aggregationsmethoden, ähnlich wie SQL. Sie funktionieren in HQL genauso wie in SQL und hier ist die Liste der verfügbaren Funktionen:
String hql = "SELECT count(distinct E.firstName) FROM Employee E"; Query query = session.createQuery(hql); List results = query.list();
Es gibt zwei Methoden zum Paginieren der Abfrageschnittstelle.
String hql = "FROM Employee"; Query query = session.createQuery(hql); query.setFirstResult(1); query.setMaxResults(10); List results = query.list();
Hibernate bietet eine alternative Möglichkeit zum Bearbeiten von Objekten und sequenziellen Daten, die in RDBMS-Tabellen verfügbar sind. Eine dieser Methoden ist die Standard-API, mit der Sie programmgesteuert ein Standardabfrageobjekt erstellen und Filterregeln und logische Bedingungen anwenden können.
Die Sitzungsschnittstelle von Hibernate stellt ein Criteria-Objekt bereit, das zum Erstellen einer Instanz eines persistenten Objekts verwendet werden kann, das zurückgegeben wird, wenn die Anwendung eine bedingte Abfrage für die Methode createCriteria() eines Criteria-Objekts durchführt.
Criteria cr = session.createCriteria(Employee.class); List results = cr.list();
Sie können die Methode add() verwenden, um Einschränkungsabfragen zum Criteria-Objekt hinzuzufügen. Nachfolgend finden Sie ein Beispiel zum Hinzufügen eines Grenzwerts, wobei die zurückgegebenen Gehaltsdatensätze dem Jahr 2000 entsprechen:
Criteria cr = session.createCriteria(Employee.class);
cr.add(Restrictions.eq("salary", 2000));
List results = cr.list();Criteria cr = session.createCriteria(Employee.class);
// To get records having salary more than 2000
cr.add(Restrictions.gt("salary", 2000));
// To get records having salary less than 2000
cr.add(Restrictions.lt("salary", 2000));
// To get records having fistName starting with zara
cr.add(Restrictions.like("firstName", "zara%"));
// Case sensitive form of the above restriction.
cr.add(Restrictions.ilike("firstName", "zara%"));
// To get records having salary in between 1000 and 2000
cr.add(Restrictions.between("salary", 1000, 2000));
// To check if the given property is null
cr.add(Restrictions.isNull("salary"));
// To check if the given property is not null
cr.add(Restrictions.isNotNull("salary"));
// To check if the given property is empty
cr.add(Restrictions.isEmpty("salary"));
// To check if the given property is not empty
cr.add(Restrictions.isNotEmpty("salary"));
可以创建AND或OR使用LogicalExpression限制如下条件：
Criteria cr = session.createCriteria(Employee.class);
Criterion salary = Restrictions.gt("salary", 2000);
Criterion name = Restrictions.ilike("firstNname","zara%");
// To get records matching with OR condistions
LogicalExpression orExp = Restrictions.or(salary, name);
cr.add( orExp );
// To get records matching with AND condistions
LogicalExpression andExp = Restrictions.and(salary, name);
cr.add( andExp );
List results = cr.list();Es gibt auch Standardschnittstellen und zwei Methoden für Paging.
public Criteria setMaxResults(int maxResults)
采用上述两种方法一起，我们可以在我们的网站或Swing应用程序构建一个分页组件。下面是例子，可以扩展来每次获取10行：
Criteria cr = session.createCriteria(Employee.class); cr.setFirstResult(1); cr.setMaxResults(10); List results = cr.list();
排序的结果：
标准的API提供了org.hibernate.criterion.Order类排序按升序或降序排列你的结果集，根据对象的属性。这个例子演示了如何使用Order类的结果集进行排序：
Criteria cr = session.createCriteria(Employee.class);
// To get records having salary more than 2000
cr.add(Restrictions.gt("salary", 2000));
// To sort records in descening order
crit.addOrder(Order.desc("salary"));
// To sort records in ascending order
crit.addOrder(Order.asc("salary"));
List results = cr.list();预测与聚合：
该Criteria API提供了一个org.hibernate.criterion.Projections类可用于获取平均值，最大值或最小值的属性值。Projections类是类似于类限制，因为它提供了几个静态工厂方法用于获得Projection 实例。 provides the
以下是涉及不同的方案的一些例子，可按规定使用：
Criteria cr = session.createCriteria(Employee.class);
// To get total row count.
cr.setProjection(Projections.rowCount());
// To get average of a property.
cr.setProjection(Projections.avg("salary"));
// To get distinct count of a property.
cr.setProjection(Projections.countDistinct("firstName"));
// To get maximum of a property.
cr.setProjection(Projections.max("salary"));
// To get minimum of a property.
cr.setProjection(Projections.min("salary"));
// To get sum of a property.
cr.setProjection(Projections.sum("salary"));Criteria Queries 例子：
考虑下面的POJO类：
public class Employee {
private int id;
private String firstName;
private String lastName;
private int salary;
public Employee() {}
public Employee(String fname, String lname, int salary) {
this.firstName = fname;
this.lastName = lname;
this.salary = salary;
}
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() {
return salary;
}
public void setSalary( int salary ) {
this.salary = salary;
}
}让我们创建下面的EMPLOYEE表来存储Employee对象：
create table EMPLOYEE ( id INT NOT NULL auto_increment, first_name VARCHAR(20) default NULL, last_name VARCHAR(20) default NULL, salary INT default NULL, PRIMARY KEY (id) );
以下将被映射文件。
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="Employee" table="EMPLOYEE">
<meta attribute="class-description">
This class contains the employee detail.
</meta>
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="firstName" column="first_name" type="string"/>
<property name="lastName" column="last_name" type="string"/>
<property name="salary" column="salary" type="int"/>
</class>
</hibernate-mapping>最后，我们将创建应用程序类的main（）方法来运行，我们将使用Criteria查询的应用程序：
import 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.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
import org.hibernate.criterion.Projections;
import org.hibernate.cfg.Configuration;
public class ManageEmployee {
private static SessionFactory factory;
public static void main(String[] args) {
try{
factory = new Configuration().configure().buildSessionFactory();
}catch (Throwable ex) {
System.err.println("Failed to create sessionFactory object." + ex);
throw new ExceptionInInitializerError(ex);
}
ManageEmployee ME = new ManageEmployee();
/* Add few employee records in database */
Integer empID1 = ME.addEmployee("Zara", "Ali", 2000);
Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
Integer empID3 = ME.addEmployee("John", "Paul", 5000);
Integer empID4 = ME.addEmployee("Mohd", "Yasee", 3000);
/* List down all the employees */
ME.listEmployees();
/* Print Total employee's count */
ME.countEmployee();
/* Print Toatl salary */
ME.totalSalary();
}
/* Method to CREATE an employee in the database */
public Integer addEmployee(String fname, String lname, int salary){
Session session = factory.openSession();
Transaction tx = null;
Integer employeeID = null;
try{
tx = session.beginTransaction();
Employee employee = new Employee(fname, lname, salary);
employeeID = (Integer) session.save(employee);
tx.commit();
}catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
}finally {
session.close();
}
return employeeID;
}
/* Method to READ all the employees having salary more than 2000 */
public void listEmployees( ){
Session session = factory.openSession();
Transaction tx = null;
try{
tx = session.beginTransaction();
Criteria cr = session.createCriteria(Employee.class);
// Add restriction.
cr.add(Restrictions.gt("salary", 2000));
List employees = cr.list();
for (Iterator iterator =
employees.iterator(); iterator.hasNext();){
Employee employee = (Employee) iterator.next();
System.out.print("First Name: " + employee.getFirstName());
System.out.print(" Last Name: " + employee.getLastName());
System.out.println(" Salary: " + employee.getSalary());
}
tx.commit();
}catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
/* Method to print total number of records */
public void countEmployee(){
Session session = factory.openSession();
Transaction tx = null;
try{
tx = session.beginTransaction();
Criteria cr = session.createCriteria(Employee.class);
// To get total row count.
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();
}finally {
session.close();
}
}
/* Method to print sum of salaries */
public void totalSalary(){
Session session = factory.openSession();
Transaction tx = null;
try{
tx = session.beginTransaction();
Criteria cr = session.createCriteria(Employee.class);
// To get total salary.
cr.setProjection(Projections.sum("salary"));
List totalSalary = cr.list();
System.out.println("Total Salary: " + totalSalary.get(0) );
tx.commit();
}catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
}编译和执行：
下面是步骤来编译并运行上述应用程序。请确保您已在进行的编译和执行之前，适当地设置PATH和CLASSPATH。
创建hibernate.cfg.xml配置文件中配置章节解释。
创建Employee.hbm.xml映射文件，如上图所示。
创建Employee.java源文件，如上图所示，并编译它。
创建ManageEmployee.java源文件，如上图所示，并编译它。
执行ManageEmployee二进制运行程序.
会得到以下结果，并记录将创建在EMPLOYEE表中。
$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........ First Name: Daisy Last Name: Das Salary: 5000 First Name: John Last Name: Paul Salary: 5000 First Name: Mohd Last Name: Yasee Salary: 3000 Total Coint: 4 Total Salary: 15000
如果检查EMPLOYEE表，它应该记录如下：
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+ | id | first_name | last_name | salary | +----+------------+-----------+--------+ | 14 | Zara | Ali | 2000 | | 15 | Daisy | Das | 5000 | | 16 | John | Paul | 5000 | | 17 | Mohd | Yasee | 3000 | +----+------------+-----------+--------+ 4 rows in set (0.00 sec)
更多在Java的Hibernate框架中对数据库数据进行查询操作相关文章请关注PHP中文网！
Mul-Anweisungsverwendung
Datei im DAT-Format
So passen Sie die Helligkeit des Computerbildschirms an
Wie man die Fans von Douyin schnell und effektiv steigert
So schließen Sie die App-Ressourcenbibliothek
Einführung in die Lightning-Schnittstelle
Vue verweist auf JS-Dateien
Häufig verwendete Permutations- und Kombinationsformeln
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
