|
|
Pubblicato su 09/08/2017 14:26:13
|
|
|
Ora supponiamo che ci sia una classe Studente con attributi id, nome, età
Stringa hql = "da Student s";
Come facevamo una volta, di solito lo facciamo
Query query = session.createQuery(hql);
Oppure se vuoi cercare secondo le condizioni.
Stringa hql = "da Studenti s dove s.name come 'King%'"
Query query = session.createQuery(hql);
Se usi QBC invece di HQL, allora il codice è:
Criteri = session.createCriteria(Student.class);
Criterio di criterio = Expression.like("name","king%");
Non riesco a vederla così. Poi aggiungiamo la condizione di ricerca all'età di 22 anni.
HQL:
Stringa hql = "da Studenti s dove s.name come 'Wang%' e s.age = 22 ";
Query query = session.createQuery(hql);
List list = query.list();
QBC:
Criteri = session.createCriteria(Student.class);
Criterio criterio1 = Expression.like("name","king%");
Criterio criterio2 = Expression.eq("age",newInteger(22));
criteri.add(criterion1).add(criterion2);
Lista lista = criteria.list();
Sembra molto più ingombrante. Ma chiunque abbia già fatto un progetto sa che quando la logica di business di un modulo cambia, spesso deve riscrivere SQL, e la cosa più fastidiosa e fastidiosa è prendere l'HQL o l'SQL di qualcun altro.
Se usi QBC, aumenta notevolmente la leggibilità e la manutenibilità del codice.
È importante notare che il valore nullo è il valore
Ad esempio, quando vogliamo trovare un oggetto Student con un nome nullo, dovremmo scriverlo così
Criteri = session.createCriteria(Student.class);
Criterio criterio = Expression.isNull("name");
criteri.add(criterion).list();
e usare tra... e tempo
Criteri = session.createCriteria(Student.class);
Criterio criterio 1 = Expression.ge("età",nuovo intero(20)); Limite inferiore
Criterio criterio2 = Expression.le("age",new Integer(25)); Sofoffitto
//这里也可以把上述两个条件添加到第三个条件里
Criterio criterio3 =Expression.and(criterion1,criterion2);
criteria.add(criterion3).list();
Equivalente a studenti che hanno un'età compresa tra i 20 e i 25 anni
Equivalente a da Studente s dove s.età >= 20 e s.età <=25
Di seguito è riportato un confronto delle condizioni di query comunemente usate di HQL e QBC
Espressione che significa HQL QBC
maggiore o uguale a > = Expression.ge()
Maggiore di > Expression.gt()
Minore o uguale a < = Expression.le()
Meno di < Expression.lt()
uguali = Expression.eq()
non è uguale a <>o!= Expression.ne()
Null è nullo Expression.isNull()
is notnull Expression.isNotNull()
All'interno dell'intervallo specificato tra e Expression.between()
Non nell'intervallo specificato, non tra e Expression.not(Expression.between())
Appartenenti a una collezione in Expression.in()
Non fa parte di una collezione notin Expression.not(Expression.in())
e expression.and()
o Expression.or()
Non Expression.not()
Query fuzzy come Expression.like
1. Crea un'istanza Criteria net.sf.hibernate.Criteria Questa interfaccia rappresenta una query per una specifica classe di persistenza. Session è la fabbrica utilizzata per produrre l'istanza Criteria.
Crit dei criteri = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
Lista gatti = crit.list();
2. Restringere l'ambito dell'insieme di risultati Una condizione di query (Criterion) è un'istanza dell'interfaccia net.sf.hibernate.expression.Criterion. La classe net.sf.hibernate.expression.Expression si definisce per ottenere alcuni tipi di criterio integrati.
Elenco gatti = sess.createCriteria(Cat.class)
.add( Expression.like("name", "Fritz%") )
.add( Expression.between("weight", minWeight, maxWeight))
.list();
Le espressioni possono essere raggruppate logicamente.
Elenco gatti = sess.createCriteria(Cat.class)
.add( Expression.like("name", "Fritz%") )
.add( Expression.or( Expression.eq( "age", new Enter(0)), Expression.isNull("age")))
.list();
Elenco gatti = sess.createCriteria(Cat.class)
.add( Expression.in( "name",new String[]{"Fritz", "Izi", "Pk"}))
.add( Expression.disjunction()
.add( Expression.isNull("age") )
.add( Expression.eq("age", nuovo Intero(0) )
.add( Expression.eq("age", nuovo intero(1) )
.add( Expression.eq("age", nuovo Intero(2) ) ) ) )
.list();
Esistono molti tipi di condizioni predefinite (sottoclassi di Espressioni). Ce n'è uno particolarmente utile che permette di incorporare SQL direttamente.
Elenco gatti = sess.createCriteria(Cat.class)
.add( Expression.sql("lower($alias.name) come lower(?)", "Fritz%", Hibernate.STRING))
.list();
dove {alias} è un segnaposto, verrà sostituito dall'alias di linea dell'entità interrogata. (Originale: Il segnaposto {alias} sarà sostituito dall'alias della riga dell'entità interrogata.)
3. Ordina i risultati Puoi usare net.sf.hibernate.expression.order per ordinare il set di risultati.
Elenco gatti = sess.createCriteria(Cat.class)
.add( Expression.like("name", "F%")
.addOrder( Order.asc("nome"))
.addOrder( Order.desc("age"))
.setMaxResults(50)
.list();
4. Associazioni Puoi usare createCriteria() tra associazioni per specificare facilmente i vincoli tra entità con relazioni.
Elenco gatti = sess.createCriteria(Cat.class)
.add( Expression.like("name", "F%")
.createCriteria("gattini")
.add( Expression.like("name","F%")
.list();
Si noti che il secondo createCriteria() restituisce una nuova istanza di Criteria, che indica un elemento della classe della collezione gattini. Le seguenti forme alternative sono utili in situazioni specifiche.
Elenco gatti = sess.createCriteria(Cat.class)
.createAlias("gattini", "kt")
.createAlias("compagno", "mt")
.add(Expression.eqProperty("kt.name", "mt.name"))
.list();
(createAlias()) non crea una nuova istanza dei Criteri. Nota che la classe di raccolta gattini detenuta dall'istanza Cat nelle due query precedenti non è pre-filtrata per criteri! Se vuoi restituire solo gattini che soddisfano i criteri, devi usare returnMaps().
Elenco gatti = sess.createCriteria(Cat.class)
.createCriteria("gattini", "kt")
.add( Expression.eq ("name", "F%") )
.returnMaps()
.list();
Iterator iter = cats.iterator();
while ( iter.hasNext())
{
Map map = (Map) iter.next();
Gatto gatto = (Gatto) map.get(Criteria.ROOT_ALIAS);
Gattino = (Gatto) map.get("kt");
}
5. Recupero dinamico di associazioni Puoi modificare la politica di recupero automatico degli oggetti di associazione impostando FetchMode() a runtime.
Elenco gatti = sess.createCriteria(Cat.class)
.add( Expression.like("name", "Fritz%") )
.setFetchMode("mate", FetchMode.EAGER)
.list();
Questa query farà arrivare sia ai partner che ai gattini tramite la giunzione esterna.
6. Secondo la classe Example queries net.sf.hibernate.expression.Example, puoi creare condizioni di query dall'istanza specificata.
Gatto gatto = nuovo gatto();
cat.setSex('F');
cat.setColor(Color.NERO);
Risultati elenco = session.createCriteria(Cat.class)
.add( Esempio.create(cat) )
.list();
Le proprietà delle versioni, le proprietà di rappresentazione e le associazioni vengono tutte ignorate. Per impostazione predefinita, anche gli attributi nulli sono esclusi. Puoi regolare come viene applicato l'esempio. Si può
per regolare come viene applicato l'esempio. Esempio esempio = Esempio.create(cat) .excludeZeroes() //exclude proprietà a valore zero
.excludeProperty("color") //escludono la proprietà denominata "color" .ignoreCase() //eseguino confronti di stringhe insensibili alla madicia e al caso
.enableLike(); Uso di like per confronti di stringhe
Risultati elenco = session.createCriteria(Cat.class)
.add(esempio)
.list();
Puoi anche usare esempi per stabilire criteri per gli oggetti associati. Risultati elenco = session.createCriteria(Cat.class) .add(Example.create(cat) )
.createCriteria("mate") .add(Example.create(cat.getMate())) .list();
Il codice di riferimento è il seguente:
|
Precedente:LINQ connessioni sinistra, destra e internaProssimo:La differenza tra le variabili di definizione let e var in js
|
