Willkommen zum Beispiel-Tutorial für Hibernate Native SQL Query. Wir haben uns in früheren Artikeln Hibernate Query Language und Hibernate Criteria angesehen. Heute werden wir uns Hibernate Native SQL Query mit Beispielen genauer ansehen.
Hibernate SQL Query
Hibernate bietet die Möglichkeit, native SQL-Abfragen über das SQLQuery-Objekt auszuführen. Hibernate SQL Query ist sehr praktisch, wenn wir datenbankspezifische Abfragen ausführen müssen, die nicht von der Hibernate-API unterstützt werden, wie z. B. Abfragehinweise oder das CONNECT-Schlüsselwort in der Oracle-Datenbank. Für normale Szenarien ist die Hibernate SQL-Abfrage nicht der empfohlene Ansatz, da wir die Vorteile der Hibernate-Assoziation und des hibernate first level cache verlieren. Ich werde die MySQL-Datenbank verwenden und dieselben Tabellen und Daten einrichten wie im HQL-Beispiel verwendet, daher sollten Sie sich das zuerst ansehen, um die Tabellen und die entsprechende Zuordnung der Modellklassen zu verstehen.
Hibernate Native SQL Beispiel
Für Hibernate Native SQL Query verwenden wir Session.createSQLQuery(String query), um das SQLQuery-Objekt zu erstellen und es auszuführen. Wenn Sie beispielsweise alle Datensätze aus der Employee-Tabelle lesen möchten, können Sie dies durch den folgenden Code tun.
// Vorbereitung
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.getCurrentSession();
// Alle Mitarbeiter abrufen
Transaction tx = session.beginTransaction();
SQLQuery query = session.createSQLQuery("select emp_id, emp_name, emp_salary from Employee");
List rows = query.list();
for(Object[] row : rows){
Employee emp = new Employee();
emp.setId(Long.parseLong(row[0].toString()));
emp.setName(row[1].toString());
emp.setSalary(Double.parseDouble(row[2].toString()));
System.out.println(emp);
}
Wenn wir den obenstehenden Code für die vorhandene Datenkonfiguration ausführen, wird folgende Ausgabe erzeugt.
Hibernate: select emp_id, emp_name, emp_salary from Employee
Id= 1, Name= Pankaj, Salary= 100.0, {Address= null}
Id= 2, Name= David, Salary= 200.0, {Address= null}
Id= 3, Name= Lisa, Salary= 300.0, {Address= null}
Id= 4, Name= Jack, Salary= 400.0, {Address= null}
Beachten Sie, dass die Methode list() eine Liste von Objektarrays zurückgibt. Wir müssen diese explizit in double, long usw. umwandeln. Unsere Klassen Employee und Address haben folgende Implementierungen der Methode toString().
@Override
public String toString() {
return "Id= " + id + ", Name= " + name + ", Salary= " + salary
+ ", {Address= " + address + "}";
}
@Override
public String toString() {
return "AddressLine1= " + addressLine1 + ", City=" + city
+ ", Zipcode=" + zipcode;
}
Beachten Sie, dass unsere Abfrage keine Address-Daten zurückgibt, während sie bei Verwendung der HQL-Abfrage "from Employee" auch die zugehörigen Tabellendaten zurückgibt.
Hibernate SQL-Abfrage addScalar
Hibernate verwendet ResultSetMetadata, um den Typ der Spalten, die von der Abfrage zurückgegeben werden, zu ermitteln. Aus Leistungsgründen können wir die Methode addScalar() verwenden, um den Datentyp der Spalte zu definieren. Wir erhalten jedoch weiterhin die Daten in Form eines Objektarrays.
//Alle Mitarbeiter abrufen - Beispiel für addScalar
query = session.createSQLQuery("select emp_id, emp_name, emp_salary from Employee")
.addScalar("emp_id", new LongType())
.addScalar("emp_name", new StringType())
.addScalar("emp_salary", new DoubleType());
rows = query.list();
for(Object[] row : rows){
Employee emp = new Employee();
emp.setId(Long.parseLong(row[0].toString()));
emp.setName(row[1].toString());
emp.setSalary(Double.parseDouble(row[2].toString()));
System.out.println(emp);
}
Die generierte Ausgabe bleibt gleich, jedoch sehen wir eine geringfügige Leistungsverbesserung, wenn die Datenmenge groß ist.
Hibernate Native SQL Mehrere Tabellen
Wenn wir Daten aus den Tabellen Employee und Address abrufen möchten, können wir einfach die SQL-Abfrage dafür schreiben und das Ergebnis-Set parsen.
query = session.createSQLQuery("select e.emp_id, emp_name, emp_salary,address_line1, city,
zipcode from Employee e, Address a where a.emp_id=e.emp_id");
rows = query.list();
for(Object[] row : rows){
Employee emp = new Employee();
emp.setId(Long.parseLong(row[0].toString()));
emp.setName(row[1].toString());
emp.setSalary(Double.parseDouble(row[2].toString()));
Address address = new Address();
address.setAddressLine1(row[3].toString());
address.setCity(row[4].toString());
address.setZipcode(row[5].toString());
emp.setAddress(address);
System.out.println(emp);
}
Für den obigen Code wird die produzierte Ausgabe wie folgt sein.
Hibernate: select e.emp_id, emp_name, emp_salary,address_line1, city, zipcode from Employee e, Address a where a.emp_id=e.emp_id
Id= 1, Name= Pankaj, Salary= 100.0, {Address= AddressLine1= Albany Dr, City=San Jose, Zipcode=95129}
Id= 2, Name= David, Salary= 200.0, {Address= AddressLine1= Arques Ave, City=Santa Clara, Zipcode=95051}
Id= 3, Name= Lisa, Salary= 300.0, {Address= AddressLine1= BTM 1st Stage, City=Bangalore, Zipcode=560100}
Id= 4, Name= Jack, Salary= 400.0, {Address= AddressLine1= City Centre, City=New Delhi, Zipcode=100100}
Hibernate Native SQL Entity und Join
Wir können auch die Methoden addEntity() und addJoin() verwenden, um die Daten aus der zugehörigen Tabelle mittels Tabellenverknüpfungen abzurufen. Zum Beispiel können die obigen Daten auch wie folgt abgerufen werden.
//Beispiel für Verknüpfung mit addEntity und addJoin
query = session.createSQLQuery("select {e.*}, {a.*} from Employee e join Address a ON e.emp_id=a.emp_id")
.addEntity("e",Employee.class)
.addJoin("a","e.address");
rows = query.list();
for (Object[] row : rows) {
for(Object obj : row) {
System.out.print(obj + "::");
}
System.out.println("\n");
}
//Die obige Verknüpfung gibt sowohl Employee- als auch Address-Objekte im Array zurück
for (Object[] row : rows) {
Employee e = (Employee) row[0];
System.out.println("Employee Info::"+e);
Address a = (Address) row[1];
System.out.println("Address Info::"+a);
}
{[Aliasname].*} wird verwendet, um alle Eigenschaften einer Entität zurückzugeben. Wenn wir addEntity() und addJoin() mit Verknüpfungsabfragen wie oben verwenden, gibt es sowohl die Objekte zurück, wie oben gezeigt. Die Ausgabe, die durch den obigen Code erzeugt wird, ist wie folgt.
Hibernate: select e.emp_id as emp_id1_1_0_, e.emp_name as emp_name2_1_0_, e.emp_salary as emp_sala3_1_0_, a.emp_id as emp_id1_0_1_, a.address_line1 as address_2_0_1_, a.city as city3_0_1_, a.zipcode as zipcode4_0_1_ from Employee e join Address a ON e.emp_id=a.emp_id
Id= 1, Name= Pankaj, Salary= 100.0, {Address= AddressLine1= Albany Dr, City=San Jose, Zipcode=95129}::AddressLine1= Albany Dr, City=San Jose, Zipcode=95129::
Id= 2, Name= David, Salary= 200.0, {Address= AddressLine1= Arques Ave, City=Santa Clara, Zipcode=95051}::AddressLine1= Arques Ave, City=Santa Clara, Zipcode=95051::
Id= 3, Name= Lisa, Salary= 300.0, {Address= AddressLine1= BTM 1st Stage, City=Bangalore, Zipcode=560100}::AddressLine1= BTM 1st Stage, City=Bangalore, Zipcode=560100::
Id= 4, Name= Jack, Salary= 400.0, {Address= AddressLine1= City Centre, City=New Delhi, Zipcode=100100}::AddressLine1= City Centre, City=New Delhi, Zipcode=100100::
Employee Info::Id= 1, Name= Pankaj, Salary= 100.0, {Address= AddressLine1= Albany Dr, City=San Jose, Zipcode=95129}
Address Info::AddressLine1= Albany Dr, City=San Jose, Zipcode=95129
Employee Info::Id= 2, Name= David, Salary= 200.0, {Address= AddressLine1= Arques Ave, City=Santa Clara, Zipcode=95051}
Address Info::AddressLine1= Arques Ave, City=Santa Clara, Zipcode=95051
Employee Info::Id= 3, Name= Lisa, Salary= 300.0, {Address= AddressLine1= BTM 1st Stage, City=Bangalore, Zipcode=560100}
Address Info::AddressLine1= BTM 1st Stage, City=Bangalore, Zipcode=560100
Employee Info::Id= 4, Name= Jack, Salary= 400.0, {Address= AddressLine1= City Centre, City=New Delhi, Zipcode=100100}
Address Info::AddressLine1= City Centre, City=New Delhi, Zipcode=100100
Sie können beide Abfragen im MySQL-Client ausführen und feststellen, dass die erzeugte Ausgabe gleich ist.
mysql> select e.emp_id as emp_id1_1_0_, e.emp_name as emp_name2_1_0_, e.emp_salary as emp_sala3_1_0_, a.emp_id as emp_id1_0_1_, a.address_line1 as address_2_0_1_, a.city as city3_0_1_, a.zipcode as zipcode4_0_1_ from Employee e join Address a ON e.emp_id=a.emp_id;
+--------------+----------------+----------------+--------------+----------------+-------------+---------------+
| emp_id1_1_0_ | emp_name2_1_0_ | emp_sala3_1_0_ | emp_id1_0_1_ | address_2_0_1_ | city3_0_1_ | zipcode4_0_1_ |
+--------------+----------------+----------------+--------------+----------------+-------------+---------------+
| 1 | Pankaj | 100 | 1 | Albany Dr | San Jose | 95129 |
| 2 | David | 200 | 2 | Arques Ave | Santa Clara | 95051 |
| 3 | Lisa | 300 | 3 | BTM 1st Stage | Bangalore | 560100 |
| 4 | Jack | 400 | 4 | City Centre | New Delhi | 100100 |
+--------------+----------------+----------------+--------------+----------------+-------------+---------------+
4 rows in set (0.00 sec)
mysql> select e.emp_id, emp_name, emp_salary,address_line1, city, zipcode from Employee e, Address a where a.emp_id=e.emp_id;
+--------+----------+------------+---------------+-------------+---------+
| emp_id | emp_name | emp_salary | address_line1 | city | zipcode |
+--------+----------+------------+---------------+-------------+---------+
| 1 | Pankaj | 100 | Albany Dr | San Jose | 95129 |
| 2 | David | 200 | Arques Ave | Santa Clara | 95051 |
| 3 | Lisa | 300 | BTM 1st Stage | Bangalore | 560100 |
| 4 | Jack | 400 | City Centre | New Delhi | 100100 |
+--------+----------+------------+---------------+-------------+---------+
4 rows in set (0.00 sec)
mysql>
Hibernate Native SQL-Abfrage mit Parametern
Wir können auch Parameter an die Hibernate-SQL-Abfragen übergeben, genau wie bei einem JDBC PreparedStatement. Die Parameter können sowohl über den Namen als auch über den Index gesetzt werden, wie im folgenden Beispiel gezeigt.
query = session
.createSQLQuery("select emp_id, emp_name, emp_salary from Employee where emp_id = ?");
List<Object[]> empData = query.setLong(0, 1L).list();
for (Object[] row : empData) {
Employee emp = new Employee();
emp.setId(Long.parseLong(row[0].toString()));
emp.setName(row[1].toString());
emp.setSalary(Double.parseDouble(row[2].toString()));
System.out.println(emp);
}
query = session
.createSQLQuery("select emp_id, emp_name, emp_salary from Employee where emp_id = :id");
empData = query.setLong("id", 2L).list();
for (Object[] row : empData) {
Employee emp = new Employee();
emp.setId(Long.parseLong(row[0].toString()));
emp.setName(row[1].toString());
emp.setSalary(Double.parseDouble(row[2].toString()));
System.out.println(emp);
}
Die Ausgabe des obigen Codes wäre:
Hibernate: select emp_id, emp_name, emp_salary from Employee where emp_id = ?
Id= 1, Name= Pankaj, Salary= 100.0, {Address= null}
Hibernate: select emp_id, emp_name, emp_salary from Employee where emp_id = ?
Id= 2, Name= David, Salary= 200.0, {Address= null}
Das ist alles für eine kurze Einführung in Hibernate SQL Query. Sie sollten es vermeiden, es zu verwenden, es sei denn, Sie möchten spezifische Datenbankabfragen ausführen.
Source:
https://www.digitalocean.com/community/tutorials/hibernate-native-sql-query-example