Aktualisierung Lucene Index im laufenden Betrieb

Question

Ich bin ein absoluter Neuling in Lucene und bekam ein Problem beim Aktualisieren des Index.

Derzeit kann ich den gesamten Index täglich neu erstellen, aber der Index wird nur auf die Zeit der Erstellung aktualisiert, aber wie kann ich den Index aktualisieren, wie es anhängen, so dass es auf dem neuesten Stand ist? Derzeit gibt es Code, der versucht, den Index zu aktualisieren, aber er aktualisiert nur die Segmentdateien und keine anderen Dateien.

Jedes Mal, wenn ein Eintrag von meiner Website hinzugefügt wird, wird die RefreshFromDatabase-Methode ausgeführt und versucht, den neuesten Index hinzuzufügen. Im Suchindexordner werden jedoch die beiden Dateien segments.gen und segments_t, jedoch alle anderen Dateien aktualisiert Dateien (.fdt .fdx .fnm .frq .nrm .prx .tii .tis .del .cfs) werden nicht aktualisiert. Hier ist der Screenshot: folder screenshot

Code:

using (ISiteScope scope = _scopeFactory.GetSiteScope(site)){ 
     scope.Get<ISearchIndexUpdater>().RefreshFromDatabase(primaryId, secondaryId); 
     scope.Commit(); 
} 

public void RefreshFromDatabase(long primaryId, int? secondaryId){ 
    Process process = _processRepo.GetById(primaryId); 
    IList<Decision> allDecisions = _decisionRepo.GetByProcess(process); 
    IList<Link> allLinks = _linkRepo.GetActiveByProcess(process); 
    Decision current = allDecisions.OrderByDescending(x => x.DTG).FirstOrDefault(); 
    _luceneRepository.Add(process, allDecisions, allLinks); 
} 

public void Add(Process process, IList<Decision> decisions, IList<Link> links){ 
    if (null == decisions) 
    decisions = new List<Decision>(); 

    using (LuceneWriter writer = BeginWriter(false)) { 
     Add(writer.Writer, 
      new SearchIndexProcess { 
       // properties 
      }, 
      decisions.Select(x => new SearchIndexDecision { 
       // params 
      }).ToArray(), 
      (links ?? new List<Link>()).Select(x => new SearchIndexLink { 
       // properties 
      }).ToArray() 
     ); 
     writer.Commit(); 
    } 
} 

und LuceneWriter Klasse:

public class LuceneWriter : IDisposable 
     { 
       Directory _directory; 
       Analyzer _analyzer; 
       IndexWriter _indexWriter; 

       bool _commit; 
       bool _optimise; 

       /// <summary> 
       /// Constructor for LuceneWriter. 
       /// </summary> 
       /// <param name="fileSystem">An IFileSystem.</param> 
       /// <param name="luceneDir">The directory that contains the Lucene index. Need not exist.</param> 
       public LuceneWriter(IFileSystem fileSystem, string luceneDir) 
        : this(fileSystem, luceneDir, false) 
       { 
       } 

       /// <summary> 
       /// Constructor for LuceneWriter. 
       /// </summary> 
       /// <param name="fileSystem">An IFileSystem.</param> 
       /// <param name="luceneDir">The directory that contains the Lucene index. Need not exist.</param> 
       /// <param name="optimiseWhenDone">Optimse the index on Dispose(). This is an expensive operation.</param> 
       public LuceneWriter(IFileSystem fileSystem, string luceneDir, bool optimiseWhenDone) 
       { 
        Init(fileSystem, luceneDir, optimiseWhenDone); 
       } 

       //init has its own single use method for mocking reasons. 
       /// <summary> 
       /// Initialise the LuceneWriter. 
       /// </summary> 
       /// <param name="fileSystem">An IFileSystem.</param> 
       /// <param name="luceneDir">The directory containing the Lucene index.</param> 
       /// <param name="optimiseWhenDone">Whether or not to optimise the Lucene index upon Dispose().</param> 
       protected virtual void Init(IFileSystem fileSystem, string luceneDir, bool optimiseWhenDone) 
       { 
        _optimise = optimiseWhenDone; 

        bool exists = true; 
        if (!fileSystem.DirectoryExists(luceneDir)) { 
          fileSystem.CreateDirectory(luceneDir); 
          exists = false; 
        } 

        _directory = FSDirectory.Open(new DirectoryInfo(luceneDir)); 
        _analyzer = new StandardAnalyzer(Version.LUCENE_30); 
        _indexWriter = new IndexWriter(_directory, _analyzer, !exists, IndexWriter.MaxFieldLength.UNLIMITED); 
       } 

       /// <summary> 
       /// Flags writer to commit and optimise. Does not commit until Dispose() is called. 
       /// </summary> 
       public void Commit() 
       { 
        _commit = true; 
       } 

       /// <summary> 
       /// The IndexWriter. 
       /// </summary> 
       public IndexWriter Writer { get { return _indexWriter; } } 

       /// <summary> 
       /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. 
       /// </summary> 
       /// <filterpriority>2</filterpriority> 
       public void Dispose() 
       { 
        if ((null != _indexWriter) && (_commit)) { 
          if (_optimise) 
            _indexWriter.Optimize(true); 
          _indexWriter.Commit(); 
          _indexWriter.Close(true); 
        } 

        if (null != _indexWriter) 
          _indexWriter.Dispose(); 
        if (null != _analyzer) 
          _analyzer.Dispose(); 
        if (null != _directory) { 
          _directory.Close(); 
          _directory.Dispose(); 
        } 
       } 
     } 

Answer 1

In Lucene gibt es keine Update-Dokumente. Es ist tatsächlich löschen und hinzufügen. Wenn Sie Dokumente aktualisieren, wird es in älteren Segmenten als gelöscht markiert und ein neues Segment wird erstellt und das Dokument wird hinzugefügt