|
|
Publicado en 9/8/2017 14:26:13
|
|
|
Ahora digamos que hay una clase de estudiante con atributos id, nombre y edad
Cadena hql = "de Student s";
Como solíamos hacer, normalmente lo hacemos
Consulta de consulta = sesión.createQuery(hql);
O si quieres buscar según las condiciones.
String hql = "de Estudiantes s donde s.name 'King%'"
Consulta de consulta = sesión.createQuery(hql);
Si usas QBC en lugar de HQL, entonces el código es:
Criterios criterios =sesión.createCriteria(Student.class);
Criterio de criterio = Expression.like("name","king%");
No puedo verlo así. Luego sumamos la condición de búsqueda a la edad de 22 años.
HQL:
Cadena hql = "de Estudiantes s donde s.name como 'Wang%' y s.age = 22 ";
Consulta de consulta = sesión.createQuery(hql);
Lista lista = query.list();
QBC:
Criterios criterios =sesión.createCriteria(Student.class);
Criterio 1 = Expression.like("name","king%");
Criterio de criterio2 = Expression.eq("age",newInteger(22));
criterios.add(criterion1).add(criterion2);
Lista lista = criteria.list();
Parece mucho más engorroso. Pero cualquiera que haya hecho un proyecto sabe que cuando la lógica de negocio de un módulo cambia, a menudo tiene que reescribir SQL, y lo más molesto y molesto es coger el HQL o SQL de otra persona.
Si usas QBC, aumenta mucho la legibilidad y la mantenibilidad del código.
Es importante señalar que el valor nulo es el valor
Por ejemplo, cuando queremos encontrar un objeto Student con un nombre nulo, deberíamos escribirlo así
Criterios criterios =sesión.createCriteria(Student.class);
Criterio de criterio = Expression.isNull("name");
criteria.add(criterion).list();
y usando entre... y tiempo
Criterios criterios =sesión.createCriteria(Student.class);
Criterio 1 = Expression.ge("edad",nuevo Entero(20)); Límite inferior
Criterio 2 = Expression.le("age",new Enter(25)); Techo
//这里也可以把上述两个条件添加到第三个条件里
Criterio criterio3 = Expresión.and(criterio1,criterio2);
criteria.add(criterion3).list();
Equivalente a los estudiantes que tienen entre 20 y 25 años
Equivalente a desde Estudiantes s donde s.edad >= 20 y s.edad <=25
A continuación se presenta una comparación de las condiciones de consulta más usadas de HQL y QBC
Expresión que significa HQL QBC
mayor o igual a > = Expression.ge()
Mayor que > Expression.gt()
Menor o igual a < = Expression.le()
Menos de < Expression.lt()
igual a = Expresión.eq()
no es igual a <>¡o!= Expression.ne()
Nulo es nulo Expression.isNull()
is notnull Expression.isNotNull()
Dentro del rango especificado entre y Expression.between()
No en el rango especificado, no entrey Expression.not(Expression.between())
Perteneciente a una colección en Expression.in()
No forma parte de una colección notin Expression.not(Expression.in())
y expression.and()
o Expression.or()
No Expression.not()
Consulta difusa como Expression.like
1. Crear una instancia de Criterios net.sf.hibernate.Criterios Esta interfaz representa una consulta para una clase de persistencia específica. Session es la fábrica utilizada para fabricar la instancia de Criterios.
Crit de criterios = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
Lista gatos = crit.list();
2. Reducir el alcance del conjunto de resultados Una condición de consulta (Criterion) es una instancia de la interfaz net.sf.hibernate.expression.Criterion. La clase net.sf.hibernate.expression.Expression define para obtener algunos tipos de criterio incorporados.
Lista cats = sess.createCriteria(Cat.class)
.add( Expresión.like("nombre", "Fritz%") )
.add( Expression.between("weight", minWeight, maxWeight))
.list();
Las expresiones pueden agruparse lógicamente.
Lista cats = sess.createCriteria(Cat.class)
.add( Expresión.like("nombre", "Fritz%") )
.add( Expression.or( Expression.eq( "age", new Enter(0)), Expression.isNull("age")))
.list();
Lista cats = sess.createCriteria(Cat.class)
.add( Expression.in( "name",new String[]{"Fritz","Izi","Pk"}))
.add( Expression.disyunción()
.add( Expression.isNull("age") )
.add( Expression.eq("age", nuevo Entero(0) )
.add( Expression.eq("age", nuevo Entero(1) )
.add( Expression.eq("age", nuevo Entero(2) ) ) ) )
.list();
Hay muchos tipos de condiciones predefinidas (subclases de Expressions). Hay uno especialmente útil que permite incrustar SQL directamente.
Lista cats = sess.createCriteria(Cat.class)
.add( Expression.sql("lower($alias.name) como lower(?)", "Fritz%", Hibernate.STRING))
.list();
donde {alias} es un marcador de posición, será reemplazado por el alias de línea de la entidad consultada. (Original: El {alias} marcador será reemplazado por el alias de fila de la entidad consultada.)
3. Ordenar los resultados Puedes usar net.sf.hibernate.expression.order para ordenar el conjunto de resultados.
Lista cats = sess.createCriteria(Cat.class)
.add( Expression.like("name", "F%")
.addOrder( Order.asc("name"))
.addOrder( Order.desc("age"))
.setMaxResults(50)
.list();
4. Asociaciones Puedes usar createCriteria() entre asociaciones para especificar fácilmente restricciones entre entidades con relaciones.
Lista cats = sess.createCriteria(Cat.class)
.add( Expression.like("name", "F%")
.createCriteria("gatitos")
.add( Expresión.like("name","F%")
.list();
Obsábanse que el segundo createCriteria() devuelve una nueva instancia de Criteria, apuntando a un elemento de la clase de colección kittens. Las siguientes formas alternativas son útiles en situaciones específicas.
Lista cats = sess.createCriteria(Cat.class)
.createAlias ("gatitos", "kt")
.createAlias("mate", "mt")
.add(Expression.eqProperty("kt.name", "mt.name"))
.list();
(createAlias()) no crea una nueva instancia de los Criterios. Ten en cuenta que la clase de colección de gatitos que tiene la instancia de Gato en las dos consultas anteriores no está prefiltrada por criterios. Si quieres devolver solo gatitos que cumplan los requisitos, debes usar returnMaps().
Lista cats = sess.createCriteria(Cat.class)
.createCriteria("gatitos", "kt")
.add( Expression.eq ("nombre", "F%") )
.returnMaps()
.list();
Iterator iter = cats.iterator();
mientras ( iter.hasNext())
{
Map map = (Map) iter.next();
Gato gato = (Gato) map.get(Criteria.ROOT_ALIAS);
Gato gatito = (Gato) map.get("kt");
}
5. Obtención dinámica de asociaciones Puede cambiar la política de obtención automática de objetos de asociación estableciendo FetchMode() en tiempo de ejecución.
Lista cats = sess.createCriteria(Cat.class)
.add( Expresión.like("nombre", "Fritz%") )
.setFetchMode("mate", FetchMode.EAGER)
.list();
Esta consulta consigue tanto a la pareja como a los gatitos mediante la unión exterior.
6. Según la clase de consultas de ejemplo net.sf.hibernate.expression.Example, puedes crear condiciones de consulta a partir de la instancia especificada.
Gato gato = gato nuevo();
cat.setSex('F');
cat.setColor(Color.BLACK);
Resultados de la lista = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.list();
Las propiedades de versión, las de representación y las asociaciones se ignoran. Por defecto, los atributos nulos también se excluyen. Puedes ajustar cómo se aplica el Ejemplo. Puedes
para ajustar cómo se aplica el ejemplo. Ejemplo de ejemplo = Example.create(cat) .excludeZeroes() //exclude propiedades con valor cero
.excludeProperty("color") //excluye la propiedad llamada "color" .ignoreCase() //realizan comparaciones de cadenas insensibles a mayúsculas y minúsculas
.enableLike(); Uso de like para comparaciones de cadenas
Resultados de la lista = session.createCriteria(Cat.class)
.add(ejemplo)
.list();
Incluso puedes usar ejemplos para establecer criterios para los objetos asociados. Resultados de la lista = session.createCriteria(Cat.class) .add(Example.create(cat) )
.createCriteria("mate") .add(Example.create(cat.getMate())) .list();
El código de referencia es el siguiente:
|
Anterior:LINQ conexiones izquierda, derecha e interiorPróximo:La diferencia entre las variables de definición let y var en js
|
