lucene

#lucene

Table des matières

À propos 1

Chapitre 1: Démarrer avec lucene 2

Remarques 2

Versions 2

Examples 2

Installer 2

Bonjour le monde 3

Chapitre 2: Requêtes 5

Examples 5

BooleanQuery 5

PhraseQuery 6

DisjunctionMaxQuery 6

Booster les requêtes 6

Chapitre 3: Suppression de documents à l'aide d'une requête à plusieurs termes 8

Introduction 8

Syntaxe 8

Remarques 8

Mises en garde avec le choix de l'analyseur 8

Examples 8

Choix de l'analyseur 8

Analyseur de requête 9

API de requête 9

Supprimer les documents correspondant à la requête 9

Chapitre 4: Une analyse 11

Examples 11

Créer un analyseur personnalisé 11

Itération manuelle à travers les jetons analysés 11

Crédits 12

À propos

You can share this PDF with anyone you feel could benefit from it, downloaded the latest version from: lucene

It is an unofficial and free lucene ebook created for educational purposes. All the content is extracted from Stack Overflow Documentation, which is written by many hardworking individuals at Stack Overflow. It is neither affiliated with Stack Overflow nor official lucene.

The content is released under Creative Commons BY-SA, and the list of contributors to each chapter are provided in the credits section at the end of this book. Images may be copyright of their respective owners unless otherwise specified. All trademarks and registered trademarks are the property of their respective company owners.

Use the content presented in this book at your own risk; it is not guaranteed to be correct nor accurate, please send your feedback and corrections to info@zzzprojects.com

https://riptutorial.com/fr/home 1

Chapitre 1: Démarrer avec lucene

Remarques

Apache Lucene est une bibliothèque de recherche en texte intégral basée sur Java.

Versions

Version Date de sortie

2.9.4 2010-12-03

3.0.3 2010-12-03

3.6.2 2013-01-16

4.10.4 2015-10-14

5.5.2 2016-06-24

6.3.0 2016-11-08

Examples

Installer

Lucene est une bibliothèque Java. Si vous ne disposez pas déjà d'un environnement de développement Java, consultez la documentation Java .

Téléchargez la dernière version de Lucene à partir du site Web Apache et décompressez-la.

Ajoutez les jars requis à votre chemin de classe. Les jars suivants seront requis par de nombreux projets, y compris l'exemple Hello World ici:

core/lucene-core-6.1.0.jar : fonctionnalité Core Lucene.•core/analysis/common/lucene-analyzers-common-6.1.0.jar : fournit une variété d'analyseurs, y compris le standard core/analysis/common/lucene-analyzers-common-6.1.0.jar .

•

queryparser/lucene-queryparser-6.1.0.jar : fournit l'analyseur de requête.•

Placez le code dans HelloLucene.java . Compilez-le avec cette commande:

javac -classpath "core/*:queryparser/*" HelloLucene.java

Et lancez-le avec cette commande:

https://riptutorial.com/fr/home 2

java -classpath ".:core/*:queryparser/*" HelloLucene

Bonjour le monde

Cet exemple de base de Lucene crée un index simple et y recherche.

Remarque: RAMDirectory crée un index résidant en mémoire, ce qui est pratique pour l'expérimentation et le test, mais dans la pratique, la plupart des utilisateurs devront avoir un index stocké dans le système de fichiers (voir FSDirectory.open ).

import java.io.IOException; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.document.*; import org.apache.lucene.index.*; import org.apache.lucene.queryparser.classic.*; import org.apache.lucene.search.*; import org.apache.lucene.store.*; public class HelloLucene { public static void main(String[] args) throws IOException, ParseException { //Create a new index and open a writer Directory dir = new RAMDirectory(); Analyzer analyzer = new StandardAnalyzer(); IndexWriterConfig config = new IndexWriterConfig(analyzer); IndexWriter writer = new IndexWriter(dir, config); //Create a document to index Document doc = new Document(); doc.add(new TextField("text", "Hello World!", Field.Store.YES)); //Index the document and close the writer System.out.println("Indexing document: " + doc); writer.addDocument(doc); writer.close(); //Open an IndexSearcher IndexReader reader = DirectoryReader.open(dir); IndexSearcher searcher = new IndexSearcher(reader); //Create a query QueryParser parser = new QueryParser("text", analyzer); Query query = parser.parse("world"); //Search for results of the query in the index System.out.println("Searching for: \"" + query + "\""); TopDocs results = searcher.search(query, 10); for (ScoreDoc result : results.scoreDocs) { Document resultDoc = searcher.doc(result.doc); System.out.println("score: " + result.score + " -- text: " + resultDoc.get("text")); } reader.close(); } }

https://riptutorial.com/fr/home 3

Lire Démarrer avec lucene en ligne: https://riptutorial.com/fr/lucene/topic/3132/demarrer-avec-lucene

https://riptutorial.com/fr/home 4

Chapitre 2: Requêtes

Examples

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();

https://riptutorial.com/fr/home 5

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

https://riptutorial.com/fr/home 6

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();

Lire Requêtes en ligne: https://riptutorial.com/fr/lucene/topic/5614/requetes

https://riptutorial.com/fr/home 7

Chapitre 3: Suppression de documents à l'aide d'une requête à plusieurs termes

Introduction

La suppression de documents d'un index Lucene est simple lorsque vous avez un champ clé primaire dans votre document (comme dans les bases de données SQL traditionnelles).

Toutefois, vous avez parfois besoin de supprimer un certain nombre de documents basés sur plusieurs champs du document. L'API Lucene vous permet d'y parvenir en spécifiant une requête à utiliser pour la suppression.

Pour ce faire, sélectionnez le bon analyseur, créez la requête, transmettez la requête à indexWriter pour supprimer les documents.

Syntaxe

indexWriter.deleteDocuments (multiTermQuery);1. Requête multiTermQuery = new QueryParser ("", analyseur) .parse ("nom_zone1:" valeur du champ 1 "AND nom_du_2):" valeur du champ 2 "");

2.

BooleanQuery multiTermQuery = new BooleanQuery (); multiTermQuery.add (new TermQuery (new Term ("nom_zone1", "valeur du champ 1")), BooleanClause.Occur.MUST); multiTermQuery.add (new TermQuery (nouveau terme ("nom_zone2", "valeur du champ 2")), BooleanClause.Occur.MUST);

3.

Remarques

Mises en garde avec le choix de l'analyseur

Ce n'est pas immédiatement évident, mais l'analyseur que vous utilisez fait une énorme différence dans la façon dont votre requête est exécutée. Ceci est dû au fait que StandardAnalyzer filtre les mots anglais courants tels que "the" et "a". Vous pouvez choisir un analyseur différent (comme KeywordAnalyzer) pour qu'il corresponde exactement. Cela dépend évidemment de votre application de Lucene bien sûr.

Examples

Choix de l'analyseur

Tout d'abord, observez l'analyseur que vous utilisez. J'ai été déconcerté pendant un moment seulement pour réaliser que le StandardAnalyzer filtre les mots communs tels que «le» et «a». Ceci est un problème lorsque votre champ a la valeur 'A'. Vous voudrez peut-être envisager le

https://riptutorial.com/fr/home 8

KeywordAnalyzer:

Voir ce post autour de l'analyseur.

// Create an analyzer: // NOTE: We want the keyword analyzer so that it doesn't strip or alter any terms: // In our example, the Standard Analyzer removes the term 'A' because it is a common English word. // http://stackoverflow.com/a/9071806/231860 KeywordAnalyzer analyzer = new KeywordAnalyzer();

Analyseur de requête

Ensuite, vous pouvez soit créer votre requête en utilisant le QueryParser:

Voir ce post sur le remplacement de l'opérateur par défaut.

// Create a query parser without a default field in this example (the first argument): QueryParser queryParser = new QueryParser("", analyzer); // Optionally, set the default operator to be AND (we leave it the default OR): // http://stackoverflow.com/a/9084178/231860 // queryParser.setDefaultOperator(QueryParser.Operator.AND); // Parse the query: Query multiTermQuery = queryParser.parse("field_name1:\"field value 1\" AND field_name2:\"field value 2\"");

API de requête

Ou vous pouvez obtenir la même chose en construisant vous-même la requête en utilisant son API:

Voir ce tutoriel sur la création de BooleanQuery.

BooleanQuery multiTermQuery = new BooleanQuery(); multiTermQuery.add(new TermQuery(new Term("field_name1", "field value 1")), BooleanClause.Occur.MUST); multiTermQuery.add(new TermQuery(new Term("field_name2", "field value 2")), BooleanClause.Occur.MUST);

Supprimer les documents correspondant à la requête

Ensuite, nous transmettons enfin la requête à l'auteur pour supprimer les documents correspondant à la requête:

Voir la réponse à cette question.

Voir l'API ici

// Remove the document by using a multi key query: // http://www.avajava.com/tutorials/lessons/how-do-i-combine-queries-with-a-boolean-query.html

https://riptutorial.com/fr/home 9

indexWriter.deleteDocuments(multiTermQuery);

Lire Suppression de documents à l'aide d'une requête à plusieurs termes en ligne: https://riptutorial.com/fr/lucene/topic/9959/suppression-de-documents-a-l-aide-d-une-requete-a-plusieurs-termes

https://riptutorial.com/fr/home 10

Chapitre 4: Une analyse

Examples

Créer un analyseur personnalisé

La plupart de la personnalisation de l'analyse se trouve dans la classe createComponents , où les Tokenizer et les TokenFilters sont définis.

Les CharFilters peuvent être ajoutés dans la méthode initReader .

Analyzer analyzer = new Analyzer() { @Override protected Reader initReader(String fieldName, Reader reader) { return new HTMLStripCharFilter(reader); } @Override protected TokenStreamComponents createComponents(String fieldName) { Tokenizer tokenizer = new StandardTokenizer(); TokenStream stream = new StandardFilter(tokenizer); //Order matters! If LowerCaseFilter and StopFilter were swapped here, StopFilter's //matching would be case sensitive, so "the" would be eliminated, but not "The" stream = new LowerCaseFilter(stream); stream = new StopFilter(stream, StopAnalyzer.ENGLISH_STOP_WORDS_SET); return new TokenStreamComponents(tokenizer, stream); } };

Itération manuelle à travers les jetons analysés

TokenStream stream = myAnalyzer.tokenStream("myField", textToAnalyze); stream.addAttribute(CharTermAttribute.class); stream.reset(); while(stream.incrementToken()) { CharTermAttribute token = stream.getAttribute(CharTermAttribute.class); System.out.println(token.toString()); } stream.close();

Un certain nombre d' attributs sont disponibles. Le plus commun est CharTermAttribute , qui est utilisé pour obtenir le terme analysé en tant que chaîne.

Lire Une analyse en ligne: https://riptutorial.com/fr/lucene/topic/4830/une-analyse

https://riptutorial.com/fr/home 11

Crédits

S. No

Chapitres Contributeurs

1Démarrer avec lucene

Community, femtoRgon, Hamid Rohani, Heidar

2 Requêtes femtoRgon

3

Suppression de documents à l'aide d'une requête à plusieurs termes

Luke Machowski

4 Une analyse femtoRgon

https://riptutorial.com/fr/home 12