Lucene学习笔记(二)

import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.SimpleAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import junit.framework.TestCase;


public class BaseIndexTestCase extends TestCase 
{
    protected String[] keywords = {"1", "2"}; 
    protected String[] unindexed = {"Netherlands", "Italy"}; 
    protected String[] unstored = {"Amsterdam has lots of bridges", "Venice has lots of canals"}; 
    protected String[] text = {"Amsterdam", "Venice"}; 
    protected Directory dir; 
 
    protected void setUp() throws IOException { 
        String indexDir =  
            System.getProperty("java.io.tmpdir", "tmp")  + 
            System.getProperty("file.separator") + "index-dir"; 
        dir = FSDirectory.getDirectory(indexDir, true); 
        addDocuments(dir); 
    } 
 
    protected void addDocuments(Directory dir) 
        throws IOException { 
        IndexWriter writer = new IndexWriter(dir, getAnalyzer(), true); 
        writer.setUseCompoundFile(isCompound()); 
        for (int i = 0; i < keywords.length; i++) 
        { 
            Document doc = new Document(); 
            doc.add(new Field("id",keywords[i],Field.Store.YES,Field.Index.UN_TOKENIZED));
            doc.add(new Field("country",unindexed[i],Field.Store.YES,Field.Index.NO));
            doc.add(new Field("contents",unstored[i],Field.Store.NO,Field.Index.TOKENIZED));
            doc.add(new Field("city",text[i],Field.Store.YES,Field.Index.TOKENIZED));
            writer.addDocument(doc); 
        } 
        writer.optimize(); 
        writer.close(); 
    } 
 
    protected Analyzer getAnalyzer() 
    { 
        return new SimpleAnalyzer(); 
    } 
    protected boolean isCompound()
    { 
        return true; 
    } 
    
    public void testIndexWriter() throws IOException
    {
        IndexWriter writer = new IndexWriter(dir,this.getAnalyzer(),false);
        assertEquals(keywords.length,writer.docCount());
         writer.close();
    }
    
    public void testIndexReader() throws IOException 
    {
        IndexReader reader = IndexReader.open(dir);
        assertEquals(keywords.length, reader.maxDoc());
        assertEquals(keywords.length, reader.numDocs());
        reader.close();
    }
}

import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.WhitespaceAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;


public class DocumentDeleteTest extends BaseIndexTestCase 
{
      public void testDeleteBeforeIndexMerge() throws IOException 
      {
        assertEquals(1, getHitCount("city", "Amsterdam"));

        IndexReader reader = IndexReader.open(dir);
        assertEquals(2, reader.maxDoc());
        assertEquals(2, reader.numDocs());
        

        reader.deleteDocument(1);

        assertTrue(reader.isDeleted(1));
        assertTrue(reader.hasDeletions());
        assertEquals(2, reader.maxDoc());
        assertEquals(1, reader.numDocs());

        reader.close();

        reader = IndexReader.open(dir);

        assertEquals(2, reader.maxDoc());
        assertEquals(1, reader.numDocs());

        reader.close();
      }

      public void testDeleteAfterIndexMerge() throws IOException 
      {
        IndexReader reader = IndexReader.open(dir);
        assertEquals(2, reader.maxDoc());
        assertEquals(2, reader.numDocs());
        reader.deleteDocument(1);
        reader.close();

        IndexWriter writer = new IndexWriter(dir, getAnalyzer(),false);
        writer.optimize();
        writer.close();

        reader = IndexReader.open(dir);

        assertFalse(reader.isDeleted(1));
        assertFalse(reader.hasDeletions());
        assertEquals(1, reader.maxDoc());
        assertEquals(1, reader.numDocs());

        reader.close();
      }
      

      private int getHitCount(String fieldName, String searchString)
        throws IOException {
        IndexSearcher searcher = new IndexSearcher(dir);
        Term t = new Term(fieldName, searchString);
        Query query = new TermQuery(t);
        Hits hits = searcher.search(query);
        int hitCount = hits.length();
        searcher.close();
        return hitCount;
      }
      

      protected Analyzer getAnalyzer() {
        return new WhitespaceAnalyzer();
      }



}

import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.WhitespaceAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;


public class DocumentUpdateTest extends BaseIndexTestCase 
{

      public void testUpdate() throws IOException 
      {
        assertEquals(1, getHitCount("city", "Amsterdam"));
        IndexReader reader = IndexReader.open(dir);
        reader.deleteDocuments(new Term("city", "Amsterdam"));
        reader.close();

        IndexWriter writer = new IndexWriter(dir, getAnalyzer(),
          false);
        Document doc = new Document();
          doc.add(new Field("id","1",Field.Store.YES,Field.Index.UN_TOKENIZED));
          doc.add(new Field("country","Russia",Field.Store.YES,Field.Index.NO));
          doc.add(new Field("contents","St. Petersburg has lots of bridges",Field.Store.NO,Field.Index.TOKENIZED));
          doc.add(new Field("city","St. Petersburg",Field.Store.YES,Field.Index.TOKENIZED));

        writer.addDocument(doc);
        writer.optimize();
        writer.close();

        assertEquals(0, getHitCount("city", "Amsterdam"));
        assertEquals(1, getHitCount("city", "Petersburg"));
      }

      protected Analyzer getAnalyzer() {
        return new WhitespaceAnalyzer();
      }

      private int getHitCount(String fieldName, String searchString)
        throws IOException {
        IndexSearcher searcher = new IndexSearcher(dir);
        Term t = new Term(fieldName, searchString);
        Query query = new TermQuery(t);
        Hits hits = searcher.search(query);
        int hitCount = hits.length();
        searcher.close();
        return hitCount;
      }

}

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.SimpleAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;


public class IndexTuningDemo 
{
     public static void main(String[] args) throws Exception {
            int docsInIndex  = Integer.parseInt(args[0]);

            // create an index called 'index-dir' in a temp directory
            Directory dir = FSDirectory.getDirectory(
            System.getProperty("java.io.tmpdir", "tmp") +
            System.getProperty("file.separator") + "index-dir", true);
            Analyzer analyzer = new SimpleAnalyzer();
            IndexWriter writer = new IndexWriter(dir, analyzer, true);

            // set variables that affect speed of indexing
            writer.setMergeFactor(Integer.parseInt(args[1]));
            writer.setMaxMergeDocs(Integer.parseInt(args[2]));
            writer.setInfoStream(System.out);
            writer.setMaxBufferedDocs(Integer.parseInt(args[3]));

            System.out.println("Merge factor:   " + writer.getMergeFactor());
            System.out.println("Max merge docs: " + writer.getMaxMergeDocs());
            System.out.println("Min merge docs: " + writer.getMaxBufferedDocs());

            long start = System.currentTimeMillis();
            for (int i = 0; i < docsInIndex; i++) {
              Document doc = new Document();
              doc.add(new Field("fieldname", "Bibamus", Field.Store.YES,Field.Index.TOKENIZED));
              writer.addDocument(doc);
            }
            writer.close();
            long stop = System.currentTimeMillis();
            System.out.println("Time: " + (stop - start) + " ms");
          }

}

import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.analysis.SimpleAnalyzer;

import junit.framework.TestCase;
import java.io.IOException;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;

public class FSversusRAMDirectoryTest extends TestCase 
{
  private Directory fsDir;
  private Directory ramDir;
  private Collection docs = loadDocuments(3000, 5);//加载数据

  protected void setUp() throws Exception 
  {
    String fsIndexDir = System.getProperty("java.io.tmpdir", "tmp") + System.getProperty("file.separator") + "fs-index";
    ramDir = new RAMDirectory();//内存中目录
    fsDir = FSDirectory.getDirectory(fsIndexDir, true);
  }

  public void testTiming() throws IOException 
  {
    long ramTiming = timeIndexWriter(ramDir);
    long fsTiming = timeIndexWriter(fsDir);

    assertTrue(fsTiming > ramTiming);
    

    System.out.println("RAMDirectory Time: " + (ramTiming) + " ms");
    System.out.println("FSDirectory Time : " + (fsTiming) + " ms");
  }

  private long timeIndexWriter(Directory dir) throws IOException 
  {
    long start = System.currentTimeMillis();
    addDocuments(dir);
    long stop = System.currentTimeMillis();
    return (stop - start);
  }

  private void addDocuments(Directory dir) throws IOException 
  {
    IndexWriter writer = new IndexWriter(dir, new SimpleAnalyzer(),true);

    /**
    // change to adjust performance of indexing with FSDirectory
    writer.mergeFactor = writer.mergeFactor;
    writer.maxMergeDocs = writer.maxMergeDocs;
    writer.minMergeDocs = writer.minMergeDocs;
    */

    for (Iterator iter = docs.iterator(); iter.hasNext();) 
    {
      Document doc = new Document();
      String word = (String) iter.next();
      doc.add(new Field("keyword",word,Field.Store.YES,Field.Index.UN_TOKENIZED));
      doc.add(new Field("unindexed",word,Field.Store.YES,Field.Index.NO));
      doc.add(new Field("unstored",word,Field.Store.NO,Field.Index.TOKENIZED));
      doc.add(new Field("text",word,Field.Store.YES,Field.Index.TOKENIZED));
      writer.addDocument(doc);
    }
    writer.optimize();
    writer.close();
  }

  private Collection loadDocuments(int numDocs, int wordsPerDoc) 
  {
    Collection docs = new ArrayList(numDocs);
    for (int i = 0; i < numDocs; i++) 
    {
      StringBuffer doc = new StringBuffer(wordsPerDoc);
      for (int j = 0; j < wordsPerDoc; j++) 
      {
        doc.append("Bibamus ");
      }
      docs.add(doc.toString());
    }
    return docs;
  }
}