El lenguaje de consultas Hibernate (HQL) es un lenguaje de consulta orientado a objetos similar al SQL, pero no a las operaciones en tablas y columnas. HQL es adecuado para objetos persistentes y sus propiedades. Las consultas HQL se convierten de Hibernate a consultas SQL tradicionales, que realizan operaciones en la base de datos en el círculo.
Aunque es posible usar SQL nativo directamente con declaraciones SQL y Hibernate, se recomienda usar HQL para evitar la molestia de la portabilidad de la base de datos tanto como sea posible y adoptar las ventajas de las estrategias de generación y almacenamiento de almacenamiento SQL de Hibernate.
Palabras clave como Select, de y dónde son sensibles a la caja, pero las propiedades como los nombres de las tabla y los nombres de la columna se distinguen en HQL Sensitive.
De la declaración
Use la cláusula FOTHE si desea cargar un objeto persistente completo en la memoria. Aquí hay una sintaxis simple que usa la cláusula DESDE:
String hql = "From Employee"; Query Query = Session.CreateQuery (HQL); Lista de resultados = query.List ();Si necesita calificar completamente un nombre de clase en HQL, simplemente especifique el siguiente paquete y nombre de clase:
String hql = "de com.HibernateBook.Criteria.Employee"; Query Query = Session.CreateQuery (HQL); Lista de resultados = Query.List ();
Como declaración
La cláusula AS se puede usar para asignar alias a consultas HQL en una clase, especialmente cuando hay consultas muy largas. Por ejemplo, nuestros breves ejemplos anteriores son los siguientes:
String hql = "del empleado como e"; consulta consulta = session.createQuery (hql); list doonds = query.list ();
La palabra clave AS es opcional, y también puede especificar un alias directamente en el nombre de clase posterior, como se muestra a continuación:
String hql = "de Employee E"; Query Query = Session.CreateQuery (HQL); Lista de resultados = query.list ();
Seleccionar cláusula
La cláusula SELECT proporciona más control que el conjunto de resultados de la cláusula FOT. Si desea obtener varias propiedades del objeto en lugar de todo el objeto, use la cláusula SELECT. Aquí hay una sintaxis simple para usar una instrucción SELECT para obtener el objeto Empleado solo el campo First_Name:
String hql = "Seleccione E.FirstName de Employee E"; Query Query = Session.CreateQuery (HQL); Lista de resultados = query.List ();
Vale la pena señalar que aquí, Employee.FirstName es un atributo del objeto del empleado, no un campo de la tabla de empleados.
Donde cláusula
Si desea reducir el objeto específico devuelto del almacenamiento, puede usar la cláusula WHERE. Aquí hay una simple sintaxis usando la cláusula WHERE:
Cadena hql = "del empleado e donde e.id = 10"; consulta Query = session.createQuery (hql); list resultados = query.list ();
Ordenar por cláusula
Para ordenar los resultados de una consulta HQL, deberá usar el pedido por cláusula. Puede ordenar los resultados en Ascending (ASC) o descendente (DESC) en el conjunto de resultados clasificando los resultados en cualquier atributo del objeto. Aquí hay una sintaxis simple que usa la cláusula de orden por orden:
Cadena hql = "del empleado e donde e.id> 10 orden por e.salary desc"; consulta consulta = session.createQuery (hql); list resultados = query.list ();
Si desea ordenar en más de una propiedad, simplemente agregará propiedades adicionales al final del comando separado por una cláusula con comas, como se muestra a continuación:
String hql = "del empleado E donde E.id> 10" + "Orden por E.FirstName Desc, E.SALARY DESC"; QUERY QUERY = Session.CreateQuery (HQL); Lista de resultados = Query.List ();
Grupo por cláusula
Esta cláusula permite la extracción de información de la base de datos y el grupo de valores basados en atributos de Hibernate, y generalmente utiliza el resultado para incluir el valor total. Aquí hay una sintaxis simple que usa la cláusula Group by:
String hql = "Seleccionar suma (E.SALARY), E.FirtName del empleado E" + "Grupo por E.FirstName"; Query Query = Session.CreateQuery (HQL); Lista de resultados = Query.List ();
Usar parámetros con nombre
Hibernate es compatible con sus parámetros de consulta HQL. Esto facilita la escritura y acepta los aportes de los usuarios sin tener que defenderse de las consultas HQL en los ataques de inyección SQL. Aquí hay una sintaxis simple usando parámetros con nombre:
String hql = "De Employee E Where E.id =: Employee_id"; Query Query = Session.CreateQuery (HQL); Query.SetParameter ("Employee_id", 10); Lista de resultados = Query.List (); Cláusula de actualización
Las actualizaciones de lotes son nuevos HQL con Hibernate3 y diferentes trabajos de eliminación, lo mismo que Hibernate 3 y Hibernate2. La interfaz de consulta ahora contiene un método llamado ExecuteUpdate () para ejecutar la actualización de HQL o eliminar la declaración.
La cláusula de actualización se puede usar para actualizar una o más propiedades en uno o más objetos. Aquí hay una sintaxis simple usando la cláusula de actualización:
String hql = "Update Employee set salary =: salario" + "donde id =: empleado_id"; consulta Query = session.createQuery (hql); query.setParameter ("salario", 1000); query.setParameter ("Employee_id", 10); int resultado = Query.ExecuteUpdate (); System.out.PRIntln ("Rows Aftect:" Result); Eliminar cláusula
La cláusula de eliminación se puede usar para eliminar uno o más objetos. Aquí hay una sintaxis simple que usa la cláusula de eliminación:
String hql = "Eliminar del empleado" + "donde id =: empleado_id"; consulta Query = session.createQuery (HQL); Query.SetParameter ("Employee_id", 10); int dente = Query.ExCuteUpdate (); System.Println ("Rows afectó:" + resultado); Cláusula de inserción
HQL admite insertar en cláusulas donde solo los registros se pueden insertar de un objeto a otro. Aquí hay una sintaxis simple usando la cláusula Insertar en:
String hql = "insertar en empleado (firstName, LastName, salario)" + "Seleccione FirstName, LastName, Salario de Old_Employee"; Query Query = Session.CreateQuery (HQL); int resultado = Query.ExeCuteUpdate (); System.out.pintln ("ROWS Afected:" + Result); Método de agregación
HQL admite múltiples métodos de agregación, similares a SQL. Funcionan en HQL de la misma manera en SQL y la siguiente lista de características disponibles:
La palabra clave distinta solo calcula valores únicos establecidos en esta línea. La siguiente consulta devolverá solo un recuento único:
String hql = "seleccione recuento (distinto e.firstName) de empleado e"; consulta consultación = session.createQuery (HQL); List resultados = query.list ();
Usando la paginación de consultas
Hay dos métodos para las interfaces de consulta de paginación.
Juntos, puede crear un componente de paginación en un sitio web o una aplicación Swing. Aquí hay un ejemplo, puede extenderlo para obtener 10 líneas:
String hql = "From Employee"; Query Query = Session.CreateQuery (HQL); Query.SetFirStresult (1); Query.SetMaxResults (10); List Results = Query.List ();
Criterio de consulta
Hibernate proporciona una forma alternativa de operar objetos y datos secuencial disponibles en la tabla RDBMS. Uno de los métodos es la API estándar, que le permite establecer una programación de objetos de consulta estándar que puede aplicar reglas de filtrado y condiciones lógicas.
La interfaz de sesión de Hibernate proporciona una instancia de una clase que puede usarse para crear un objeto persistente devuelto, y la aplicación ejecuta una consulta condicional al método CreateCriteria ().
El siguiente es un ejemplo de una consulta condicional más simple que simplemente devolverá cada objeto correspondiente a la clase de empleados.
Criterios cr = session.createCriteria (Employee.Class); Lista de resultados = CR.List ();
Limitaciones y estándares:
Puede usar el método add () para agregar consulta de restricción utilizando el objeto de criterios. Aquí hay un ejemplo de agregar un límite con un registro de retorno salarial igual a 2000:
Criterios cr = session.createCriteria (empleado.class); cr.add (restrictions.eq ("salario", 2000)); list doonds = cr.list ();Aquí hay algunos ejemplos que cubren diferentes escenarios y se pueden usar según sea necesario:
Criteria cr = session.createCriteria(Employee.class);// To get records having salary more than 2000cr.add(Restrictions.gt("salary", 2000));// To get records having salary less than 2000cr.add(Restrictions.lt("salary", 2000));// To get records having fistName starting with zaracr.Add (restrictions.ike ("FirstName", "Zara%")); // Forma sensible de casos de la restricción anterior.CR.Add (restrictions.ilike ("FirstName", "Zara%")); // para obtener registros que tienen salarios en 1000 y 2000c.add (restricciones.between ("salary", 1000, 2000)); nullcr.add (restrictions.isNull ("salario")); // para verificar si la propiedad dada no es nullcr.add (restrictions.isNotNull ("salario")); // para verificar si la propiedad dada es vacíacR.add (restrictions.isEmpty ("salario")); // para verificar si la propiedad dada no es la propiedad dada no es vacíaCR.Add (restricciones.IsnotEmpty ("salario")); Puede crear y ors para usar LogicalExpression para restringir las siguientes condiciones: criterios cr = session.createCriteria (empleado.class); Criterio salario = restrictions.gt ("salario", 2000); Criterion name = restrictions.Ilike ("FirstNname", "Zara%"); // para obtener registros que coincidan con o condicionionSlogicalExpression oexp = restrictions.or (salario, nombre); cr.add (oexp); // para obtener registros con condiciones y condicionsLogicalExPression y Exexps.Aunque todas las condiciones anteriores se pueden introducir directamente utilizando HQL en el tutorial anterior.
Estándares de uso de la paginación:
También hay interfaces estándar, dos métodos para la paginación.
Junto con los dos métodos anteriores, podemos crear un componente de paginación en nuestro sitio web o aplicación Swing. Aquí hay un ejemplo, que se puede extender para obtener 10 filas a la vez:
Criterios cr = session.createCriteria (empleado.class); CR.SetFirStresult (1); CR.SetMaxResults (10); Lista de resultados = CR.List ();
Resultados de clasificación:
La API estándar proporciona la clase org.hibernate.criterion.Order Ordena su resultado establecido en orden ascendente o descendente, de acuerdo con las propiedades del objeto. Este ejemplo demuestra cómo clasificar el uso del conjunto de resultados de la clase de pedido:
Criterios cr = session.createCriteria (empleado.class); // para obtener registros que tienen ventas más de 2000cr.add (restrictions.gt ("salario", 2000))); // para clasificar los registros en descendente OrderCrit.Addorder (orden.desc ("salario"); // para clasificar registros en ascendentes en ascendente. cr.list (); Predicción y agregación:
La API de criterios proporciona una clase org.hibernate.criterion.projections que puede usarse para obtener los valores de atributo promedio, máximo o mínimo. La clase de proyecciones es similar a la limitación de clase porque proporciona varios métodos de fábrica estática para obtener instancias de proyección. Proporciona el
Aquí hay algunos ejemplos que involucran diferentes esquemas que se pueden usar según lo prescrito:
Criterios cr = session.createCriteria (empleado.class); // para obtener un recuento de fila total total. Property.CR.SetProyection (Projections.Max ("Salario")); // para obtener mínimo de una propiedad.CR.SetProyection (proyections.min ("salario")); // para obtener la suma de una propiedad.cr.setProyection (proyects.sum ("salario")); Ejemplo de consultas de criterios:
Considere la siguiente clase POJO:
Empleado de clase pública {private int id; cadena privada FirstName; cadena privada lastname; salario privado int; Public Employee () {} Public Employee (String fname, String lname, int salario) {this.firstname = fname; this.lastName = lname; this.salary = salario; } 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 () {salario de retorno; } public void setSalary (int salario) {this.salary = salary; }}Creemos la siguiente tabla de empleados para almacenar el objeto del empleado:
Crear tabla empleado (id int no null auto_incement, first_name varchar (20) predeterminado NULL, last_name varchar (20) predeterminado nulo, salario int predeterminado nulo, clave primaria (id));
Los siguientes se asignarán archivos.
<? xml versión = "1.0" encoding = "utf-8"?> <! DOCTYPE Hibernate-Mapping público "-// Hibernate/Hibernate Mapping dtd // en" "http://wwww.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <HiCercnate-mapping> <calse name = "empleado" table = "Empleado"> <meta attribute = "clase-descripción"> Esta clase contiene el detalle del empleado. </meta> <id name = "id" type = "int" column = "id"> <generador/> </id> <propiedad name = "firstName" column = "first_name" type = "string"/> <Property name = "LastName" column = "Last_name" type = "String"/> <Property name = "salary" column = "salary type =" int "/> <class> <</class> </hibber
Finalmente, crearemos el método Main () de la clase de aplicación para ejecutarse, y utilizaremos la consulta de criterios para la aplicación:
import java.util.list; import java.util.date; import java.util.iterator; importar org.hibernate.HibernateException; importar org.hibernate.session; importar org.hibernate.transaction; import org.hibernate.sessionFactory; import org.hibernate.criteria; import. public static void main (string [] args) {try {factory = new Configuration (). configure (). BuildSessionFactory (); } catch (showable EX) {System.err.println ("No se pudo crear el objeto SessionFactory." + EX); arrojar nuevos excepcionios de excepcionios (ex); } ManageMloyee ME = new ManageMloyee (); / * Agregar pocos registros de empleados en la base de datos */ Integer Empid1 = me.addemployee ("Zara", "Ali", 2000); Integer empid2 = me.addemployee ("margarita", "das", 5000); Integer empid3 = me.addemployee ("John", "Paul", 5000); Integer empid4 = me.addemployee ("mohd", "yasee", 3000); / * Enumere a todos los empleados */ me.listEmployee (); / * Imprimir el recuento total del empleado */ me.countEmployee (); / * Imprimir salario toatl */ me.totalSalary (); } / * Método para crear un empleado en la base de datos * / public Integer AddEmployee (String fname, String lname, int salario) {session session = factory.opensession (); Transacción tx = nulo; Integer EmployeeId = NULL; intente {tx = session.beGinTransaction (); Empleado empleado = nuevo empleado (fname, lname, salario); EmployeeId = (Integer) Session.save (Empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); } return EmployeeId; } / * Método para leer a todos los empleados que tienen salario más de 2000 * / public void listEmployees () {session session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Criterios cr = session.createCriteria (empleado.class); // Agregar restricción. CR.Add (restrictions.gt ("salario", 2000)); Lista de empleados = CR.List (); para (iterator iterator = empleado.iterator (); iterator.hasnext ();) {empleado empleado = (empleado) iterator.next (); System.out.print ("Nombre:" + Empleado.getFirstName ()); System.out.print ("apellido:" + empleado.getLastName ()); System.out.println ("Salario:" + Empleado.getSalary ()); } tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para imprimir el número total de registros * / public void CountEmployee () {Session Session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Criterios cr = session.createCriteria (empleado.class); // para obtener un recuento de filas totales. CR.SetProyection (proyections.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 (); } finalmente {session.close (); }} / * Método para imprimir la suma de los salarios * / public void TotalSalary () {Session Session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Criterios cr = session.createCriteria (empleado.class); // para obtener salario total. cr.setProyection (proyects.sum ("salario")); List TotalStary = CR.List (); System.out.println ("Salario total:" + TotalSalary.get (0)); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }}} Compilar y ejecutar:
Estos son los pasos para compilar y ejecutar la aplicación anterior. Asegúrese de haber establecido ruta y classpath adecuadamente antes de compilar y ejecutar.
Se obtendrán los siguientes resultados y el registro se creará en la tabla de empleados.
$ Java ManagementEmployee
..... Varios mensajes de registro se mostrarán aquí ......... Nombre: Daisy Apellido: Das Salario: 5000 First Nombre: John Apellido: Paul Salario: 5000 Nombre: Mohd Apellido: Yasee Salario: 3000 TOUNTAL COINT: 4 Total Salario: 15000
Si verifica la tabla de empleados, debe registrarse de la siguiente manera:
mysql> select * de empleado;
+-----------------------------------+| ID | First_Name | Last_Name | salario |+-------------------------------------------------------------------------------------------------------------------