Einführung in Apache Lucene

1. Übersicht

Apache Lucene ist eine Volltextsuchmaschine, die in verschiedenen Programmiersprachen verwendet werden kann.

In diesem Artikel werden wir versuchen, die Kernkonzepte der Bibliothek zu verstehen und eine einfache Anwendung zu erstellen.

2. Maven Setup

Fügen Sie zunächst die erforderlichen Abhängigkeiten hinzu:

 org.apache.lucene lucene-core 7.1.0 

Die neueste Version finden Sie hier.

Zum Parsen unserer Suchanfragen benötigen wir außerdem:

 org.apache.lucene lucene-queryparser 7.1.0 

Suchen Sie hier nach der neuesten Version.

3. Kernkonzepte

3.1. Indizierung

Einfach ausgedrückt, verwendet Lucene eine „invertierte Indizierung“ von Daten - anstatt Seiten Schlüsselwörtern zuzuordnen, ordnet sie Schlüsselwörter Seiten zu, genau wie ein Glossar am Ende eines Buches.

Dies ermöglicht schnellere Suchantworten, da ein Index durchsucht wird, anstatt Text direkt zu durchsuchen.

3.2. Unterlagen

Hier ist ein Dokument eine Sammlung von Feldern, und jedem Feld ist ein Wert zugeordnet.

Indizes bestehen normalerweise aus einem oder mehreren Dokumenten, und Suchergebnisse sind Sätze von am besten passenden Dokumenten.

Es ist nicht immer ein einfaches Textdokument, es kann auch eine Datenbanktabelle oder eine Sammlung sein.

3.3. Felder

Dokumente können Felddaten enthalten, wobei ein Feld normalerweise ein Schlüssel ist, der einen Datenwert enthält:

title: Goodness of Tea body: Discussing goodness of drinking herbal tea...

Beachten Sie, dass hier Titel und Text Felder sind und zusammen oder einzeln gesucht werden können.

3.4. Analyse

Eine Analyse konvertiert den angegebenen Text in kleinere und präzise Einheiten, um die Suche zu vereinfachen.

Der Text durchläuft verschiedene Vorgänge zum Extrahieren von Schlüsselwörtern, Entfernen gängiger Wörter und Satzzeichen, Ändern von Wörtern in Kleinbuchstaben usw.

Zu diesem Zweck gibt es mehrere eingebaute Analysatoren:

  1. StandardAnalyzer - analysiert basierend auf der grundlegenden Grammatik, entfernt Stoppwörter wie "a", "an" usw. Konvertiert auch in Kleinbuchstaben
  2. SimpleAnalyzer - Unterbricht den Text basierend auf einem Buchstaben ohne Buchstaben und konvertiert ihn in Kleinbuchstaben
  3. WhiteSpaceAnalyzer - Unterbricht den Text anhand von Leerzeichen

Es stehen uns weitere Analysegeräte zur Verfügung, die wir ebenfalls verwenden und anpassen können.

3.5. Suchen

Sobald ein Index erstellt wurde, können wir diesen Index mithilfe einer Abfrage und eines IndexSearchers durchsuchen. Das Suchergebnis ist normalerweise eine Ergebnismenge, die die abgerufenen Daten enthält.

Beachten Sie, dass ein IndexWritter für die Erstellung des Index und ein IndexSearcher für die Suche im Index verantwortlich ist.

3.6. Abfragesyntax

Lucene bietet eine sehr dynamische und einfach zu schreibende Abfragesyntax.

Um einen freien Text zu suchen, würden wir nur einen Text verwenden String als Abfrage.

Um einen Text in einem bestimmten Feld zu suchen, verwenden wir:

fieldName:text eg: title:tea

Bereichssuche:

timestamp:[1509909322,1572981321] 

Wir können auch mit Platzhaltern suchen:

dri?nk

würde nach einem einzelnen Zeichen anstelle des Platzhalters "?" suchen

d*k

sucht nach Wörtern, die mit "d" beginnen und mit "k" enden, mit mehreren Zeichen dazwischen.

uni*

findet Wörter, die mit "uni" beginnen.

Wir können diese Abfragen auch kombinieren und komplexere Abfragen erstellen. Und schließen Sie logische Operatoren wie AND, NOT, OR ein:

title: "Tea in breakfast" AND "coffee"

Mehr zur Abfragesyntax hier.

4. Eine einfache Anwendung

Lassen Sie uns eine einfache Anwendung erstellen und einige Dokumente indizieren.

Zuerst erstellen wir einen In-Memory-Index und fügen ihm einige Dokumente hinzu:

... Directory memoryIndex = new RAMDirectory(); StandardAnalyzer analyzer = new StandardAnalyzer(); IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer); IndexWriter writter = new IndexWriter(memoryIndex, indexWriterConfig); Document document = new Document(); document.add(new TextField("title", title, Field.Store.YES)); document.add(new TextField("body", body, Field.Store.YES)); writter.addDocument(document); writter.close(); 

Here, we create a document with TextField and add them to the index using the IndexWriter. The third argument in the TextField constructor indicates whether the value of the field is also to be stored or not.

Analyzers are used to split the data or text into chunks, and then filter out the stop words from them. Stop words are words like ‘a', ‘am', ‘is' etc. These completely depend on the given language.

Next, let's create a search query and search the index for the added document:

public List searchIndex(String inField, String queryString) { Query query = new QueryParser(inField, analyzer) .parse(queryString); IndexReader indexReader = DirectoryReader.open(memoryIndex); IndexSearcher searcher = new IndexSearcher(indexReader); TopDocs topDocs = searcher.search(query, 10); List documents = new ArrayList(); for (ScoreDoc scoreDoc : topDocs.scoreDocs) { documents.add(searcher.doc(scoreDoc.doc)); } return documents; }

In the search() method the second integer argument indicates how many top search results it should return.

Now let's test it:

@Test public void givenSearchQueryWhenFetchedDocumentThenCorrect() { InMemoryLuceneIndex inMemoryLuceneIndex = new InMemoryLuceneIndex(new RAMDirectory(), new StandardAnalyzer()); inMemoryLuceneIndex.indexDocument("Hello world", "Some hello world"); List documents = inMemoryLuceneIndex.searchIndex("body", "world"); assertEquals( "Hello world", documents.get(0).get("title")); }

Here, we add a simple document to the index, with two fields ‘title' and ‘body', and then try to search the same using a search query.

6. Lucene Queries

As we are now comfortable with the basics of indexing and searching, let us dig a little deeper.

In earlier sections, we've seen the basic query syntax, and how to convert that into a Query instance using the QueryParser.

Lucene provides various concrete implementations as well:

6.1. TermQuery

A Term is a basic unit for search, containing the field name together with the text to be searched for.

TermQuery is the simplest of all queries consisting of a single term:

@Test public void givenTermQueryWhenFetchedDocumentThenCorrect() { InMemoryLuceneIndex inMemoryLuceneIndex = new InMemoryLuceneIndex(new RAMDirectory(), new StandardAnalyzer()); inMemoryLuceneIndex.indexDocument("activity", "running in track"); inMemoryLuceneIndex.indexDocument("activity", "Cars are running on road"); Term term = new Term("body", "running"); Query query = new TermQuery(term); List documents = inMemoryLuceneIndex.searchIndex(query); assertEquals(2, documents.size()); }

6.2. PrefixQuery

To search a document with a “starts with” word:

@Test public void givenPrefixQueryWhenFetchedDocumentThenCorrect() { InMemoryLuceneIndex inMemoryLuceneIndex = new InMemoryLuceneIndex(new RAMDirectory(), new StandardAnalyzer()); inMemoryLuceneIndex.indexDocument("article", "Lucene introduction"); inMemoryLuceneIndex.indexDocument("article", "Introduction to Lucene"); Term term = new Term("body", "intro"); Query query = new PrefixQuery(term); List documents = inMemoryLuceneIndex.searchIndex(query); assertEquals(2, documents.size()); }

6.3. WildcardQuery

As the name suggests, we can use wildcards “*” or “?” for searching:

// ... Term term = new Term("body", "intro*"); Query query = new WildcardQuery(term); // ...

6.4. PhraseQuery

It's used to search a sequence of texts in a document:

// ... inMemoryLuceneIndex.indexDocument( "quotes", "A rose by any other name would smell as sweet."); Query query = new PhraseQuery( 1, "body", new BytesRef("smell"), new BytesRef("sweet")); List documents = inMemoryLuceneIndex.searchIndex(query); // ...

Notice that the first argument of the PhraseQuery constructor is called slop, which is the distance in the number of words, between the terms to be matched.

6.5. FuzzyQuery

We can use this when searching for something similar, but not necessarily identical:

// ... inMemoryLuceneIndex.indexDocument("article", "Halloween Festival"); inMemoryLuceneIndex.indexDocument("decoration", "Decorations for Halloween"); Term term = new Term("body", "hallowen"); Query query = new FuzzyQuery(term); List documents = inMemoryLuceneIndex.searchIndex(query); // ...

We tried searching for the text “Halloween”, but with miss-spelled “hallowen”.

6.6. BooleanQuery

Sometimes we might need to execute complex searches, combining two or more different types of queries:

// ... inMemoryLuceneIndex.indexDocument("Destination", "Las Vegas singapore car"); inMemoryLuceneIndex.indexDocument("Commutes in singapore", "Bus Car Bikes"); Term term1 = new Term("body", "singapore"); Term term2 = new Term("body", "car"); TermQuery query1 = new TermQuery(term1); TermQuery query2 = new TermQuery(term2); BooleanQuery booleanQuery = new BooleanQuery.Builder() .add(query1, BooleanClause.Occur.MUST) .add(query2, BooleanClause.Occur.MUST) .build(); // ...

7. Sorting Search Results

We may also sort the search results documents based on certain fields:

@Test public void givenSortFieldWhenSortedThenCorrect() { InMemoryLuceneIndex inMemoryLuceneIndex = new InMemoryLuceneIndex(new RAMDirectory(), new StandardAnalyzer()); inMemoryLuceneIndex.indexDocument("Ganges", "River in India"); inMemoryLuceneIndex.indexDocument("Mekong", "This river flows in south Asia"); inMemoryLuceneIndex.indexDocument("Amazon", "Rain forest river"); inMemoryLuceneIndex.indexDocument("Rhine", "Belongs to Europe"); inMemoryLuceneIndex.indexDocument("Nile", "Longest River"); Term term = new Term("body", "river"); Query query = new WildcardQuery(term); SortField sortField = new SortField("title", SortField.Type.STRING_VAL, false); Sort sortByTitle = new Sort(sortField); List documents = inMemoryLuceneIndex.searchIndex(query, sortByTitle); assertEquals(4, documents.size()); assertEquals("Amazon", documents.get(0).getField("title").stringValue()); }

Wir haben versucht, die abgerufenen Dokumente nach Titelfeldern zu sortieren, die die Namen der Flüsse sind. Das boolesche Argument für den SortField- Konstruktor dient zum Umkehren der Sortierreihenfolge.

8. Entfernen Sie Dokumente aus dem Index

Versuchen wir, einige Dokumente basierend auf einem bestimmten Begriff aus dem Index zu entfernen :

// ... IndexWriterConfig indexWriterConfig = new IndexWriterConfig(analyzer); IndexWriter writer = new IndexWriter(memoryIndex, indexWriterConfig); writer.deleteDocuments(term); // ...

Wir werden dies testen:

@Test public void whenDocumentDeletedThenCorrect() { InMemoryLuceneIndex inMemoryLuceneIndex = new InMemoryLuceneIndex(new RAMDirectory(), new StandardAnalyzer()); inMemoryLuceneIndex.indexDocument("Ganges", "River in India"); inMemoryLuceneIndex.indexDocument("Mekong", "This river flows in south Asia"); Term term = new Term("title", "ganges"); inMemoryLuceneIndex.deleteDocument(term); Query query = new TermQuery(term); List documents = inMemoryLuceneIndex.searchIndex(query); assertEquals(0, documents.size()); }

9. Fazit

Dieser Artikel war eine kurze Einführung in die ersten Schritte mit Apache Lucene. Außerdem haben wir verschiedene Abfragen ausgeführt und die abgerufenen Dokumente sortiert.

Wie immer ist der Code für die Beispiele auf Github zu finden.