Lettore di directory di classe
Lettore di directory è un'implementazione di Lettore Composito che può leggere gli indici in a elenco.
Lettore di directory le istanze sono generalmente costruite con una chiamata a uno degli statici Open()
metodi, ad es Apri(Directory).
Per efficienza, in questa API i documenti sono spesso indicati tramite numeri di documento, numeri interi non negativi che nominano ciascuno un documento univoco nell'indice. Questi numeri di documento sono temporanei: possono cambiare quando i documenti vengono aggiunti ed eliminati da un indice. I clienti non dovrebbero quindi fare affidamento su un determinato documento che ha lo stesso numero tra le sessioni.
NOTA: Lettore di indici le istanze sono completamente thread-safe, il che significa che più thread possono chiamare uno qualsiasi dei suoi metodi, contemporaneamente. Se la tua applicazione richiede la sincronizzazione esterna, dovresti non sincronizzare sul Lettore di indici esempio; usa invece i tuoi oggetti (non Lucene).
Eredità
Membri ereditati
montaggio: DistributedLuce.Net.dll
Sintassi
public abstract class DirectoryReader : BaseCompositeReader<AtomicReader>, IIdentifiableSurrogate
Costruttori
Nome | Descrizione |
---|---|
Lettore di directory(Directory, Lettore atomico[]) | Esperto: Costruisce a Lettore di directory sul dato |
Lettore directory(Stringa, NCacheDirectory, tipo) |
campi
Nome | Descrizione |
---|---|
DEFAULT_TERMS_INDEX_DIVISOR | Termine predefinitoInfosIndexDivisor. |
directory_m | La directory dell'indice. |
Properties
Nome | Descrizione |
---|---|
Consenti risultati parziali | Imposta il comportamento del risultato in caso di cluster parziale |
elenco | Restituisce la directory in cui risiede questo indice. |
IndiceCommit | Esperto: restituire il IndiceCommit che questo lettore ha aperto. @lucene.sperimentale |
Versione | Numero di versione quando questo Lettore di indici era aperto. Questo metodo restituisce la versione registrata nel commit che il lettore ha aperto. Questa versione è avanzata ogni volta che viene apportata una modifica Indice scrittore. |
Metodi
Nome | Descrizione |
---|---|
DoOpenIfChanged() | Implementare questo metodo per supportare OpenIfChanged(Lettore Directory). Se questo lettore non supporta la riapertura, ritorna |
DoOpenIfChanged(IndexCommit) | Implementare questo metodo per supportare OpenIfChanged(DirectoryReader, IndexCommit). Se questo lettore non supporta, riapri da uno specifico IndiceCommit, gettare |
DoOpenIfChanged(IndexWriter, Booleano) | Implementare questo metodo per supportare OpenIfChanged(DirectoryReader, IndexWriter, Booleano). Se questo lettore non supporta, riapri da Indice scrittore, gettare |
Indice esiste (directory) | Reso |
È attuale() | Controlla se sono state apportate nuove modifiche all'indice dall'apertura di questo lettore. Se questo lettore è stato creato chiamando un overload di Apri(Directory), quindi questo metodo controlla se ci sono altri commit (vedi Commettere()) si sono verificati nella directory. Se invece questo lettore è un lettore quasi in tempo reale (cioè ottenuto tramite una chiamata a
Apri(IndexWriter, Booleano)o chiamando un overload di OpenIfChanged(Lettore Directory)
su un lettore quasi in tempo reale), quindi questo metodo controlla se si è verificato un nuovo commit o se sono state apportate nuove modifiche non vincolate tramite lo scrittore. Si noti che anche se lo scrittore ha eseguito solo l'unione, questo metodo verrà comunque restituito In ogni caso, se questo ritorna |
ListCommits(Directory) | Restituisce tutti i punti di commit che esistono in elenco. Normalmente, perché l'impostazione predefinita è KeepOnlyLastCommitDeletionPolicy, ci sarebbe un solo punto di commit. Ma se stai usando un'abitudine IndiceDeletionPolicy allora potrebbero esserci molti commit. Una volta che hai un determinato commit, puoi aprire un lettore su di esso chiamando Apri(IndiceCommit) Deve esserci almeno un commit in elenco, altrimenti questo metodo genera IndexNotFoundException. Si noti che se è in corso un commit mentre questo metodo è in esecuzione, tale commit può essere restituito o meno. |
Apri(IndiceCommit) | Esperto: restituisce un Lettore di indici leggendo l'indice nel dato IndiceCommit. |
Apri(IndexCommit, Int32) | Esperto: restituisce un Lettore di indici leggendo l'indice nel dato
IndiceCommit ed |
Apri(IndexWriter, Booleano) | Apri quasi in tempo reale Lettore di indici dal Indice scrittore. @lucene.sperimentale |
Apri(Directory) | Restituisce un file Lettore di indici leggendo l'indice nel dato elenco |
Apri(Directory, Int32) | Esperto: Resi a Lettore di indici leggendo l'indice nel dato elenco con il dato termineInfosIndexDivisor. |
OpenIfChanged(Lettore Directory) | Se l'indice è cambiato dall'apertura del lettore fornito, apri e restituisci un nuovo lettore; altrimenti, torna
Questo metodo è in genere molto meno costoso dell'apertura di uno completamente nuovo Lettore di directory poiché condivide le risorse (ad esempio i lettori secondari) con il fornito Lettore di directory, quando possibile. Il lettore fornito non è eliminato (l'utente è responsabile di farlo); se viene restituito un nuovo lettore è necessario eventualmente smaltirlo. Assicurati di non smaltire mai un lettore mentre altri thread lo stanno ancora utilizzando; vedere Cercatore Manager per semplificare la gestione di questo. |
OpenIfChanged(DirectoryReader, IndexCommit) | Se l' IndiceCommit differisce da ciò che il lettore fornito sta cercando, apre e restituisce un nuovo lettore; altrimenti, torna |
OpenIfChanged(DirectoryReader, IndexWriter, Booleano) | Esperto: Se ci sono cambiamenti (impegnati o meno) nel
Indice scrittore rispetto a ciò che il lettore fornito sta cercando, quindi aprilo e restituiscine uno nuovo
Lettore di indici ricercare sia le modifiche commesse che quelle non vincolate dallo scrittore; altrimenti, torna Ciò fornisce una ricerca "quasi in tempo reale", in quanto le modifiche apportate durante un Indice scrittore la sessione può essere resa rapidamente disponibile per la ricerca senza chiudere lo scrittore né chiamare Commettere(). Suo vicino in tempo reale perché non vi è alcuna garanzia sulla velocità con cui puoi ottenere un nuovo lettore dopo aver apportato modifiche Indice scrittore. Dovrai sperimentare nella tua situazione per determinare se è abbastanza veloce. Poiché si tratta di una funzionalità nuova e sperimentale, riferisci i tuoi risultati in modo che possiamo imparare, migliorare e ripetere. La prima volta che questo metodo viene chiamato, questa istanza di writer farà ogni sforzo per mettere in comune i lettori che apre per eseguire unioni, applicare eliminazioni, ecc. Ciò significa che verranno consumate risorse aggiuntive (RAM, descrittori di file, tempo della CPU). Per una latenza inferiore alla riapertura di un lettore, dovresti chiamare MergedSegmentWarmer (sopra IndexWriterConfig) per preriscaldare un segmento appena unito prima che venga eseguito il commit nell'indice. Questo è importante per ridurre al minimo il ritardo tra l'indice e la ricerca dopo un'unione di grandi dimensioni. Se una chiamata AddIndexes* è in esecuzione in un altro thread, questo lettore cercherà solo quei segmenti dell'indice esterno che sono stati copiati con successo, finora. NOTA: Una volta eliminato lo scrittore, tutti i lettori in sospeso possono continuare a essere utilizzati. Tuttavia, se tenti di riaprire uno di questi lettori, colpirai un @lucene.sperimentale |