CLucene - a full-featured, c++ search engine
API Documentation

---

IndexWriter.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
* 
* Distributable under the terms of either the Apache License (Version 2.0) or 
* the GNU Lesser General Public License, as specified in the COPYING file.
------------------------------------------------------------------------------*/
#ifndef _lucene_index_IndexWriter_
#define _lucene_index_IndexWriter_

#if defined(_LUCENE_PRAGMA_ONCE)
# pragma once
#endif

#include "CLucene/analysis/AnalysisHeader.h"
#include "CLucene/util/VoidList.h"
#include "CLucene/search/Similarity.h"
#include "CLucene/store/Lock.h"
#include "CLucene/store/TransactionalRAMDirectory.h"

#include "SegmentHeader.h"

CL_NS_DEF(index)


class IndexWriter:LUCENE_BASE {
        class LockWith2:public CL_NS(store)::LuceneLockWith<void>{
        public:
                CL_NS(util)::CLVector<SegmentReader*>* segmentsToDelete;
                IndexWriter* writer;
                bool create;
                void doBody();
                LockWith2(CL_NS(store)::LuceneLock* lock, int64_t lockWaitTimeout,
                                IndexWriter* wr, 
                                CL_NS(util)::CLVector<SegmentReader*>* std,
                                bool create);
                ~LockWith2(){
                }
        };
        friend class LockWith2;

        class LockWithCFS:public CL_NS(store)::LuceneLockWith<void>{
        public:
                CL_NS(store)::Directory* directory;
                IndexWriter* writer;
                const char* segName;
                CL_NS(util)::AStringArrayWithDeletor* filesToDelete;
                void doBody();
                LockWithCFS(CL_NS(store)::LuceneLock* lock, int64_t lockWaitTimeout, 
                                CL_NS(store)::Directory* dir, 
                                IndexWriter* wr, 
                                const char* segName, 
                                CL_NS(util)::AStringArrayWithDeletor* ftd);
                ~LockWithCFS(){
                }
        };
    friend class IndexWriter::LockWithCFS;

        bool isOpen; //indicates if the writers is open - this way close can be called multiple times

        // how to analyze text
        CL_NS(analysis)::Analyzer* analyzer;

        CL_NS(search)::Similarity* similarity; // how to normalize

        bool useCompoundFile;
        bool closeDir;

        CL_NS(store)::TransactionalRAMDirectory* ramDirectory; // for temp segs

        CL_NS(store)::LuceneLock* writeLock;

        void _IndexWriter(const bool create);

        void _finalize();

        // where this index resides
        CL_NS(store)::Directory* directory;             
                
                
        int32_t getSegmentsCounter(){ return segmentInfos->counter; }
        int32_t maxFieldLength;
        int32_t mergeFactor;
        int32_t minMergeDocs;
        int32_t maxMergeDocs;
        int32_t termIndexInterval;

        int64_t writeLockTimeout;
        int64_t commitLockTimeout;
public:
        DEFINE_MUTEX(THIS_LOCK)
        
        // Release the write lock, if needed. 
        SegmentInfos* segmentInfos;
  
        // Release the write lock, if needed.
        ~IndexWriter();

        LUCENE_STATIC_CONSTANT(int32_t, DEFAULT_MAX_FIELD_LENGTH = 10000);
        LUCENE_STATIC_CONSTANT(int32_t, FIELD_TRUNC_POLICY__WARN = -1);
        int32_t getMaxFieldLength() const{ return maxFieldLength; }
        void setMaxFieldLength(int32_t val){ maxFieldLength = val; }

        LUCENE_STATIC_CONSTANT(int32_t, DEFAULT_MAX_BUFFERED_DOCS = 10);
        void setMaxBufferedDocs(int32_t val){ minMergeDocs = val; }
        int32_t getMaxBufferedDocs(){ return minMergeDocs; }
        
        LUCENE_STATIC_CONSTANT(int64_t, WRITE_LOCK_TIMEOUT = 1000);
        void setWriteLockTimeout(int64_t writeLockTimeout) { this->writeLockTimeout = writeLockTimeout; }
        int64_t getWriteLockTimeout() { return writeLockTimeout; }
        
        LUCENE_STATIC_CONSTANT(int64_t, COMMIT_LOCK_TIMEOUT = 10000);
        void setCommitLockTimeout(int64_t commitLockTimeout) { this->commitLockTimeout = commitLockTimeout; }
        int64_t getCommitLockTimeout() { return commitLockTimeout; }

        static const char* WRITE_LOCK_NAME; //"write.lock";
        static const char* COMMIT_LOCK_NAME; //"commit.lock";
        
        LUCENE_STATIC_CONSTANT(int32_t, DEFAULT_MERGE_FACTOR = 10);
        /* Determines how often segment indices are merged by addDocument().  With
        *  smaller values, less RAM is used while indexing, and searches on
        *  unoptimized indices are faster, but indexing speed is slower.  With larger
        *  values more RAM is used while indexing and searches on unoptimized indices
        *  are slower, but indexing is faster.  Thus larger values (> 10) are best
        *  for batched index creation, and smaller values (< 10) for indices that are
        *  interactively maintained.
        *
        * <p>This must never be less than 2.  The default value is 10.
        */
        int32_t getMergeFactor() const{ return mergeFactor; }
        void setMergeFactor(int32_t val){ mergeFactor = val; }

        
        LUCENE_STATIC_CONSTANT(int32_t, DEFAULT_TERM_INDEX_INTERVAL = 128);
        void setTermIndexInterval(int32_t interval) { termIndexInterval = interval; }
        int32_t getTermIndexInterval() { return termIndexInterval; }
  
        int32_t getMinMergeDocs() const{ return minMergeDocs; }
        void setMinMergeDocs(int32_t val){ minMergeDocs = val; }

        LUCENE_STATIC_CONSTANT(int32_t, DEFAULT_MAX_MERGE_DOCS = LUCENE_INT32_MAX_SHOULDBE);
        int32_t getMaxMergeDocs() const{ return maxMergeDocs; }
        void setMaxMergeDocs(int32_t val){ maxMergeDocs = val; }

        IndexWriter(const char* path, CL_NS(analysis)::Analyzer* a, const bool create, const bool closeDir=true);
        
        
        IndexWriter(CL_NS(store)::Directory* d, CL_NS(analysis)::Analyzer* a, const bool create, const bool closeDir=false);

        void close();

        int32_t docCount();


        void addDocument(CL_NS(document)::Document* doc, CL_NS(analysis)::Analyzer* analyzer=NULL);
  

        void optimize();


        void addIndexes(CL_NS(store)::Directory** dirs);
                
        void addIndexes(IndexReader** readers);


        CL_NS(store)::Directory* getDirectory() { return directory; }

        bool getUseCompoundFile() { return useCompoundFile; }

        void setUseCompoundFile(bool value) { useCompoundFile = value; }


        void setSimilarity(CL_NS(search)::Similarity* similarity) { this->similarity = similarity; }

        CL_NS(search)::Similarity* getSimilarity() { return this->similarity; }

        CL_NS(analysis)::Analyzer* getAnalyzer() { return analyzer; }

private:
        void flushRamSegments();

        void maybeMergeSegments();

        void mergeSegments(const uint32_t minSegment);
        
        void mergeSegments(const uint32_t minSegment, const uint32_t end);

        void deleteFiles(CL_NS(util)::AStringArrayWithDeletor& files);
        void readDeleteableFiles(CL_NS(util)::AStringArrayWithDeletor& files);
        void writeDeleteableFiles(CL_NS(util)::AStringArrayWithDeletor& files);
    
        /*
        * Some operating systems (e.g. Windows) don't permit a file to be deleted
        * while it is opened for read (e.g. by another process or thread). So we
        * assume that when a delete fails it is because the file is open in another
        * process, and queue the file for subsequent deletion.
        */
        void deleteSegments(CL_NS(util)::CLVector<SegmentReader*>* segments);
        void deleteFiles(CL_NS(util)::AStringArrayWithDeletor& files, CL_NS(store)::Directory* directory);
        void deleteFiles(CL_NS(util)::AStringArrayWithDeletor& files, CL_NS(util)::AStringArrayWithDeletor& deletable);


        // synchronized
        char* newSegmentName();
};

CL_NS_END
#endif

---

clucene.sourceforge.net