Hibernate Query Language (HQL) est un langage de requête orienté objet similaire à SQL, mais pas des opérations sur les tables et les colonnes. HQL convient aux objets persistants et à leurs propriétés. Les requêtes HQL sont converties de Hibernate en requêtes SQL traditionnelles, qui effectuent des opérations sur la base de données sur le cercle.
Bien qu'il soit possible d'utiliser SQL natif directement avec les instructions SQL et Hibernate, il est recommandé d'utiliser le HQL pour éviter autant que possible les tracas de la portabilité de la base de données et d'adopter les avantages de la génération et des stratégies de mise en cache SQL d'Hibernate.
Des mots clés comme Select, From and Where sont sensibles à la casse, mais les propriétés telles que les noms de table et les noms de colonnes se distinguent en sensible HQL.
De la déclaration
Utilisez la clause From si vous souhaitez charger un objet persistant complet en mémoire. Voici une syntaxe simple en utilisant la clause From:
String hql = "From Employee"; Query Query = Session.CreateeQuery (HQL); List Results = Query.List ();Si vous avez besoin de qualifier pleinement un nom de classe dans HQL, spécifiez simplement le package suivant et le nom de classe:
String hql = "de com.hibernatebook.criteria.employee"; query query = session.createeQuery (hql); list results = query.list ();
Comme déclaration
La clause AS peut être utilisée pour alimenter l'allocation aux requêtes HQL dans une classe, surtout lorsqu'il y a de très longues requêtes. Par exemple, nos brefs exemples ci-dessus sont les suivants:
String hql = "de l'employé en E"; query query = session.CreateeQuery (HQL); Liste Results = Query.List ();
Le mot clé AS est facultatif, et vous pouvez également spécifier un alias directement dans le nom de classe ultérieure, comme indiqué ci-dessous:
String hql = "From Employee E"; Query Query = Session.CreateeQuery (HQL); List Results = Query.List ();
Sélectionner la clause
La clause SELECT fournit plus de contrôle que l'ensemble de résultats de la clause From. Si vous souhaitez obtenir plusieurs propriétés de l'objet au lieu de l'objet entier, utilisez la clause SELECT. Voici une syntaxe simple pour utiliser une instruction SELECT pour obtenir un champ d'employee Just First_name Field:
String hql = "SELECT E.FirstName dans Employee E"; Query Query = Session.CreateeQuery (HQL); List Results = Query.List ();
Il convient de noter qu'ici, Employee.
Où clause
Si vous souhaitez affiner l'objet spécifique renvoyé du stockage, vous pouvez utiliser la clause WHERE. Voici une syntaxe simple utilisant la clause WHERE:
String hql = "de l'employé e où e.id = 10"; query query = session.CreateeQuery (HQL); List Results = Query.List ();
Ordre par clause
Pour trier les résultats d'une requête HQL, vous devrez utiliser la clause Order Order by. Vous pouvez trier les résultats en ascendant (ASC) ou descendant (DESC) dans le résultat défini en triant les résultats dans n'importe quel attribut de l'objet. Voici une syntaxe simple utilisant la clause Order By:
String hql = "de l'employé e où e.id> 10 ordre par e.salary desc"; query query = session.CreateeQuery (HQL); List des résultats = query.list ();
Si vous souhaitez trier par plus d'une propriété, vous allez simplement ajouter des propriétés supplémentaires à la fin de la commande séparées par une clause avec des virgules, comme indiqué ci-dessous:
String hql = "de l'employé e où e.id> 10" + "Ordre par e.firstname desc, e.salary desc"; query query = session.CreateeQuery (hql); list results = query.list ();
Groupe par clause
Cette clause permet l'extraction d'informations à partir de la base de données et du groupe des valeurs basées sur les attributs d'Hibernate, et utilise généralement le résultat pour inclure la valeur totale. Voici une syntaxe simple utilisant la clause Group By:
String hql = "select sum (e.salary), e.firtname from Employee e" + "Group by e.FirstName"; query query = session.createequery (hql); list results = query.list ();
Utiliser les paramètres nommés
Hibernate est pris en charge dans ses paramètres de requête HQL. Cela facilite l'écriture et l'acceptation des entrées des utilisateurs sans avoir à se défendre contre les requêtes HQL sur les attaques d'injection SQL. Voici une syntaxe simple utilisant des paramètres nommés:
String hql = "de l'employé e où e.id =: employee_id"; query query = session.CreateeQuery (hql); query.setParameter ("employee_id", 10); lister les résultats = query.list (); Clause de mise à jour
Les mises à jour par lots sont nouvelles HQL avec Hibernate3, et différents fonctionnent de suppression, identiques à Hibernate 3 et HiberNate2. L'interface de requête contient désormais une méthode appelée EXECUTEUPDate () pour exécuter HQL Update ou Delete Instruction.
La clause de mise à jour peut être utilisée pour mettre à jour une ou plusieurs propriétés dans un ou plusieurs objets. Voici une syntaxe simple utilisant la clause de mise à jour:
String hql = "Update Employee Set Salaire =: Salaire" + "WHERE ID =: Employee_ID"; Query Query = Session.CreateEquery (HQL); Query.SetParameter ("Salaire", 1000); Query.SetParamètre ("Employee_Id", 10); INT Result = Query.ExecuUpdate (); System.out.TratLn (Rows affecte: "+ respect); Clause de suppression
La clause de suppression peut être utilisée pour supprimer un ou plusieurs objets. Voici une syntaxe simple utilisant la clause de suppression:
String hql = "Delete de l'employé" + "où id =: employee_id"; query query = session.createequery (hql); query.setParameter ("employee_id", 10); int résultat = query.executeupdate (); system.out.println ("lignes affectées:" + résultat); Insérer la clause
HQL prend en charge l'insert dans les clauses où seuls les enregistrements peuvent être insérés d'un objet à un autre. Voici une syntaxe simple utilisant l'insert dans la clause:
String hql = "Insérer dans l'employé (FirstName, LastName, Salaire)" + "Select FirstName, LastName, Salaire From Old_Employee"; Query Query = Session.CreateeQuery (HQL); int résultat = Query.ExecuteUpDate (); System.out.println ("lignes affectées:" + résultat); Méthode d'agrégation
HQL prend en charge plusieurs méthodes d'agrégation, similaires à SQL. Ils travaillent à HQL de la même manière dans SQL et la liste suivante des fonctionnalités disponibles:
Le mot-clé distinct calcule uniquement des valeurs uniques définies sur cette ligne. La requête suivante ne renverra qu'un décompte unique:
String hql = "Select Count (distinct e.firstname) de l'employé E"; query query = session.createeQuery (HQL); List des résultats = query.list ();
Utilisation de la pagination de la requête
Il existe deux méthodes pour les interfaces de requête de pagination.
Ensemble, vous pouvez créer un composant de pagination sur un site Web ou une application swing. Voici un exemple, vous pouvez l'étendre pour obtenir 10 lignes:
String hql = "From Employee"; Query Query = Session.CreateeQuery (HQL); Query.SetFirStResult (1); query.setMaxResults (10); List Results = Query.List ();
Critères de requête
Hibernate fournit un autre moyen de faire fonctionner des objets et des données séquentiellement disponibles dans la table RDBMS. L'une des méthodes est l'API standard, qui vous permet d'établir une programmation d'objets de requête standard qui peut appliquer des règles de filtrage et des conditions logiques.
L'interface de session de HiberNate fournit une instance d'une classe qui peut être utilisée pour créer un objet persistant renvoyé, et l'application exécute une requête conditionnelle à la méthode CreateCriteria ().
Ce qui suit est un exemple d'une requête conditionnelle la plus simple qui renverra simplement chaque objet correspondant à la classe des employés.
Critères CR = Session.CreateCriteria (Employee.Class); Liste Résultats = CR.List ();
Limites et normes:
Vous pouvez utiliser la méthode Add () pour ajouter une requête de restriction à l'aide de l'objet Critères. Voici un exemple d'ajout d'une limite avec un enregistrement de retour salarial égal à 2000:
Critères CR = Session.CreateCriteria (Employee.Class); CR.Add (Restrictions.EQ ("Salaire", 2000)); List Results = CR.List ();Voici quelques exemples couvrant différents scénarios et peuvent être utilisés au besoin:
Critères CR = Session.CreateCriteria (Employee.Class); // pour obtenir des enregistrements ayant un salaire plus de 2000cr.add (restriction.gt ("salaire", 2000)); // pour obtenir des enregistrements ayant un salaire moins de 2000cr.add (restriction.lt ("salaire", 2000)); // pour obtenir des enregistrements ayant un nom de fis. zaracr.add (restrictions.like ("FirstName", "Zara%")); // Forme sensible à la casse de la restriction ci-dessus.cr.add (restrictions.ilike ("FirstName", "Zara%")); // pour obtenir des enregistrements ayant une salaire entre 1000 et 2000cr.add (restriction.between (Salary ", 1000, 2000); nullcr.add (restrictions.isnull ("salaire")); // pour vérifier si la propriété donnée n'est pas nullcr.add (restrictions.isnotnull ("salaire")); // pour vérifier si la propriété donnée est videCr.add (restriction.isempty ("SALARY")); // pour vérifier si la propriété donnée n'est pas videcr.add (restrictions.isnotempty ("salaire")); Vous pouvez créer et ou ORS pour utiliser LogicalExpression pour restreindre les conditions suivantes: Critères CR = Session.CreateCriteria (Employee.Class); Salaire critère = restrictions.gt ("salaire", 2000); Nom du critère = restrictions.ilike ("Firstnname", "Zara%"); // pour obtenir des enregistrements correspondant à ou conditionionsLogicalExpression orexp = restrictions.or (salaire, nom); cr.add (orexp); // pour obtenir des enregistrements correspondant à et des conditions de logicale Cr.List ();Bien que toutes les conditions ci-dessus puissent être introduites directement à l'aide de HQL dans le tutoriel précédent.
Normes d'utilisation de la pagination:
Il existe également des interfaces standard, deux méthodes de pagination.
Avec les deux méthodes ci-dessus, nous pouvons créer un composant de pagination sur notre site Web ou notre application Swing. Voici un exemple, qui peut être étendu pour obtenir 10 lignes à la fois:
Critères CR = Session.CreateCriteria (Employee.Class); Cr.setFirStResult (1); Cr.SetMaxResults (10); Liste Résultats = CR.List ();
Trier les résultats:
L'API standard fournit l'org.hibernate.criterion.Order Class Triant vos résultats définis dans l'ordre croissant ou décroissant, selon les propriétés de l'objet. Cet exemple montre comment trier à l'aide de l'ensemble de résultats de la classe de commande:
Critères CR = Session.CreateCriteria (employee.class); // pour obtenir des enregistrements ayant des ventes de plus de 2000cr.add (restriction.gt ("salaire", 2000)); // trier les enregistrements dans OrderCrit.AdDorder (Order.Desc ("Salaire")); // pour trier les enregistrements dans la liste ascendante. Prédiction et agrégation:
L'API des critères fournit une classe org.hibernate.criterion.projections qui peut être utilisée pour obtenir les valeurs d'attribut moyens, maximales ou minimales. La classe de projections est similaire à la limitation de la classe car elle fournit plusieurs méthodes d'usine statiques pour obtenir des instances de projection. Fournit le
Voici quelques exemples impliquant différents schémas qui peuvent être utilisés comme prescrits:
Critères CR = session.CreateCriteria (employee.class); // pour obtenir le nombre total de lignes.cr.setProjection (projections.rowCount ()); // pour obtenir la moyenne d'une propriété.cr.setProjection (projections.avg ("salaire")); // pour obtenir un comptage distinct d'un bien. propriété.cr.setprojection (projections.max ("salaire")); // pour obtenir le minimum d'une propriété.cr.setProjection (projections.min ("salaire")); // pour obtenir la somme d'une propriété.cr.setprojection (projections.sum ("salaire")); Exemple de requêtes de critères:
Considérez la classe POJO suivante:
Employé de classe publique {private int id; String privé FirstName; String privé LastName; Salaire int privé; Employee public () {} Public Employee (String fname, String lname, int salaire) {this.firstName = fname; this.lastName = lname; this.salary = salaire; } 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 salaire; } public void setsalary (int salaire) {this.salary = salaire; }}Créons la table des employés suivants pour stocker l'objet de l'employé:
Créer un employé de table (id int not null auto_increment, first_name varchar (20) par défaut null, last_name varchar (20) par défaut null, salaire int null, clé primaire (id));
Ce qui suit sera des fichiers mappés.
<? 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> table = "Employee"> <meta attribut = "class-description"> Cette classe contient le détail des employés. </ meta> <id name = "id" type = "int" chronn = "id"> <générateur /> </ id> <propriété name = "firstName" colonnen = "first_name" type = "string" /> <propriété name = "lastName" chronny = "last_name" type = "int" /> </ class> </ HOBERN-MUMNY = "Salary" Type = "int"
Enfin, nous créerons la méthode principale () de la classe d'application à exécuter, et nous utiliserons la requête des critères pour l'application:
Importer 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.essionfactory; import org.hibernate.criteria; import org.hibernate.criterion.restrictions; import org.hibernate.criterion.projections; import org.hibernate.cfg.configuration; public classe gérera, gardien de travail {privilège STATICFACTORY Factory; public static void main (String [] args) {try {factory = new Configuration (). configure (). buildSessionFactory (); } catch (Throwable ex) {System.err.println ("Échec de la création de l'objet SessionFactory." + Ex); Jetez une nouvelle exceptionIninializizerError (ex); } ManageMloyee me = new ManageMloyee (); / * Ajouter quelques enregistrements d'employés dans la base de données * / 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); / * Énumérez tous les employés * / me.listEmployee (); / * Imprimez le nombre total des employés * / me.Cousemployee (); / * Imprimer le salaire Toatl * / me.totalsalary (); } / * Méthode pour créer un employé dans la base de données * / entier public addEmployee (String fname, String lname, int salaire) {session session = factory.opencession (); Transaction tx = null; EmployeeId entier = null; try {tx = session.begintransaction (); Employé employé = nouvel employé (FNAME, LNAME, SALAIRE); EmployeeId = (entier) Session.Save (employé); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); } return EmployeeId; }! Transaction tx = null; try {tx = session.begintransaction (); Critères CR = Session.CreateCriteria (Employee.Class); // Ajouter une restriction. CR.ADD (restriction.gt ("salaire", 2000)); Liste des employés = cr.list (); pour (iterator iterator = employés.iterator (); iterator.hasnext ();) {employee employé = (employé) iterator.next (); System.out.print ("prénom:" + employee.getFirstName ()); System.out.print ("nom de famille:" + employee.getLastName ()); System.out.println ("Salaire:" + employee.getsalary ()); } tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); }} / * Méthode pour imprimer le nombre total d'enregistrements * / public void comymployee () {session session = factory.opencession (); Transaction tx = null; try {tx = session.begintransaction (); Critères CR = Session.CreateCriteria (Employee.Class); // Pour obtenir le nombre total de lignes. 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 (); } enfin {session.close (); }} / * Méthode pour imprimer la somme des salaires * / public void totalSalary () {session session = factory.opencession (); Transaction tx = null; try {tx = session.begintransaction (); Critères CR = Session.CreateCriteria (Employee.Class); // pour obtenir un salaire total. Cr.setProjection (projections.sum ("salaire")); List totalSalary = cr.list (); System.out.println ("Salaire total:" + totalsalary.get (0)); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); e.printStackTrace (); } enfin {session.close (); }}} Compiler et exécuter:
Voici les étapes pour compiler et exécuter l'application ci-dessus. Veuillez vous assurer que vous avez réglé Path et ClassPath de manière appropriée avant de compiler et d'exécuter.
Les résultats suivants seront obtenus et l'enregistrement sera créé dans le tableau des employés.
$ java managemployee
..... Divers messages de journal s'affichent ici ......... Premier nom: Daisy Nom de famille: DAS Salaire: 5000 Nom de John: John Nom: Paul Salaire: 5000 Nom de MOHD Nom de famille: Salaire Yasee: 3000 Total Coint: 4total Salaire: 15000
Si vous vérifiez le tableau des employés, il doit être enregistré comme suit:
MySQL> SELECT * à partir de l'employé;
+ ----------------------------------- + | ID | First_name | Last_name | salaire | + -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------