Classe IndexWriter
An Indice scrittore crea e mantiene un indice.
Eredità
montaggio: DistributedLuce.Net.dll
Sintassi
public class IndexWriter : IDisposable, ITwoPhaseCommit, IIdentifiableSurrogate
Commento
I Modalità aperta opzione attivata Modalità aperta determina se viene creato un nuovo indice o se viene aperto un indice esistente. Nota che puoi aprire un indice con CREA anche mentre i lettori utilizzano l'indice. I vecchi lettori continueranno a cercare l'istantanea "punto nel tempo" che avevano aperto e non vedranno l'indice appena creato finché non riapriranno. Se CREATE_OR_APPEND viene usato Indice scrittore creerà un nuovo indice se non è già presente un indice nel percorso fornito e in caso contrario aprirà l'indice esistente.
In entrambi i casi, i documenti vengono aggiunti AddDocument(IEnumerable ) e rimosso con Elimina documenti (termine) or Elimina documenti (interrogazione). Un documento può essere aggiornato con UpdateDocument(Term, IEnumerable ) (che elimina e quindi aggiunge l'intero documento). Al termine dell'aggiunta, eliminazione e aggiornamento dei documenti, Smaltire() dovrebbe essere chiamato.
Queste modifiche vengono memorizzate nel buffer e periodicamente scaricate nel file elenco (durante le chiamate al metodo precedenti). Un flush viene attivato quando ci sono abbastanza documenti aggiunti dall'ultimo flush. Lo svuotamento viene attivato dall'utilizzo della RAM dei documenti (vedi Dimensioni buffer RAM MB) o il numero di documenti aggiunti (cfr MaxBufferedDocs). L'impostazione predefinita è svuotare quando si verifica l'utilizzo della RAM DEFAULT_RAM_BUFFER_SIZE_MB MB. Per la migliore velocità di indicizzazione dovresti svuotare in base all'utilizzo della RAM con un buffer RAM di grandi dimensioni. Inoltre, se Indice scrittore raggiunge il numero configurato di eliminazioni nel buffer (vedi MaxBufferedDeleteTerms) i termini e le query eliminati vengono cancellati e applicati ai segmenti esistenti. In contrasto con le altre opzioni di risciacquo Dimensioni buffer RAM MB ed MaxBufferedDocs, i termini eliminati non attiveranno uno svuotamento del segmento. Si noti che lo svuotamento sposta semplicemente lo stato bufferizzato interno Indice scrittore nell'indice, ma queste modifiche non sono visibili a Lettore di indici fino a quando nessuno dei due Commettere() or Smaltire() è chiamato. Un flush può anche attivare uno o più unioni di segmenti che per impostazione predefinita vengono eseguiti con un thread in background in modo da non bloccare le chiamate addDocument (vedi sotto per cambiare il Lucene.Net.Index.IndexWriter.mergeScheduler).
Apertura di un Indice scrittore crea un file di blocco per la directory in uso. Cercando di aprirne un altro Indice scrittore nella stessa directory porterà a a LockObtainFailedException. LockObtainFailedException viene lanciato anche se un Lettore di indici nella stessa directory viene utilizzato per eliminare i documenti dall'indice.
esperto: Indice scrittore consente un optional IndiceDeletionPolicy attuazione da precisare. Puoi usarlo per controllare quando i commit precedenti vengono eliminati dall'indice. La politica predefinita è KeepOnlyLastCommitDeletionPolicy che rimuove tutti i commit precedenti non appena viene eseguito un nuovo commit (questo corrisponde al comportamento prima della 2.2). La creazione di una propria policy può consentire di mantenere in modo esplicito i precedenti commit "point in time" attivi nell'indice per un po' di tempo, per consentire ai lettori di aggiornarsi al nuovo commit senza che il vecchio commit venga eliminato da sotto di essi. Ciò è necessario su filesystem come NFS che non supportano la semantica "cancella all'ultima chiusura", su cui normalmente si basa la ricerca "point in time" di Lucene.
esperto: Indice scrittore consente di modificare separatamente il Lucene.Net.Index.IndexWriter.mergePolicy e la Lucene.Net.Index.IndexWriter.mergeScheduler. Il Lucene.Net.Index.IndexWriter.mergePolicy viene richiamato ogni volta che vengono apportate modifiche ai segmenti nell'indice. Il suo ruolo è selezionare quali unioni eseguire, se presenti, e restituire a MergePolicy.MergeSpecification descrivere le fusioni. L'impostazione predefinita è LogByteSizeMergePolicy. Poi il Unisci pianificazione viene invocato con le unioni richieste e decide quando e come eseguire le unioni. L'impostazione predefinita è ConcurrentMergeScheduler.
NOTA: se colpisci un
NOTA: Indice scrittore 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 Indice scrittore esempio in quanto ciò potrebbe causare deadlock; usa invece i tuoi oggetti (non Lucene).
NOTA: Se chiami
Costruttori
Nome | Descrizione |
---|---|
IndexWriter(Directory, IndexWriterConfig) | Costruisce un nuovo Indice scrittore secondo le impostazioni fornite NOTA: dopo che questo writer è stato creato, l'istanza di configurazione specificata non può essere passata a un altro writer. Se hai intenzione di farlo, dovresti Clone() in anticipo. |
campi
Nome | Descrizione |
---|---|
MAX_TERM_LENGTH | Lunghezza massima assoluta per un termine, in byte una volta codificata come UTF8. Se un termine arriva dall'analizzatore più lungo di questa lunghezza, an
|
FONTE | Chiave per l'origine di un segmento in Diagnostica Ultrasuoni. |
SOURCE_ADDINDEXES_LETTORI | Sorgente di un segmento che risulta da una chiamata a AggiungiIndici(LettoreIndice[]). |
FONTE_FLUSH | Sorgente di un segmento che risulta da un colore. |
FONTE_MERGE | Sorgente di un segmento che risulta dall'unione di altri segmenti. |
WRITE_LOCK_NAME | Nome del blocco di scrittura nell'indice. |
Properties
Nome | Descrizione |
---|---|
Consenti risultati parziali | Impostare su false per restituire un errore generale se la richiesta produce risultati parziali. Impostato su true, che consentirà risultati parziali in caso di cluster parziale. |
Analyzer | Ottiene l'analizzatore utilizzato da questo indice. |
CommitData | Restituisce la mappa dei dati utente del commit su cui è stato eseguito il commit per ultimo o quella su cui è stato impostato SetCommitData(IDdizionario ). |
Config | Restituisce un file LiveIndexWriterConfig, che può essere utilizzato per interrogare il Indice scrittore impostazioni correnti, nonché modificare quelle "live". |
elenco | Ottiene il file elenco utilizzato da questo indice. |
È chiuso | |
KeepFullyDeletedSegments | Solo per test. @lucene.interna |
Max Doc | Ottiene il numero totale di documenti in questo indice, inclusi i documenti non ancora scaricati (ancora nel buffer RAM), senza contare le eliminazioni. |
Unione di segmenti | Esperto: ad uso di a MergePolicy per evitare di selezionare unioni per i segmenti già uniti. La raccolta restituita non viene clonata e quindi è possibile accedervi in modo sicuro solo se si tiene Indice scrittore's lock (cosa che fai quando Indice scrittore invoca il MergePolicy). Non alterare la collezione restituita! |
NumDoc | Ottiene il numero totale di documenti in questo indice, inclusi i documenti non ancora scaricati (ancora nel buffer della RAM) e incluse le eliminazioni. NOTA: le eliminazioni memorizzate nel buffer non vengono conteggiate. Se hai davvero bisogno che questi vengano contati dovresti chiamare Commettere() prima. |
Operazioni completate | Le operazioni di scrittura dell'indice sono tutte asincrone. Restituisce vero se tutti sono completi. |
Metodi
Nome | Descrizione |
---|---|
AddDocument(IEnumerable ) | Aggiunge un documento a questo indice. Si noti che se un Questo metodo scarica periodicamente i documenti in sospeso nel elenco (Vedi Indice scrittore), e inoltre attiva periodicamente le fusioni di segmenti nell'indice in base a MergePolicy in uso. Le unioni consumano temporaneamente spazio nella directory. La quantità di spazio richiesta è fino a 1 volte la dimensione di tutti i segmenti da unire, quando nessun lettore/cercatore è aperto sull'indice e fino a 2 volte la dimensione di tutti i segmenti da unire quando i lettori/cercatori sono aperti sull'indice (vedi Forza unione(Int32) per dettagli). La sequenza delle operazioni di unione primitive eseguite è regolata dalla politica di unione. Si noti che ogni termine nel documento non può essere più lungo di MAX_TERM_LENGTH in byte, altrimenti an
Nota che è possibile creare una stringa Unicode non valida in java se una coppia di surrogati UTF16 non è corretta. In questo caso, i caratteri non validi vengono sostituiti automaticamente con il carattere sostitutivo Unicode U+FFFD. NOTA: se questo metodo colpisce un |
AddDocument(IEnumerable , Analizzatore) | Aggiunge un documento a questo indice, utilizzando il file fornito See AddDocument(IEnumerable ) per i dettagli sull'indice e Indice scrittore stato dopo un NOTA: se questo metodo colpisce un |
AddDocuments(IDictionary , Analizzatore>) | |
AddDocuments(IEnumerable >) | Aggiunge atomicamente un blocco di documenti con ID documento assegnati in sequenza, in modo tale che un lettore esterno possa vedere tutti o nessuno dei documenti. AVVERTIMENTO: l'indice non registra attualmente quali documenti sono stati aggiunti come blocco. Oggi va bene, perché l'unione conserverà un blocco. L'ordine dei documenti all'interno di un segmento verrà mantenuto, anche quando i documenti figlio all'interno di un blocco vengono eliminati. La maggior parte delle funzioni di ricerca (come il raggruppamento dei risultati e l'unione di blocchi) richiedono di contrassegnare i documenti; quando questi documenti vengono eliminati, queste funzioni di ricerca non funzioneranno come previsto. Ovviamente l'aggiunta di documenti a un blocco esistente richiederà la reindicizzazione dell'intero blocco. Tuttavia è possibile che in futuro Lucene possa unire i documenti in modo più aggressivo (ad esempio, forse per ottenere una migliore compressione dell'indice), nel qual caso potrebbe essere necessario reindicizzare completamente i documenti in quel momento. See AddDocument(IEnumerable ) per i dettagli sull'indice e Indice scrittore stato dopo un NOTA: gli strumenti che eseguono la suddivisione offline di un indice (ad esempio, IndexSplitter in Lucene.Net.Misc) o il riordinamento dei documenti (ad esempio, IndexSorter in contrib) non sono a conoscenza di questi documenti aggiunti atomicamente e probabilmente li scomporranno. Utilizzare tali strumenti a proprio rischio! NOTA: se questo metodo colpisce un @lucene.sperimentale |
AddDocuments(IEnumerable >, Analizzatore) | Aggiunge atomicamente un blocco di documenti, analizzati utilizzando il fornito @lucene.sperimentale |
AggiungiIndici(LettoreIndice[]) | Unisce gli indici forniti in questo indice. Il fornito Lettore di indicis non sono chiusi.
See AggiungiIndici(LettoreIndice[]) per i dettagli sulla semantica transazionale, spazio libero temporaneo richiesto nel file elencoe segmenti non CFS su an
NOTA: se questo metodo colpisce un NOTA: i segmenti vuoti vengono eliminati con questo metodo e non vengono aggiunti a questo indice.
NOTA: questo metodo unisce tutti i dati Lettore di indicis in una fusione. Se intendi unire un numero elevato di lettori, potrebbe essere meglio chiamare questo metodo più volte, ogni volta con un piccolo gruppo di lettori. In linea di principio, se si utilizza un criterio di unione con a
NOTA: se chiami Elimina (Booleano) con |
AggiungiIndici(Directory[]) | Aggiunge tutti i segmenti da una matrice di indici a questo indice. Questo può essere utilizzato per parallelizzare l'indicizzazione batch. Una grande raccolta di documenti può essere suddivisa in sottoraccolte. Ogni sottoraccolta può essere indicizzata in parallelo, su un thread, un processo o una macchina diversi. L'indice completo può quindi essere creato unendo gli indici di sottoraccolta con questo metodo. NOTA: questo metodo acquisisce il blocco di scrittura in ogni directory, per garantire che n Indice scrittore è attualmente aperto o tenta di aprire mentre è in esecuzione. Questo metodo è transazionale in quanto Si noti che ciò richiede spazio libero temporaneo nel file elenco fino a 2 volte la somma di tutti gli indici di input (incluso l'indice di partenza). Se i lettori/cercatori sono aperti rispetto all'indice iniziale, lo spazio libero temporaneo richiesto sarà maggiore della dimensione dell'indice iniziale (vedi Forza unione(Int32) per dettagli). NOTA: questo metodo copia solo i segmenti degli indici in entrata e non li unisce. Pertanto i documenti eliminati non vengono rimossi ei nuovi segmenti non vengono uniti a quelli esistenti. Ciò richiede che questo indice non sia tra quelli da aggiungere.
NOTA: se questo metodo colpisce un |
Commettere() | Impegna tutte le modifiche in sospeso (documenti aggiunti ed eliminati, unioni di segmenti, indici aggiunti, ecc.) nell'indice e sincronizza tutti i file di indice di riferimento, in modo che un lettore possa vedere le modifiche e gli aggiornamenti dell'indice sopravvivano a un arresto anomalo del sistema operativo o della macchina o perdita di potenza. Si noti che questo non attende il completamento di eventuali unioni in background in esecuzione. Questa potrebbe essere un'operazione costosa, quindi dovresti testare il costo nella tua applicazione e farlo solo quando veramente necessario. Si noti che questa operazione chiama Sincronizza(ICollezione ) sui file di indice. Quella chiamata non dovrebbe tornare fino a quando il contenuto del file e i metadati non sono su una memoria stabile. Per Directory FS, questo chiama fsync del sistema operativo. Ma attenzione: alcuni dispositivi hardware potrebbero infatti memorizzare nella cache le scritture anche durante fsync e tornare prima che i bit siano effettivamente su una memoria stabile, per dare l'impressione di prestazioni più veloci. Se si dispone di un dispositivo del genere e non dispone di una batteria di backup (ad esempio), in caso di interruzione dell'alimentazione potrebbe comunque perdere dati. Lucene non può garantire la coerenza su tali dispositivi. NOTA: se questo metodo colpisce un |
Cancella tutto() | Elimina tutti i documenti nell'indice. Questo metodo eliminerà tutti i documenti memorizzati nel buffer e rimuoverà tutti i segmenti dall'indice. Questa modifica non sarà visibile fino a quando a Commettere() è stato chiamato. Questo metodo può essere ripristinato utilizzando Ripristina(). NOTA: questo metodo è molto più veloce dell'utilizzo NOTA: questo metodo interromperà forzatamente tutte le unioni in corso. Se sono in esecuzione altri thread Forza unione(Int32), AggiungiIndici(LettoreIndice[]) or ForzaUnisciElimina() metodi, possono ricevere MergePolicy.MergeAbortedExceptions. |
Elimina documenti (termine) | Elimina i documenti che li contengono NOTA: se questo metodo colpisce un |
Elimina documenti(Termine[]) | Elimina i documenti contenenti uno qualsiasi dei termini. Tutte le eliminazioni date vengono applicate e svuotate atomicamente allo stesso tempo. NOTA: se questo metodo colpisce un |
Elimina documenti (interrogazione) | Elimina i documenti corrispondenti alla query fornita. NOTA: se questo metodo colpisce un |
Elimina documenti(interrogazione[]) | Elimina i documenti che corrispondono a una qualsiasi delle query fornite. Tutte le eliminazioni date vengono applicate e svuotate atomicamente allo stesso tempo. NOTA: se questo metodo colpisce un |
EliminaFileInutilizzati() | Esperto: rimuove tutti i file di indice che non sono più utilizzati. Indice scrittore normalmente elimina i file inutilizzati da solo, durante l'indicizzazione. Tuttavia, su Windows, che non consente l'eliminazione dei file aperti, se è presente un lettore aperto nell'indice, tali file non possono essere eliminati. Questo va bene, perché Indice scrittore riproverà periodicamente l'eliminazione. Però, i Indice scrittore non ci prova spesso: solo su apertura, chiusura, svuotamento di un nuovo segmento e finitura di un'unione. Se non esegui nessuna di queste azioni con il tuo Indice scrittore, vedrai che i file inutilizzati rimangono. Se questo è un problema, chiama questo metodo per eliminarli (una volta chiusi i lettori aperti che ne impedivano l'eliminazione). Inoltre, puoi chiamare questo metodo per eliminare i commit dell'indice senza riferimenti. questo potrebbe essere utile se stai usando un IndiceDeletionPolicy che mantiene i commit dell'indice fino a quando alcuni criteri non vengono soddisfatti, ma quei commit non sono più necessari. In caso contrario, tali commit verranno eliminati la prossima volta Commettere() è chiamato. |
Smaltire() | Conferma tutte le modifiche a un indice, attende il completamento delle unioni in sospeso e chiude tutti i file associati. Questo è un "arresto graduale lento" che potrebbe richiedere molto tempo, specialmente se è in sospeso un grande unione: se vuoi solo chiudere le risorse, usa Ripristina(). Se vuoi solo confermare le modifiche in sospeso e chiudere le risorse, vedi Elimina (Booleano). Tieni presente che questa potrebbe essere un'operazione costosa, quindi prova a riutilizzare un singolo writer invece di chiuderne e aprirne uno nuovo. Vedere Commettere() per avvertimenti sulla memorizzazione nella cache di scrittura eseguita da alcuni dispositivi IO. Se uno Se è possibile correggere la causa sottostante (ad esempio liberare spazio su disco), è possibile chiamare Smaltire() ancora. In caso contrario, se vuoi forzare il rilascio del blocco di scrittura (pericoloso, perché potresti perdere i documenti nel buffer Indice scrittore esempio) allora puoi fare qualcosa del genere:
dopodiché, devi essere certo di non utilizzare più l'istanza dello scrittore. NOTA: se questo metodo colpisce un |
Elimina (Booleano) | Chiude l'indice con o senza attendere il termine delle unioni attualmente in esecuzione. Questo è significativo solo quando si utilizza a Unisci pianificazione che esegue si unisce nei thread in background. NOTA: se questo metodo colpisce un NOTA: è pericoloso chiamare sempre
|
EseguiDoAfterFlush() | Un hook per estendere le classi per eseguire operazioni dopo che i documenti aggiunti ed eliminati in sospeso sono stati scaricati in elenco ma prima che la modifica venga confermata (nuovo file segments_N scritto). |
Fare prima di sciacquare() | Un hook per estendere le classi per eseguire operazioni prima che i documenti aggiunti ed eliminati in sospeso vengano scaricati in elenco. |
GarantireAperto() | Utilizzato internamente per lanciare un
Bandi GarantireAperto(Booleano). |
GarantireAperto(Booleano) | Utilizzato internamente per lanciare un |
Flush(Booleano, Booleano) | Scarica tutti gli aggiornamenti bufferizzati in memoria (aggiunte ed eliminazioni) in elenco. |
Forza unione(Int32) | Forza la politica di unione per unire i segmenti finché non ci sono <=
Questa è un'operazione terribilmente costosa, soprattutto quando si passa un piccolo Tieni presente che ciò richiede fino a 2 volte lo spazio libero della dimensione dell'indice nella directory (3 volte se stai utilizzando un formato di file composto). Ad esempio, se la dimensione dell'indice è 10 MB, sono necessari fino a 20 MB per il completamento (30 MB se si utilizza un formato di file composto). Inoltre, è meglio chiamare Commettere() dopo, per consentire Indice scrittore liberare spazio su disco. Se alcuni lettori, ma non tutti, si riaprono mentre è in corso l'unione, ciò causerà il consumo di > 2 volte lo spazio temporaneo poiché quei nuovi lettori manterranno aperti i segmenti temporanei in quel momento. È meglio non riaprire i lettori mentre è in corso l'unione. L'effettivo utilizzo temporaneo potrebbe essere molto inferiore a queste cifre (dipende da molti fattori). In generale, una volta completato, la dimensione totale dell'indice sarà inferiore alla dimensione dell'indice iniziale. Potrebbe essere un po' più piccolo (se ci fossero molte eliminazioni in sospeso) o solo leggermente più piccolo. Se uno Questa chiamata unirà quei segmenti presenti nell'indice quando è iniziata la chiamata. Se altri thread stanno ancora aggiungendo documenti e svuotando i segmenti, quei segmenti appena creati non verranno uniti a meno che tu non chiami Forza unione(Int32) nuovamente. NOTA: se questo metodo colpisce un NOTA: se chiami Elimina (Booleano)
con |
ForceMerge(Int32, Booleano) | Proprio come Forza unione(Int32), tranne per il fatto che puoi specificare se la chiamata deve essere bloccata fino al completamento di tutta l'unione. Questo ha senso solo con a Lucene.Net.Index.IndexWriter.mergeScheduler che è in grado di eseguire unioni nei thread in background. NOTA: se questo metodo colpisce un |
ForzaUnisciElimina() | Forza l'unione di tutti i segmenti che hanno eliminato i documenti. Le effettive unioni da eseguire sono determinate dal MergePolicy. Ad esempio, l'impostazione predefinita TieredMergePolicy sceglierà un segmento solo se la percentuale di documenti eliminati è superiore al 10%. Questa è spesso un'operazione orribilmente costosa; raramente è garantito. Per vedere quante eliminazioni hai in sospeso nel tuo indice, chiama NumDocumentiEliminati. NOTA: questo metodo svuota prima un nuovo segmento (se sono presenti documenti indicizzati) e applica tutte le eliminazioni memorizzate nel buffer. NOTA: se questo metodo colpisce un |
ForceMergeDeletes(Booleano) | Proprio come ForzaUnisciElimina(), tranne per il fatto che puoi specificare se la chiamata deve essere bloccata fino al completamento dell'operazione. Questo ha senso solo con a Unisci pianificazione che è in grado di eseguire unioni nei thread in background. NOTA: se questo metodo colpisce un NOTA: se chiami Elimina (Booleano)
con |
GetReader(Booleano) | Esperto: restituisce un lettore di sola lettura, che copre tutte le modifiche apportate e non vincolate all'indice. questo 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(). Si noti che funzionalmente equivale a chiamare Flush() e quindi aprire un nuovo lettore. Ma i tempi di consegna di questo metodo dovrebbero essere più rapidi poiché evita il potenziale costoso Commettere(). Devi chiudere il Lettore di indici restituito da questo metodo una volta che hai finito di usarlo. 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. Il lettore risultante supporta DoOpenIfChanged(), ma quella chiamata verrà semplicemente inoltrata a questo metodo (sebbene ciò possa cambiare in futuro). 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 impostare MergedSegmentWarmer 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 |
Ha eliminazioni() | Reso |
Ha in sospeso unioni() | Esperto: restituisce true se ci sono unioni in attesa di essere pianificate. @lucene.sperimentale |
HaUncommittedChanges() | Reso |
È bloccato (directory) | Reso |
ForseUnisci() | Esperto: chiede il Lucene.Net.Index.IndexWriter.mergePolicy se sono necessarie unioni ora e, in tal caso, esegue le unioni richieste e quindi itera (prova di nuovo se sono necessarie unioni) finché non vengono restituite più unioni da parte Lucene.Net.Index.IndexWriter.mergePolicy. Chiamate esplicite a ForseUnisci() di solito non sono necessari. Il caso più comune è quando i parametri dei criteri di unione sono cambiati. questo metodo chiamerà il Lucene.Net.Index.IndexWriter.mergePolicy con ESPLICITO. NOTA: se questo metodo colpisce un |
Unisci(MergePolicy.OneMerge) | Unisce i segmenti indicati, sostituendoli nella pila con un singolo segmento. @lucene.sperimentale |
UnisciFinish(MergePolicy.OneMerge) | Esegue la finitura per un'unione, che è veloce ma mantiene attivo il blocco sincronizzato Indice scrittore esempio. |
AvantiUnisci() | Esperto: il Lucene.Net.Index.IndexWriter.mergeScheduler chiama questo metodo per recuperare la successiva unione richiesta dal MergePolicy @lucene.sperimentale |
NumDocumentiEliminati(SegmentCommitInfo) | Ottieni il numero di documenti eliminati per un lettore in pool. Se il lettore non viene raggruppato, viene restituito delCount di segmentInfo. |
NumRamDocs() | Esperto: restituisce il numero di documenti attualmente memorizzati nella RAM. |
PreparaCommit() | Esperto: preparati per l'impegno. Questo esegue la prima fase del commit a 2 fasi. questo metodo esegue tutti i passaggi necessari per eseguire il commit delle modifiche dall'apertura di questo writer: svuota i documenti aggiunti ed eliminati in attesa, sincronizza i file di indice, scrive la maggior parte del file segments_N successivo. Dopo aver chiamato questo è necessario chiamare uno dei due Commettere() per completare il commit, o Ripristina() per ripristinare il commit e annullare tutte le modifiche apportate dall'apertura dello scrittore. Puoi anche solo chiamare Commettere() direttamente senza PreparaCommit() prima nel qual caso quel metodo chiamerà internamente PreparaCommit(). NOTA: se questo metodo colpisce un |
Dimensione RamInByte() | Esperto: restituisce la dimensione totale di tutti i file di indice attualmente memorizzati nella cache. Utile per la gestione delle dimensioni con flushRamDocs() |
Ripristina() | Chiudi il Indice scrittore senza eseguire il commit delle modifiche che si sono verificate dall'ultimo commit (o da quando è stato aperto, se il commit non è stato chiamato). questo rimuove tutti i file temporanei che erano stati creati, dopodiché lo stato dell'indice sarà lo stesso di quando era Commettere() è stato chiamato l'ultima volta o quando questo scrittore è stato aperto per la prima volta. Questo cancella anche una precedente chiamata a PreparaCommit(). |
SegString() | Restituisce una descrizione stringa di tutti i segmenti, per il debug. @lucene.interna |
SegString(IEnumerable ) | Restituisce una descrizione stringa dei segmenti specificati, per il debug. @lucene.interna |
SegString(SegmentCommitInfo) | Restituisce una descrizione stringa del segmento specificato, per il debug. @lucene.interna |
SetCommitData(IDdizionario ) | Imposta la mappa dei dati dell'utente del commit. Tale metodo è considerato una transazione da Indice scrittore e sarà impegnato (Commettere() anche se non sono state apportate altre modifiche all'istanza dello scrittore. Nota che devi prima chiamare questo metodo PreparaCommit(), o altrimenti non sarà incluso nel follow-on Commettere(). NOTA: il dizionario viene clonato internamente, quindi la modifica del contenuto del dizionario dopo aver chiamato questo metodo non ha alcun effetto. |
ProvaDeleteDocument(IndexReader, Int32) | Esperto: tenta di eliminare per ID documento, purché fornito NOTA: questo metodo può eliminare solo i documenti visibili al lettore NRT attualmente aperto. Se è necessario eliminare i documenti indicizzati dopo aver aperto il lettore NRT è necessario utilizzare gli altri metodi DeleteDocument() (es. Elimina documenti (termine)). |
Sblocca (Directory) | Sblocca forzatamente l'indice nella directory denominata. Attenzione: questo dovrebbe essere utilizzato solo dal codice di ripristino dell'errore, quando è noto che nessun altro processo o thread sta attualmente accedendo a questo indice. |
UpdateBinaryDocValue(Termine, Stringa, BytesRef) | Aggiorna un documento BinaryDocValues per NOTA: questo metodo sostituisce attualmente il valore esistente di tutti i documenti interessati con il nuovo valore.
NOTA: se questo metodo colpisce un |
UpdateDocument(Term, IEnumerable ) | Aggiorna un documento eliminando prima i documenti che lo contengono NOTA: se questo metodo colpisce un |
UpdateDocument(Term, IEnumerable , Analizzatore) | Aggiorna un documento eliminando prima i documenti che lo contengono NOTA: se questo metodo colpisce un |
UpdateDocuments(Term, IEnumerable >) | Elimina atomicamente i documenti corrispondenti a quelli forniti
@lucene.sperimentale |
UpdateDocuments(Term, IEnumerable >, Analizzatore) | Elimina atomicamente i documenti corrispondenti a quelli forniti
@lucene.sperimentale |
UpdateNumericDocValue(Termine, Stringa, Nullable ) | Aggiorna un documento NumericDocValues per
NOTA: se questo metodo colpisce un |
WaitForMerges() | Attendi il completamento di tutte le unioni attualmente in sospeso. È garantito che tutte le unioni avviate prima di chiamare questo metodo saranno completate una volta completato questo metodo. |