Wirklich dynamischer JPA CriteriaBuilder

Ich muss eine "echte" dynamische JPA erstellenCriteriaBuilder. Ich bekomme eineMap<String, String> mit den Aussagen. Es sieht aus wie:

name : John
surname : Smith
email : [email protected]

...more pairs possible

Folgendes implementiere ich:

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<User> query = cb.createQuery(User.class);
Root<User> userRoot = query.from(User.class);
query.select(userRoot);

List<Predicate> predicates = new ArrayList<Predicate>();
Iterator<String> column = statements.keySet().iterator();
while (column.hasNext()) {

    // get the pairs
    String colIndex = column.next();
    String colValue = statements.get(colIndex);

    // create the statement
    Predicate pAnd = cb.conjunction();
    pAnd = cb.and(pAnd, cb.equal(userRoot.get(colIndex), colValue));
    predicates.add(pAnd);
}

// doesn't work, i don't know how many predicates i have -> can not address them
query.where(predicates.get(0), predicates.get(1), ...);

// doesn't work, because it is a list of predicates
query.where(predicates);

// doesn't work, because the actual predicate overwrites the old predicate
for (Predicate pre : predicates) {
     query.where(pre)
}

Ich habe versucht, eine große zu bauenPredicate, der alle anderen Prädikate enthält und diese zumquery.where(), aber wieder überschreiben die Prädikate alte Werte. Sieht so aus, als ob es keine Möglichkeit gibt, eine hinzuzufügenPredicate anstatt ein Prädikat zu ändern :-(

Das eigentliche Projekt ist noch komplizierter, da einige Paare eineequal und einige andere alike. Und das reicht noch nicht mal: Es könnte eine extra Aussage mit gebenor enthalten wietype : 1;4;7. Hier muss sich der Wert aufteilen und eine Aussage machen wie:

<rest of statement> AND (type = 1 OR type = 4 OR type = 7)

UPDATE und LÖSUNG Habe zwei Listen, erste Liste für AND funktioniert gut. Die zweite Liste enthält OR-Anweisungen wie erwartet:

final List<Predicate> andPredicates = new ArrayList<Predicate>();
final List<Predicate> orPredicates = new ArrayList<Predicate>();
for (final Entry<String, String> entry : statements.entrySet()) {
    final String colIndex = entry.getKey();
    final String colValue = entry.getValue();
    if (colIndex != null && colValue != null) {

        if (!colValue.contains(";")) {
            if (equals) {
                andPredicates.add(cb.equal(userRoot.get(colIndex), colValue));
            } else {
                andPredicates.add(cb.like(userRoot.<String> get(colIndex), "%" + colValue + "%"));
            }
        } else {
            String[] values = colValue.split(";");
            for (String value : values) {
                orPredicates.add(cb.or(cb.equal(userRoot.get(colIndex), value)));
            }
        }       
    }
}

// Here goes the magic to combine both lists
if (andPredicates.size() > 0 && orPredicates.size() == 0) {
    // no need to make new predicate, it is already a conjunction
    query.where(andPredicates.toArray(new Predicate[andPredicates.size()]));
} else if (andPredicates.size() == 0 && orPredicates.size() > 0) {
    // make a disjunction, this part is missing above
    Predicate p = cb.disjunction();
    p = cb.or(orPredicates.toArray(new Predicate[orPredicates.size()]));
    query.where(p);
} else {
    // both types of statements combined
    Predicate o = cb.and(andPredicates.toArray(new Predicate[andPredicates.size()]));
    Predicate p = cb.or(orPredicates.toArray(new Predicate[orPredicates.size()]));
    query.where(o, p);
}

query.where(predicates.toArray(new Predicate[predicates.size()]));
users = em.createQuery(query).getResultList();

Antworten auf die Frage(4)

Ihre Antwort auf die Frage