Se venisse chiesto di pensare a un motore di ricerca, la quasi totalità delle persone pen­se­reb­be a Google. Anche i gestori di siti web uti­liz­za­no Google sotto forma di Custom Search Engine (CSE) per fornire agli utenti una funzione di ricerca dei propri contenuti rapida e di semplice utilizzo. Ma Google non è l’unico servizio a di­spo­si­zio­ne – per molti gestori di siti web cer­ta­men­te anche non il migliore – per fornire ai propri vi­si­ta­to­ri una ricerca completa dei testi. Lucene, progetto open source e quindi gratuito di Apache, rap­pre­sen­ta in questo caso un’ottima al­ter­na­ti­va.

Numerose sono le aziende che, online o offline, hanno integrato Apache Lucene. Wikipedia lo ha uti­liz­za­to fino a pochi anni fa come funzione di ricerca, mentre ora ha deciso di affidarsi a Solr, altro software basato su Lucene; anche la ricerca su Twitter è com­ple­ta­men­te targata Lucene. Dal progetto avviato da Doug Cutting a fine degli anni 90 come hobby è stato svi­lup­pa­to un software uti­liz­za­to gior­nal­men­te da milioni di persone.

Che cos’è Lucene?

Lucene è una libreria di programmi pub­bli­ca­ta da Apache Software Foun­da­tion. È open source e gratuita e può essere uti­liz­za­ta e mo­di­fi­ca­ta dagli utenti. All’inizio Lucene era scritto in­te­ra­men­te in Java, ma ora ci sono anche porte in altri linguaggi di pro­gram­ma­zio­ne. Apache Solr ed Ela­stic­search sono potenti esten­sio­ni che ampliano la funzione di ricerca con ancora più pos­si­bi­li­tà.

Lucene è una ricerca full-text: ciò significa in parole povere che un programma ricerca una serie di documenti testuali per uno o più termini definiti dall’utente. È perciò subito evidente che Lucene non è uti­liz­za­to esclu­si­va­men­te nel contesto del World Wide Web, anche se le funzioni di ricerca sono qui on­ni­pre­sen­ti. Lucene può infatti essere uti­liz­za­to anche per archivi, librerie o anche per PC desktop domestici. Lucene cerca non solo documenti HTML, ma funziona per esempio anche con e-mail o file PDF.

Decisivo per la ricerca è un indice, cuore del software Apache: qui sono salvati tutti i termini di tutti i documenti. Chiamato Inverted Index, fon­da­men­tal­men­te è soltanto una tabella in cui per ogni termine viene me­mo­riz­za­ta la posizione cor­ri­spon­den­te. Per costruire un simile indice occorre in­nan­zi­tut­to un’estra­zio­ne: ciò significa che tutti i termini devono essere estratti da tutti i termini e salvati nell’indice. Lucene offre agli utenti la pos­si­bi­li­tà di con­fi­gu­ra­re questa estra­zio­ne in­di­vi­dual­men­te. Gli svi­lup­pa­to­ri decidono quali campi vogliono includere nell’indice. Ma per capire meglio occorre fare un passo indietro.

Gli oggetti con cui lavora Lucene sono documenti in qualsiasi forma. Tuttavia i documenti stessi con­ten­go­no, dal punto di vista di Lucene, dei campi. Essi sono ad esempio il nome dell’autore, il titolo del documento o il nome del file stesso. Ogni campo ha come nome univoco un valore. Ad esempio, il campo title potrebbe avere il valore “Istru­zio­ni per l’uso di Apache Lucene”. Quando si crea l’indice è quindi possibile decidere quali metadati si desidera re­gi­stra­re.

Quando si in­di­ciz­za­no i documenti avviene anche una co­sid­det­ta to­ke­niz­za­zio­ne. Dal punto di vista di una macchina un documento è ini­zial­men­te una raccolta di in­for­ma­zio­ni. Anche se vi al­lon­ta­na­te dal livello dei bit e vi rivolgete al contenuto leggibile dagli esseri umani, un documento consiste in una stringa di caratteri: lettere, pun­teg­gia­tu­ra, spazi.

Da questo set di dati è possibile uti­liz­za­re la to­ke­niz­za­zio­ne per creare segmenti, i termini (prin­ci­pal­men­te parole singole) che è possibile cercare. Il modo più semplice per eseguire tale to­ke­niz­za­zio­ne funziona con il metodo “white space”: un termine finisce quando c’è uno spazio bianco. Tuttavia tale metodo non porta allo scopo de­si­de­ra­to se i termini fissi con­si­sto­no di diverse parole, per esempio “Notte santa”. Per questo vengono uti­liz­za­ti dizionari che possono anche essere im­ple­men­ta­ti nel codice Lucene.

Quando analizza i dati di cui la to­ke­niz­za­zio­ne è una parte, Lucene esegue anche una nor­ma­liz­za­zio­ne. Ciò significa che i termini sono portati in una forma stan­dar­diz­za­ta, nella quale ad esempio tutte le lettere maiuscole vengono scritte comunque in minuscolo. Inoltre Lucene crea uno smi­sta­men­to che funziona tramite algoritmi, ad esempio uti­liz­zan­do il metodo TF-IDF. In qualità di utente, pro­ba­bil­men­te de­si­de­ra­te ottenere per primi i risultati più rilevanti o più recenti, come rendono possibile gli algoritmi del motore di ricerca.

Per fare in modo che gli utenti possano trovare qualcosa devono inserire un termine di ricerca in una riga di testo. Nel contesto di Lucene il termine o i termini sono chiamati “query”, che in inglese significa “richiesta”. Essa indica che l’input non deve con­si­ste­re solo di una o più parole, ma può anche contenere mo­di­fi­ca­to­ri come AND, OR, + e -, nonché me­ta­ca­rat­te­ri. Que­ry­Par­ser, una classe all’interno della libreria del programma, traduce l’input in una richiesta di ricerca specifica per il motore di ricerca. Inoltre gli svi­lup­pa­to­ri di Que­ry­Par­ser hanno la pos­si­bi­li­tà di mo­di­fi­ca­re le opzioni di con­fi­gu­ra­zio­ne, così il parser può essere con­fi­gu­ra­to per sod­di­sfa­re le esigenze dell’utente.

Ciò che ha reso Lucene com­ple­ta­men­te nuova alla sua comparsa è stata l’in­di­ciz­za­zio­ne in­cre­men­ta­le: prima di Lucene era possibile soltanto un batch indexing con il quale si im­ple­men­ta­va­no solo indici completi, mentre con l’in­di­ciz­za­zio­ne in­cre­men­ta­le ora si può ag­gior­na­re l’indice. Le singole voci possono essere aggiunte o rimosse.

Immagine: Rappresentazione schematica del processo all’interno di Apache Lucene
L’indice è il cuore di Lucene

Lucene vs Google & Co?

La domanda sorge spontanea: perché costruire un proprio motore di ricerca quando ci sono Google, Bing e altri search engine? Na­tu­ral­men­te non è facile ri­spon­de­re a questa domanda, perché dopotutto si tratta sempre di con­si­de­ra­re le esigenze in­di­vi­dua­li di chi utilizza queste ap­pli­ca­zio­ni.

Di sicuro quando parliamo di Lucene come motore di ricerca si tratta di una de­scri­zio­ne sem­pli­fi­ca­ta. Di fatto si tratta di una In­for­ma­tion Retrieval Library, ovvero un sistema in cui è possibile trovare in­for­ma­zio­ni. È una ca­rat­te­ri­sti­ca comune anche a Google e altri motori di ricerca, tuttavia questi sono limitati alle in­for­ma­zio­ni che pro­ven­go­no dal World Wide Web, mentre Lucene può invece essere applicato a qualsiasi scenario e con­fi­gu­ra­to con­for­me­men­te ai vostri scopi. Per esempio potete uti­liz­za­re Lucene anche per altre ap­pli­ca­zio­ni.

In sintesi

Apache Lucene è, a dif­fe­ren­za dei web search engine, un software non finito: per be­ne­fi­cia­re delle pos­si­bi­li­tà del sistema è ne­ces­sa­rio prima pro­gram­mar­lo. Vi mo­stre­re­mo i primi passi per farlo nel nostro tutorial di Lucene.

Lucene, Solr, Ela­stic­search: quali sono le dif­fe­ren­ze?

So­prat­tut­to i prin­ci­pian­ti si chiedono dove stia la dif­fe­ren­za tra Apache Lucene da una parte e Apache Solr ed Ela­stic­search dall’altra. Gli ultimi due sono basati su Lucene: il vecchio prodotto è un motore di ricerca puro, mentre Solr ed Ela­stic­search sono server di ricerca completi che estendono ul­te­rior­men­te le capacità di Lucene.

Consiglio

Se avete solo bisogno di una ricerca per il vostro sito web, pro­ba­bil­men­te vi troverete meglio uti­liz­zan­do Solr o Ela­stic­search, due sistemi pro­get­ta­ti spe­ci­fi­ca­men­te per l’uso sul web.

Apache Lucene: tutorial

Lucene è basato su Java nella versione originale, il che consente di uti­liz­zar­lo per diverse piat­ta­for­me sia online che offline, se si sa come farlo. Spie­ghe­re­mo passo per passo come costruire il vostro motore di ricerca con Apache Lucene.

N.B.

In questo tutorial parleremo di Lucene basato su Java. Il codice è stato testato con Lucene versione 7.3.1 e JDK versione 8. Lavoriamo con Eclipse su Ubuntu. I singoli passaggi possono essere diversi se si uti­liz­za­no altri sistemi operativi e ambienti di sviluppo.

In­stal­la­zio­ne

Per poter lavorare con Apache Lucene è ne­ces­sa­rio aver in­stal­la­to Java. Come Lucene, potete scaricare gra­tui­ta­men­te anche il Java De­ve­lo­p­ment Kit (JDK) sul sito web ufficiale di Oracle. Dovreste anche in­stal­la­re un ambiente di sviluppo che vi permetta di scrivere il codice per Lucene. Molti svi­lup­pa­to­ri si affidano a Eclipse, ma ci sono molte altre offerte open source. Infine è possibile scaricare Lucene dalla pagina del progetto. Se­le­zio­na­te la core version del programma.

Non è ne­ces­sa­rio in­stal­la­re Lucene: basta de­com­pri­me­re il download in una posizione de­si­de­ra­ta. Quindi si crea un nuovo progetto in Eclipse o in un altro ambiente di sviluppo e si aggiunge Lucene come library. Per questo esempio uti­liz­ze­re­mo tre librerie che sono tutte incluse nel pacchetto di in­stal­la­zio­ne:

  • …/lucene-7.3.1/core/lucene-core-7.3.1.jar
  • …/lucene-7.3.1/que­ry­par­ser/lucene-que­ry­par­ser-7.3.1.jar
  • …/lucene-7.3.1/analysis/common/lucene-analyzers-common-7.3.1.jar

Se uti­liz­za­te una versione diversa o se avete mo­di­fi­ca­to la struttura della cartella, dovete mo­di­fi­ca­re di con­se­guen­za queste in­di­ca­zio­ni.

Immagine: Aggiunta di librerie in Eclipse
Inserite le librerie ne­ces­sa­rie per il vostro progetto.
Consiglio

Per com­pren­de­re i seguenti passaggi sono ne­ces­sa­rie delle co­no­scen­ze di base di Java e di pro­gram­ma­zio­ne in generale. Se avete delle co­no­scen­ze di base di questo lin­guag­gio di pro­gram­ma­zio­ne, lavorare con Lucene è un ottimo modo per svi­lup­pa­re le vostre com­pe­ten­ze.

In­di­ciz­za­zio­ne

Il nucleo di un motore di ricerca basato su Lucene è l’index, senza il quale non si possono dare funzioni di ricerca. Pertanto il primo passo è proprio quello di creare una classe Java per l’in­di­ciz­za­zio­ne.

Ma prima di costruire il mec­ca­ni­smo di in­di­ciz­za­zio­ne creeremo due classi che vi aiu­te­ran­no per i passi suc­ces­si­vi. Sia la classe indice che la classe di ricerca si basano su queste due.

package tutorial;
public class LuceneConstants {
    public static final String CONTENTS = "contents";
    public static final String FILE_NAME = "filename";
    public static final String FILE_PATH = "filepath";
    public static final int MAX_SEARCH = 10;
}

Queste in­for­ma­zio­ni si ri­ve­le­ran­no im­por­tan­ti più avanti, quando si tratterà di stabilire i campi in modo preciso.

package tutorial;
import java.io.File;
import java.io.FileFilter;
public class TextFileFilter implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        return pathname.getName().toLowerCase().endsWith(".txt");
    }
}

In questo modo im­ple­men­tia­mo un filtro che legge cor­ret­ta­men­te nei nostri documenti. A questo punto vi rendete già conto che il nostro motore di ricerca fun­zio­ne­rà solo per i file txt. Questo semplice esempio ignora tutti gli altri formati.

Immagine: File di testo come corpo di ricerca per Apache Lucene
Nel nostro esempio il corpo per la ricerca è co­sti­tui­to da semplici file di testo.
N.B.

All’inizio di una classe per prima cosa si importano altre classi che possono essere già parte della vostra in­stal­la­zio­ne Java, al­tri­men­ti sono di­spo­ni­bi­li at­tra­ver­so l’in­te­gra­zio­ne di librerie esterne.

Ora create la classe ap­pro­pria­ta per l’in­di­ciz­za­zio­ne.

package tutorial;
import java.io.File;
import java.io.FileFilter;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Paths;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
public class Indexer {
    private IndexWriter writer;
    public Indexer(String indexDirectoryPath) throws IOException {
        Directory indexDirectory = 
            FSDirectory.open(Paths.get(indexDirectoryPath));
        StandardAnalyzer analyzer = new StandardAnalyzer();
        IndexWriterConfig iwc = new IndexWriterConfig(analyzer);
        writer = new IndexWriter(indexDirectory, iwc);
    }
    public void close() throws CorruptIndexException, IOException {
        writer.close();
    }
    private Document getDocument(File file) throws IOException {
        Document document = new Document();
        TextField contentField = new TextField(LuceneConstants.CONTENTS, new FileReader(file));
        TextField fileNameField = new TextField(LuceneConstants.FILE_NAME,
            file.getName(),TextField.Store.YES);
        TextField filePathField = new TextField(LuceneConstants.FILE_PATH,
            file.getCanonicalPath(),TextField.Store.YES);
        document.add(contentField);
        document.add(fileNameField);
        document.add(filePathField);
        return document;
    }    
    private void indexFile(File file) throws IOException {
        System.out.println("Indexing "+file.getCanonicalPath());
        Document document = getDocument(file);
        writer.addDocument(document);
    }
    public int createIndex(String dataDirPath, FileFilter filter) 
        throws IOException {
        File[] files = new File(dataDirPath).listFiles();
        for (File file : files) {
            if(!file.isDirectory()
                && !file.isHidden()
                && file.exists()
                && file.canRead()
                && filter.accept(file)
            ){
                indexFile(file);
            }
        }
        return writer.numDocs();
    }
}

Nel corso del codice vengono ef­fet­tua­ti diversi passaggi: avete impostato In­dex­W­ri­ter uti­liz­zan­do Stan­dar­dA­na­ly­zer. Lucene offre diverse classi di analisi che possono essere trovate nella libreria cor­ri­spon­den­te.

Fatto

Nella do­cu­men­ta­zio­ne ufficiale di Apache Lucene trovate tutte le classi contenute nel download.

Inoltre il programma si addentra nei file e imposta campi per l’in­di­ciz­za­zio­ne. Alla fine del codice vengono creati i file index.

Immagine: File Index di Apache Lucene
Lucene crea più file indice dai documenti di partenza.

Funzione di ricerca

Na­tu­ral­men­te l’indice da solo non vi porta a nulla. Dovete infatti ancora stabilire una funzione di ricerca.

package tutorial;
import java.io.IOException;
import java.nio.file.Paths;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
public class Searcher {
	
   IndexSearcher indexSearcher;
   QueryParser queryParser;
   Query query;
   
   public Searcher(String indexDirectoryPath) 
      throws IOException {
      Directory indexDirectory = 
         FSDirectory.open(Paths.get(indexDirectoryPath));
      IndexReader reader = DirectoryReader.open(indexDirectory);
      indexSearcher = new IndexSearcher(reader);
      queryParser = new QueryParser(LuceneConstants.CONTENTS,
         new StandardAnalyzer());
   }
   
   public TopDocs search( String searchQuery) 
      throws IOException, ParseException {
      query = queryParser.parse(searchQuery);
      return indexSearcher.search(query, LuceneConstants.MAX_SEARCH);
   }
   public Document getDocument(ScoreDoc scoreDoc) 
      throws CorruptIndexException, IOException {
      return indexSearcher.doc(scoreDoc.doc);	
   }
}

Due delle classi importate da Lucene sono par­ti­co­lar­men­te im­por­tan­ti all’interno del codice: In­de­x­Sear­cher e Que­ry­Par­ser. Mentre il primo cerca nell’indice creato, Que­ry­Par­ser è re­spon­sa­bi­le del tra­sfe­ri­men­to della query di ricerca per elaborare in­for­ma­zio­ni com­pren­si­bi­li.

Ora avete sia una classe per l’in­di­ciz­za­zio­ne sia una per cercare all’interno dell’indice, ma non potete ancora fare una ricerca concreta con queste due: per farlo avete bisogno di una quinta classe.

package tutorial;
import java.io.IOException;
import org.apache.lucene.document.Document;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
public class LuceneTester {
	
   String indexDir = "/home/Index/";
   String dataDir = "/home/Data/";
   Indexer indexer;
   Searcher searcher;
   public static void main(String[] args) {
      LuceneTester tester;
      try {
         tester = new LuceneTester();
         tester.createIndex();
         tester.search("YourSearchTerm");
      } catch (IOException e) {
         e.printStackTrace();
      } catch (ParseException e) {
         e.printStackTrace();
      }
   }
   private void createIndex() throws IOException {
      indexer = new Indexer(indexDir);
      int numIndexed;
      long startTime = System.currentTimeMillis();	
      numIndexed = indexer.createIndex(dataDir, new TextFileFilter());
      long endTime = System.currentTimeMillis();
      indexer.close();
      System.out.println(numIndexed+" File indexed, time taken: "
         +(endTime-startTime)+" ms");		
   }
   private void search(String searchQuery) throws IOException, ParseException {
      searcher = new Searcher(indexDir);
      long startTime = System.currentTimeMillis();
      TopDocs hits = searcher.search(searchQuery);
      long endTime = System.currentTimeMillis();
   
      System.out.println(hits.totalHits +
         " documents found. Time :" + (endTime - startTime));
      for(ScoreDoc scoreDoc : hits.scoreDocs) {
         Document doc = searcher.getDocument(scoreDoc);
            System.out.println("File: "
            + doc.get(LuceneConstants.FILE_PATH));
      }  
   }
}

È ne­ces­sa­rio adattare almeno tre voci in queste classi finali, poiché qui si spe­ci­fi­ca­no i percorsi dei documenti originali e dei file di indice nonché il termine di ricerca.

  • String indexDir: qui si inserisce il percorso della cartella in cui si desidera salvare il file di indice.
  • String dataDir: qui il codice sorgente si aspetta il percorso per la cartella in cui sono ar­chi­via­ti i documenti da cercare.
  • tester.search: qui inserite il termine di ricerca.

Poiché si tratta di stringhe in tutti e tre i casi, è ne­ces­sa­rio rac­chiu­de­re le espres­sio­ni tra vir­go­let­te. Anche in Windows si usano le barre normali invece dei backslash per i percorsi.

Per testare il programma copiate alcuni file di testo normale nella directory spe­ci­fi­ca­ta come dataDir. As­si­cu­ra­te­vi che le esten­sio­ni dei file siano “.txt”. Ora potete avviare il programma: in Eclipse, ad esempio, per farlo vi basterà cliccare sul pulsante con la freccia verde nella barra dei menu.

N.B.

Il codice di programma pre­sen­ta­to è solo un progetto di­mo­stra­ti­vo per chiarire come funziona Lucene. Ad esempio, in questo programma manca un’in­ter­fac­cia utente grafica: è ne­ces­sa­rio inserire il termine di ricerca di­ret­ta­men­te nel codice sorgente e il risultato è di­spo­ni­bi­le solo tramite la console.

Immagine: Codice sorgente in Eclipse e risultati di una ricerca su Lucen nella console
Eclipse mostra il risultato della vostra ricerca nella console.

Lucene Query Syntax

I motori di ricerca, anche quelli che vi sono noti dal web, in genere non con­sen­to­no soltanto di cercare un termine singolo. Alcuni metodi infatti per­met­to­no di mettere insieme le parole, cercare frasi o escludere singole parole. Na­tu­ral­men­te anche Apache Lucene offre queste pos­si­bi­li­tà: con Lucene Query Syntax si cercano espres­sio­ni complesse, anche in diversi campi.

  • Single Term: consiste nell’immettere un termine semplice così com’è. A dif­fe­ren­za di Google e Co., Lucene pre­sup­po­ne che sappiate come si scrive il termine. Se com­met­te­te errori nella di­gi­ta­zio­ne, i risultati saranno negativi. Esempio: auto.
  • Phrase: per frasi si intendono suc­ces­sio­ni stabilite di parole. Non sono decisivi solo i termini in­di­vi­dua­li all’interno della frase, ma anche l’ordine in cui si trovano. Esempio: "La mia auto è rossa".
  • Wildcard Searches: consiste nell’uti­liz­za­re me­ta­ca­rat­te­ri per so­sti­tui­re uno o più caratteri nella query di ricerca. I me­ta­ca­rat­te­ri possono essere uti­liz­za­ti alla fine o alla metà di un termine, ma non all’inizio.
    • ?: il punto in­ter­ro­ga­ti­vo è appunto un tale me­ta­ca­rat­te­re. Esempio: Au?o
    • *: l’asterisco può so­sti­tui­re da zero a infiniti caratteri. In questo modo può con­sen­ti­re la ricerca ad esempio di altre forme di un termine. Esempio: Auto* per “au­to­mo­bi­le”
  • Regular Ex­pres­sion Searches: le espres­sio­ni regolari cercano più termini con­tem­po­ra­nea­men­te, alcuni dei quali pre­sen­ta­no so­mi­glian­ze e talvolta dif­fe­ri­sco­no. Con­tra­ria­men­te ai me­ta­ca­rat­te­ri, essi de­fi­ni­sco­no esat­ta­men­te quali va­ria­zio­ni si prendono in con­si­de­ra­zio­ne. Per farlo si possono usare le barre e le parentesi quadre. Esempio: /[MS]on/
  • Fuzzy Searches: si uti­liz­za­no ad esempio quando de­si­de­ra­te una certa tol­le­ran­za di errore. Uti­liz­zan­do la distanza di Damerau-Le­ven­sh­tein, una formula che valuta le so­mi­glian­za, si imposta quanto ampia possa essere la de­via­zio­ne. Per questo si usa il simbolo della tilde. Sono con­sen­ti­te distanze da 0 a 2. Esempio: Auto~1
  • Proximity Searches: anche se si desidera che ci sia un’ap­pros­si­ma­zio­ne delle frasi, uti­liz­za­te la tilde. Ad esempio potete spe­ci­fi­ca­re due termini di ricerca che vanno ricercati anche quadndo tra di loro sono frapposte altre 5 parole. Esempio: "Auto rossa"~5
  • Range Searches: in questa forma di richiesta si cerca in una par­ti­co­la­re area tra due termini. Sebbene tale ricerca abbia poco senso per il contenuto generale di un documento, può essere molto utile per trattare specifici campi come autori o titoli. Lo smi­sta­men­to funziona secondo un ordine les­si­co­gra­fi­co. Nel chia­ri­fi­ca­re un’area inclusiva con parentesi quadre uti­liz­za­te le parentesi graffe per escludere dall’in­ter­ro­ga­zio­ne l’area spe­ci­fi­ca­ta dai due termini di ricerca. I due termini si de­li­mi­ta­no con TO. Esempio: [Allende TO Borges] o {Byron TO Shelley}
  • Boosting: Lucene vi dà la pos­si­bi­li­tà di fornire termini e frasi di ricerca più per­ti­nen­ti di altri. Questo influenza l’ordine dei risultati. Il boosting si imposta con il cir­con­fles­so seguito da un valore. Esempio: Auto^2 rot
  • Boolean Operators: potete uti­liz­za­re gli operatori logici per creare con­nes­sio­ni tra termini all’interno di una query di ricerca. Gli operatori devono sempre essere scritti in lettere minuscole in modo che Lucene non li valuti come normali termini di ricerca.
    • AND: per un’ope­ra­zio­ne AND devono essere presenti entrambi i termini nel documento affinché appaiano come risultato. Invece dell’espres­sio­ne in lettere potete anche uti­liz­za­re due e com­mer­cia­li (“&”) con­se­cu­ti­ve. Esempio: Auto && rosso
    • OR: l’operatore OR è l’opzione pre­de­fi­ni­ta (quindi sot­tin­te­sa) quando sem­pli­ce­men­te si in­se­ri­sco­no due parole una dopo l’altra. Uno dei termini deve essere ob­bli­ga­to­rio, ma possono anche essere presenti insieme nel documento. La com­bi­na­zio­ne OR si crea o con OR, “||” o non inserendo alcun operatore. Esempio: Auto rossa
    • +: con il segno “+” create un caso specifico dell’ope­ra­zio­ne OR. Po­si­zio­nan­do il segno di­ret­ta­men­te davanti alla parola di una ricerca composta da due (o più) termini, significa che essa deve essere presente mentre l’altra è fa­col­ta­ti­va. Esempio: +Auto rossa
    • NOT: l’operatore NOT esclude de­ter­mi­na­ti termini o frasi della ricerca. È possibile so­sti­tui­re l’operatore con un punto escla­ma­ti­vo o mettere un segno negativo im­me­dia­ta­men­te prima del termine da escludere. Non è possibile uti­liz­za­re l’operatore NOT con un solo termine o una sola frase. Esempio: Auto rossa -blu
  • Grouping: con le parentesi si possono rag­grup­pa­re termini nelle query di ricerca. In questo modo create input più complessi con i quali ad esempio ac­cop­pia­te in modo ne­ces­sa­rio un termine con un altro dei due termini. Esempio: Auto AND (rossa OR blu)
  • Escaping Special Cha­rac­ters: per uti­liz­za­re caratteri che sono uti­liz­za­bi­li per Lucene Query Syntax, com­bi­na­te­li con un backslash. In questo modo potete inserire un punto in­ter­ro­ga­ti­vo in una ricerca senza che l’ana­liz­za­to­re lo in­ter­pre­ti come un me­ta­ca­rat­te­re. Esempio: "Dov’è la mia auto\?"

Apache Lucene: vantaggi e svantaggi

Lucene è un potente strumento per stabilire una funzione di ricerca sul web, negli archivi o nelle ap­pli­ca­zio­ni. I fan di Lucene ap­prez­za­no il fatto di poter costruire, at­tra­ver­so l’in­di­ciz­za­zio­ne, un motore di ricerca molto veloce che può essere adattato in modo molto det­ta­glia­to alle proprie esigenze. Essendo un progetto open source, infatti, Lucene non solo è di­spo­ni­bi­le gra­tui­ta­men­te, ma è anche svi­lup­pa­to co­stan­te­men­te da una grande community.

Quindi ora potrete usarlo oltre che in Java anche in PHP, Python e altri linguaggi di pro­gram­ma­zio­ne. E qui si arriva all’unico lato negativo: sono as­so­lu­ta­men­te ne­ces­sa­rie com­pe­ten­ze di pro­gram­ma­zio­ne. La ricerca full-text non è perciò una soluzione adatta a tutti. Se avete soltanto bisogno di una funzione di ricerca per il vostro sito web, è si­cu­ra­men­te meglio optare per altre soluzioni.

Vantaggi Svantaggi
Di­spo­ni­bi­le per diversi linguaggi di pro­gram­ma­zio­ne Necessita co­no­scen­ze di pro­gram­ma­zio­ne
Open source
Veloce e snello
Ranked searching
Possibili query di ricerca complesse
Molto fles­si­bi­le
Vai al menu prin­ci­pa­le