Java Store.YES属性代码示例

public static Document newsToDocument(NewsDetailModel news){
	Document document = new Document();
	
	StringField idField = new StringField("id",news.getId(),Store.YES);
	StringField urlField = new StringField("url",news.getUrl(),Store.YES);
	StringField titleField = new StringField("title",news.getTitle(),Store.YES);
	StringField contentField = new StringField("content",news.getContent(),Store.YES);
	StringField timeField = new StringField("time",news.getTime(),Store.YES);
	
	document.add(idField);
	document.add(urlField);
	document.add(titleField);
	document.add(contentField);
	document.add(timeField);

	return document;
}
 

public void index(Item item) throws IOException {
	String id = item.getId();
   	String text = item.getText();
   	
   	long publicationTIme = item.getPublicationTime();
   	
   	Document document = new Document();
	
	Field idField = new StringField("id", id, Store.YES);
   	document.add(idField);
	
	FieldType fieldType = new FieldType();
	fieldType.setStored(true);
	fieldType.setIndexed(true);
	fieldType.setStoreTermVectors(true);
	document.add(new Field("text", text, fieldType));
	
	document.add(new LongField("publicationTIme", publicationTIme, LongField.TYPE_STORED));
	if(iwriter != null) {
		iwriter.addDocument(document);
	}
}
 

private static void addTweetToIndex(Tweet headline, IndexWriter writer) throws IOException {
	
	Document doc = new Document();
	Field timestamp = new LongField(FieldNames.TIMESTAMP.name(), headline.getTimestamp().getTime(), Field.Store.YES);
	Field tweetID = new LongField(FieldNames.TWEETID.name(), headline.getTweetID(), Field.Store.NO);
	Field userName = new StringField(FieldNames.USERNAME.name(), headline.getUserName(), Store.YES);
	Field userID = new LongField(FieldNames.USERID.name(), headline.getUserID(), Field.Store.NO);
	Field tweet = new TextField(FieldNames.TEXT.name(), headline.getText(), Field.Store.YES);

	doc.add(tweet);
	doc.add(tweetID);
	doc.add(userName);
	doc.add(userID);
	doc.add(timestamp);
	
	writer.addDocument(doc);
}
 

/**
 * Adds the given {@link IIndexElement} to the index.
 * It builds the {@link Document} with its {@link Field}s and writes it to {@link Index}.
 * @param element the {@link IIndexElement} to add.
 * @throws IOException if an error occurred in the index.
 */
@SuppressWarnings("unchecked")
private void add(final IIndexElement element) throws IOException {
	final IIndexTypeConf conf = indexData.getConf();

	final Document doc = new Document();

	// add id field
	final StringField idField = new StringField(IIndexElement.FIELD_ID, element.getId(), Store.YES);
	doc.add(idField);

	// add index type field
	final StringField indexTypeField = new StringField(IIndexElement.FIELD_INDEX_TYPE, conf.getName(), Store.YES);
	doc.add(indexTypeField);

	final Locale locale = element.getLocale();
	if(element.getLocale() != null) {
		doc.add(new StringField(IIndexElement.FIELD_LOCALE, locale.getLanguage(), Store.YES));
	}

	for (@SuppressWarnings("rawtypes") final IIndexFieldConf fieldConf : conf.getFields()) {
		Object fieldContent = element.getContent(fieldConf.getName());

		if(fieldContent != null) {
			if(!(fieldContent instanceof Collection<?>)) {
				fieldContent = Arrays.asList(fieldContent);
			}

			for (final Object content : (Collection<?>) fieldContent) {
				doc.add(fieldConf.buildField(content));
			}
		}
	}

	index.addDocument(doc, locale);
}
 

private Document getDocument(File file) throws IOException {
	Document document = new Document();
	Field contentsField = new TextField(LuceneConstants.CONTENTS, new String(Files.readAllBytes(file.toPath())), Store.YES);
	Field fileNameField = new Field(LuceneConstants.FILE_NAME, file.getName(), TextField.TYPE_STORED);
	Field filePathField = new Field(LuceneConstants.FILE_PATH, file.getCanonicalPath(), TextField.TYPE_STORED);
	document.add(contentsField);
	document.add(fileNameField);
	document.add(filePathField);
	return document;
}
 

/**
 * Adds an string field, which may be analyzer or not
 */
public DocumentBuilder add(final String name, final String value, final boolean analyzed) {
    if (StringUtils.isNotEmpty(value)) {
        final Field field = new Field(name, value, Store.YES, analyzed ? Index.ANALYZED : Index.NOT_ANALYZED);
        document.add(field);
    }
    return this;
}
 

protected void getKeyBytes(Row row) {
    
    byte[] bytes = row.hKey().hKeyBytes();
    keyEncodedString = encodeBytes(bytes, 0, bytes.length);
    Field field = new StringField(IndexedField.KEY_FIELD, keyEncodedString, Store.YES);
    currentDocument.add(field);
}
 

/**
 * save index as text file
 * @param bw buffered writer
 * @param dumper write strategy
 * @throws IOException IOException
 */
public void save(BufferedWriter bw, WriteDocumentStrategy dumper) throws IOException {
	IndexSearcher searcher = manager.acquire();
	IndexReader reader = searcher.getIndexReader();
	int maxDoc = reader.maxDoc();

	int docId = 0;
	List<String> storedFields = new ArrayList<String>(fieldNames.length);
	for(int i=0;i<fieldNames.length;i++) {
		if (stores[i] == Store.YES) {
			storedFields.add(fieldNames[i]);
		}
	}
	if (hasHeader) {
		bw.write(dumper.writeDocument(storedFields.toArray(new String[0])));
		bw.newLine();
	}
	String[] fields = new String[storedFields.size()];
	while(docId<maxDoc) {
		Document doc = reader.document(docId);
		for(int i=0,size=storedFields.size();i<size;i++) {
			fields[i] = doc.get(storedFields.get(i));
		}
		bw.write(dumper.writeDocument(fields));
		bw.newLine();
	}
	bw.close();
}
 

@Override
public Store[] createStores(int fieldsLength) {
	Store[] stores = new Store[fieldsLength];
	for(int i=0;i<fieldsLength;i++) {
		stores[i] = Store.YES;
	}
	return stores;
}
 

/** {@inheritDoc} */
@Override
@SuppressWarnings("unchecked")
public void addFields(Document document, DecoratedKey partitionKey) {
    ByteBuffer bb = factory.toByteArray(partitionKey.getToken());
    String serialized = ByteBufferUtils.toString(bb);
    Field field = new StringField(FIELD_NAME, serialized, Store.YES);
    document.add(field);
}
 

public static void main(String args[]) throws ParseException, IOException{
	MemoryIndex index = new MemoryIndex();
	Analyzer analyzer = new StandardAnalyzer();
	StringField field3 = new StringField(AUTHOR, FULL_NAME, Store.YES);
	index.addField(field3, analyzer);
	
	Query query = new TermQuery(new Term(AUTHOR,FULL_NAME));
	search(index,query);
	
	query = new TermQuery(new Term(AUTHOR,FIRST_NAME));
	search(index,query);
	
	query = new TermQuery(new Term(AUTHOR,LAST_NAME));
	search(index,query);	
}
 

/**
 * Returns true if the field is storeable.
 */
protected Store isStored() {
	return store ? Store.YES : Store.NO;
}
 

public void testLongFieldCache() throws IOException {
  Directory dir = newDirectory();
  IndexWriterConfig cfg = newIndexWriterConfig(new MockAnalyzer(random()));
  cfg.setMergePolicy(newLogMergePolicy());
  RandomIndexWriter iw = new RandomIndexWriter(random(), dir, cfg);
  Document doc = new Document();
  LongField field = new LongField("f", 0L, Store.YES);
  doc.add(field);
  final long[] values = new long[TestUtil.nextInt(random(), 1, 10)];
  for (int i = 0; i < values.length; ++i) {
    final long v;
    switch (random().nextInt(10)) {
      case 0:
        v = Long.MIN_VALUE;
        break;
      case 1:
        v = 0;
        break;
      case 2:
        v = Long.MAX_VALUE;
        break;
      default:
        v = TestUtil.nextLong(random(), -10, 10);
        break;
    }
    values[i] = v;
    if (v == 0 && random().nextBoolean()) {
      // missing
      iw.addDocument(new Document());
    } else {
      field.setLongValue(v);
      iw.addDocument(doc);
    }
  }
  iw.forceMerge(1);
  final DirectoryReader reader = iw.getReader();
  final FieldCache.Longs longs = FieldCache.DEFAULT.getLongs(getOnlySegmentReader(reader), "f", false);
  for (int i = 0; i < values.length; ++i) {
    assertEquals(values[i], longs.get(i));
  }
  reader.close();
  iw.close();
  dir.close();
}
 

public void testIntFieldCache() throws IOException {
  Directory dir = newDirectory();
  IndexWriterConfig cfg = newIndexWriterConfig(new MockAnalyzer(random()));
  cfg.setMergePolicy(newLogMergePolicy());
  RandomIndexWriter iw = new RandomIndexWriter(random(), dir, cfg);
  Document doc = new Document();
  IntField field = new IntField("f", 0, Store.YES);
  doc.add(field);
  final int[] values = new int[TestUtil.nextInt(random(), 1, 10)];
  for (int i = 0; i < values.length; ++i) {
    final int v;
    switch (random().nextInt(10)) {
      case 0:
        v = Integer.MIN_VALUE;
        break;
      case 1:
        v = 0;
        break;
      case 2:
        v = Integer.MAX_VALUE;
        break;
      default:
        v = TestUtil.nextInt(random(), -10, 10);
        break;
    }
    values[i] = v;
    if (v == 0 && random().nextBoolean()) {
      // missing
      iw.addDocument(new Document());
    } else {
      field.setIntValue(v);
      iw.addDocument(doc);
    }
  }
  iw.forceMerge(1);
  final DirectoryReader reader = iw.getReader();
  final FieldCache.Ints ints = FieldCache.DEFAULT.getInts(getOnlySegmentReader(reader), "f", false);
  for (int i = 0; i < values.length; ++i) {
    assertEquals(values[i], ints.get(i));
  }
  reader.close();
  iw.close();
  dir.close();
}
 

/**
 * @param field
 * @return
 */
public Store getFieldStore(SchemaField field)
{
    if (storeAll)
    {
        return Store.YES;
    }

    PropertyDefinition propertyDefinition = getPropertyDefinition(field.getName());
    if (propertyDefinition != null)
    {
        return propertyDefinition.isStoredInIndex() ? Store.YES : Store.NO;
    }

    NonDictionaryField nonDDField = nonDictionaryFields.get(field.getName());
    if (nonDDField != null)
    {
        return nonDDField.store;
    }

    for (String additionalContentFieldEnding : additionalContentFields.keySet())
    {
        if (field.getName().endsWith(additionalContentFieldEnding)
                && (getPropertyDefinition(field.getName().substring(0, (field.getName().length() - additionalContentFieldEnding.length()))) != null))
        {
            return additionalContentFields.get(additionalContentFieldEnding).store;
        }
    }

    for (String additionalTextFieldEnding : additionalTextFields.keySet())
    {
        if (field.getName().endsWith(additionalTextFieldEnding)
                && (getPropertyDefinition(field.getName().substring(0, (field.getName().length() - additionalTextFieldEnding.length()))) != null))
        {
            return additionalTextFields.get(additionalTextFieldEnding).store;
        }
    }

    for (String additionalMlTextFieldEnding : additionalMlTextFields.keySet())
    {
        if (field.getName().endsWith(additionalMlTextFieldEnding)
                && (getPropertyDefinition(field.getName().substring(0, (field.getName().length() - additionalMlTextFieldEnding.length()))) != null))
        {
            return additionalMlTextFields.get(additionalMlTextFieldEnding).store;
        }
    }

    return Store.NO;
}