Una breve discusión de las diferencias entre hql y sql, describiendo las áreas que requieren atención especial
1. La diferencia entre hql y sql
consulta orientada a tablas de base de datos sql
consulta orientada a objetos hql
hql: seguido por from Nombre de clase + objeto de clase donde, luego use los atributos del objeto para crear condiciones
sql: from es seguido por el nombre de la tabla donde, y luego use los campos en la tabla para crear condiciones
Consulta
Cuando se utilizan consultas en Hibernate, generalmente se utilizan declaraciones de consulta Hql.
HQL (Hibernate Query Language), el lenguaje de consulta de Hibernate es muy similar a SQL. Sin embargo, la diferencia más fundamental entre HQL y SQL es que está orientado a objetos.
Debe prestar atención a los siguientes puntos al utilizar HQL:
l Sensibilidad entre mayúsculas y minúsculas
Debido a que HQL está orientado a objetos y los nombres y atributos de las clases de objetos distinguen entre mayúsculas y minúsculas, por lo que HQL distingue entre mayúsculas y minúsculas.
Ej.
Declaración HQL: from Cat as cat donde cat.id > 1; es diferente de Cat as cat donde cat.ID > 1; diferente.
l de la cláusula
Por ejemplo, de Cat, esta cláusula devuelve una instancia de objeto Cat, los desarrolladores también pueden agregarle alias, por ejemplo, de Cat como cat, para consultas múltiples. Para obtener más información, consulte lo siguiente:
de Gato como gato, Perro como perro
Otros aspectos son similares a SQL y no los repetiré aquí.
El siguiente es un ejemplo de consulta en Hibernate.
1.1 Consulta simple
List list = session.createQuery("from User as user order by user.loginName").list();
1.2 Con Consulta de parámetro único
List list = session.find("from User as user where user.loginName=?",
loginName,
Hibernate.STRING ) ;
1.3 Consulta con múltiples parámetros
Eg1. Este ejemplo utiliza el método de marcador de posición "?"
Cadena hql = "de Usuario como usuario donde usuario.loginName =? y user.orgId=? ";
Consulta consulta = session.createQuery(hql);
query.setParameter(1, 'amigo');
query.setParameter(2, new Long(1)) ;
List list = query .list();
Eg2. Este ejemplo utiliza el método ":paramName "
Cadena hql = "de Usuario como usuario donde user.loginName=:loginName y user.orgId=:orgId ";
Consulta consulta = session.createQuery(hql);
query.setParameter('loginName', 'amigo');
query.setParameter('orgId', new Long(1));
Lista lista = consulta. list();
1.4 Cantidad de consultas
int count = (Entero) session.createQuery("select count(*) from User").uniqueResult() .intValue();
1.5 Consulta para limitar el valor inicial y la cantidad de la consulta
Esto generalmente es necesario cuando es necesario paginar los registros, por ejemplo, en el siguiente código, limitando el registro inicial posición de la consulta a 50 y el número máximo de consultas a 50.
String hql = "de Usuario como usuario orden por usuario.loginName";
int firstResult= 50;
int maxResults = 50;
Consulta consulta = session.createQuery(hql);
consulta = query.setFirstResult(firstResult);
query.setMaxResults(maxResults);
1.6 Subconsulta
En algunos casos, también es necesario utilizar subconsultas. Por ejemplo, en el siguiente ejemplo, Usuario es el objeto de usuario y UserRole es el objeto asociado con el usuario y el rol. La siguiente declaración HQL encontrará objetos de usuario sin roles asignados.
String hql = "from Usuario usuario donde usuario.loginName"
+ " not in(select ur.user.loginName from UserRole ur) ";
List list = (session.createQuery(hql)).list();
1.7 Consulta SQL nativa
Para algunas declaraciones de consulta complejas, es necesario llamar a una base de datos específica. Solo se puede Puede resolverse mediante funciones específicas. Aunque Hibernate no recomienda el uso de declaraciones SQL nativas para realizar consultas, porque esto destruirá la portabilidad de la base de datos, Hibernate también proporciona un método para usar SQL nativo para realizar consultas, y solo necesita obtener una conexión.
Por ejemplo, en el siguiente ejemplo, se utiliza la instrucción SQL nativa en la base de datos del servidor Sql, como se muestra a continuación:
String timeUnit = "13";
String sql = "seleccione recuento(*) recuento, CONVERT(VARCHAR(" + timeUnit +"), log.gen_datetime,121) timeUnit " + "from Log log";
Consulta SQLQuery = sesión. createSQLQuery(sql)
.addScalar("count", Hibernate.INTEGER)
.addScalar("timeUnit", Hibernate.STRING);
Lista de lista = query.list();
2 Agregar nuevo
Para agregar nuevos registros en la base de datos, no necesita usar el comando insertar en Hibernate. Solo necesita construir el archivo. nuevo objeto y llame a la sesión. Simplemente use el método save(…) del objeto.
2.1 Agregar un solo objeto
El ejemplo de agregar un solo objeto es el siguiente. Este ejemplo agregará un nuevo registro en la tabla de usuarios.
Sesión sesión = HibernateSessionFactory.getSession();
Transacción ts = nula;
prueba {
ts = sesión.beginTransaction( );
Usuario usuario = nuevo Usuario();
usuario.setLoginName("amigo");
usuario.setFullName("amigo") ;
……
session.save(usuario) ;
ts.commit();
} catch (Excepción e) {
if (ts != null) {
ts.rollback();
}
} finalmente {
HibernateSessionFactory.closeSession();
}
2.2 Agregar objetos en lotes
Para el caso de agregar objetos en lotes, es necesario agregar una parte Vacíe y borre una vez después del objeto. Por ejemplo, si no se agregan 20 objetos en lotes, vacíelo una vez manualmente. Suponga que la lista es una lista de usuarios que contiene muchos objetos de usuario. Para implementar la adición por lotes de estos objetos, se puede realizar lo siguiente. ser utilizado Método:
Session session = HibernateSessionFactory.getSession();
Transacción ts = null;
prueba {
ts = sesión. comenzarTransacción();
for (int i = 0; i < list.size(); i++) {
Usuario usuario = (Usuario) list.get(i) ;
sesión.save(usuario) ;
if (i % 20 == 0) {
sesión.flush();
session.clear();
}
}
ts.commit();
} captura (Excepción e) {
if (ts != null) {
ts.rollback();
}
} finalmente {
HibernateSessionFactory.closeSession();
}
3 Actualización
En hibernación, no es necesario utilizar la declaración de consulta antes de actualizar el objeto. : actualizar..., generalmente requerido Recogiendo
Después de obtener el objeto persistente que necesita actualizarse, ejecute el método de actualización (...) del objeto de sesión. Por ejemplo:
Sesión sesión = HibernateSessionFactory.getSession();
Transacción ts = nulo;
prueba {
ts = sesión . beginTransaction();
//Obtener el objeto persistente
Usuario user = session.get(User.class, "amigo");
//. Sí Modificar los atributos que deben modificarse
user.setFullName("Amigo");
……
session.update(user);
ts.commit();
} catch (Excepción e) {
if (ts != null) {
ts.rollback ( );
}
} finalmente {
HibernateSessionFactory.closeSession();
}
4 Eliminar
4.1 Eliminar un solo objeto
Generalmente, después de obtener un objeto, los desarrolladores pueden llamar al método eliminar (...) del objeto de sesión para eliminar el objeto.
Por ejemplo, en el siguiente ejemplo, después de obtener el objeto Usuario cuyo nombre de inicio de sesión (clave principal) es "amigo", elimínelo.
Sesión sesión = HibernateSessionFactory.getSession();
Transacción ts = nula;
prueba {
ts = sesión.beginTransaction( );
//Obtener el objeto persistente
Usuario usuario = session.get(User.class, "amigo");
session.delete(usuario ) ;
ts.commit();
} captura (Excepción e) {
if (ts != null) {
ts.rollback();
}
} finalmente {
HibernateSessionFactory.closeSession();
}
4.2 Eliminación por lotes de objetos
Para la eliminación por lotes de objetos, los desarrolladores pueden eliminar los objetos uno por uno después de obtener la lista de objetos que se eliminarán. Para conocer el método de eliminación de cada objeto, consulte 3.4. 1 sección. Los desarrolladores también pueden utilizar declaraciones hql para realizar eliminaciones por lotes.
Ej. Esta instancia elimina registros mediante la declaración de eliminación Excepto el objeto cuyo loginName es "amigo", el resto se eliminan:
Sesión de sesión =. HibernateSessionFactory.getSession ();
Transacción ts = null;
prueba {
ts = session.beginTransaction();
Cadena hql = "eliminar usuario como usuario donde user.loginName! = 'amigo'";
Consulta consulta = session.createQuery(hql);
int count = query.executeUpdate() ;
p>
ts.commit();
System.out.println("eliminar recuento: " + recuento); //Eliminar número
} catch (Excepción e ) {
if (ts != null) {
ts.rollback();
}
} finalmente {
p>
HibernateSessionFactory.closeSession();
}