lucene
Requêtes

BooleanQuery

BooleanQuery est utilisé pour combiner d'autres requêtes.

Ils peuvent être combinés en utilisant trois paramètres BooleanClause.Occur:

• BooleanClause.Occur.MUST - La sous-requête doit correspondre.
• BooleanClause.Occur.SHOULD - La sous-requête peut ne pas correspondre, mais sera BooleanClause.Occur.SHOULD plus fortement si c'est le cas. S'il n'y a pas de clause MUST, au moins une clause SHOULD doit correspondre.
• BooleanClause.Occur.MUST_NOT - La sous-requête ne doit pas correspondre au document.

Dans cet exemple, un document correspondra s'il a "important", mais pas "interdit", et obtiendra un score plus élevé s'il a aussi "utile".

Query importantQuery = new TermQuery(new Term("fieldname", "important"));
Query optionalQuery = new TermQuery(new Term("fieldname", "helpful"));
Query forbidQuery = new TermQuery(new Term("fieldname", "forbidden"));
BooleanQuery query = new BooleanQuery.Builder()
        .add(importantQuery, BooleanClause.Occur.MUST) 
        .add(optionalQuery, BooleanClause.Occur.SHOULD) 
        .add(forbidQuery, BooleanClause.Occur.MUST_NOT) 
        .build();

Vous pouvez également spécifier le nombre minimum de clauses à faire correspondre:

Query query1 = new TermQuery(new Term("fieldname", "one"));
Query query2 = new TermQuery(new Term("fieldname", "two"));
Query query3 = new TermQuery(new Term("fieldname", "three"));
BooleanQuery query = new BooleanQuery.Builder()
        .add(query1, BooleanClause.Occur.SHOULD) 
        .add(query2, BooleanClause.Occur.SHOULD) 
        .add(query3, BooleanClause.Occur.SHOULD)
        .setMinimumNumberShouldMatch(2)
        .build();

Gotcha: Les clauses avec BooleanClause.Occur.MUST_NOT ne correspondent pas à tout le reste, elles n'éliminent que les correspondances. Votre BooleanQuery doit avoir au moins un MUST ou SHOULD clause, ou il ne correspond. Ceci, par exemple, ne fonctionnera PAS :

//***This does NOT work!***
Query forbidQuery = new TermQuery(new Term("fieldname", "forbidden"));
BooleanQuery getEverythingElseQuery = new BooleanQuery.Builder()
        .add(forbidQuery, BooleanClause.Occur.MUST_NOT) 
        .build();

PhraseQuery

PhraseQuery est utilisé pour rechercher une séquence de termes. Ce qui suit correspond à la phrase "Hello World" (après avoir été indexé avec StandardAnalyzer )

Query query = new PhraseQuery.Builder()
        .add(new Term("text", "hello"))
        .add(new Term("text", "world"))
        .build();

PhraseQuery peut également gérer un "slop", ou des termes supplémentaires dans une requête, en définissant une distance de montage maximale avec setSlop . Cela correspondra à "Lorem ipsum sit amet dolor":

Query query = new PhraseQuery.Builder()
        .add(new Term("text", "lorem"))
        .add(new Term("text", "amet"))
        .setSlop(2)
        .build();

Vous pouvez également définir des incréments de position exacts:

Query query = new PhraseQuery.Builder()
        .add(new Term("text", "lorem"), 0)
        .add(new Term("text", "sit"), 2)
        .add(new Term("text", "dolor"), 4)
        .build();

DisjunctionMaxQuery

Cela combine des requêtes telles que la meilleure correspondance (c'est-à-dire la plus élevée) de ses sous-requêtes contribue au score final.

List<Query> disjuncts = new ArrayList<Query>();
disjuncts.add(new TermQuery(new Term("fieldname", "hello")));
disjuncts.add(new TermQuery(new Term("fieldname", "world")));
Query query = new DisjunctionMaxQuery(disjuncts, 0.0f);

Le second argument du constructeur DisjunctionMaxQuery est une valeur de bris d'égalité qui, lorsqu'elle est différente de zéro, permet aux correspondances non maximales d'apporter une petite contribution au score, afin de rompre les liens. Il devrait généralement être petit (de l'ordre de 0,1).

Booster les requêtes

Une requête peut être augmentée pour augmenter son score par rapport aux autres sous-requêtes. Ceci est fait en l'enveloppant avec un BoostQuery

Query lessRelevantQuery = new TermQuery(new Term("fieldname", "ipsum"));
//Five times as interesting
Query highlyRelevantQuery = new BoostQuery(
         new TermQuery(new Term("fieldname", "lorem")), 
         5.0f);
BooleanQuery query = new BooleanQuery.Builder()
        .add(lessRelevantQuery, BooleanClause.Occur.SHOULD) 
        .add(highlyRelevantQuery, BooleanClause.Occur.SHOULD) 
        .build();