看看最后一种docValue，sortedSet，他有点难，如果不是之前看了四种其他的格式的话，不是很容易理解，同理，如果看懂了其他的格式，则很容易理解。先说一下SortedSet吧，它是存储的byte[]，一个doc是可以有多个值的，在存储的时候，是排序的，即在索引中是可以查找到每个doc的byte[]的排序的。他的存储是综合了sortedDocValue（存储排序的单值byte[]）和SortedNumericDocValue，在存储的时候对于所有的byte[]是要先获得对应的排序，如果我们把顺序的地方和具体的byte[]值分开的话，单独存放所有的byte[]就可以使用和SortedDocValues同样的格式，如果存储好了所有的byte[]，那么每个doc就可以根据自己的byte[]的排序就可以获得其自己的byte[]了，也就是只需要保存一些数字就可以了，就可以使用SortedNumericDocValue的格式了。
看看再内存中的保存，使用的是SortedSetDocValuesWriter ：
class SortedSetDocValuesWriter extends DocValuesWriter {
/**用来存储所有的byte[]，并定义其id*/
final BytesRefHash hash;
/** 记录termid，所有的doc的都记录，不过在每个doc记录的时候，是按照termId排序的，但是对于不同的doc是不排序的 */
private PackedLongValues.Builder pending; // stream of all termIDs
/** 每个doc含有的byte[]的个数的，重复的计算一个 */
private PackedLongValues.Builder pendingCounts; // termIDs per doc
private final Counter iwBytesUsed;
private long bytesUsed; // this only tracks differences in 'pending' and 'pendingCounts'
private final FieldInfo fieldInfo;
/** 当前处理的doc的id，用于区别是不是同一个doc*/
private int currentDoc;
/** 当前的doc处的所有的byte[] */
private int currentValues[] = new int[8];
/**当前的doc含有的byte[]在currentValues中的指针*/
private int currentUpto = 0;
/**所有的doc中含有的byte[]的个数的最大值 */
private int maxCount = 0;
public SortedSetDocValuesWriter(FieldInfo fieldInfo, Counter iwBytesUsed) {
this.fieldInfo = fieldInfo;
this.iwBytesUsed = iwBytesUsed;
hash = new BytesRefHash(new ByteBlockPool(new ByteBlockPool.DirectTrackingAllocator(iwBytesUsed)),BytesRefHash.DEFAULT_CAPACITY, new DirectBytesStartArray(BytesRefHash.DEFAULT_CAPACITY, iwBytesUsed));
pending = PackedLongValues.packedBuilder(PackedInts.COMPACT);
pendingCounts = PackedLongValues.deltaPackedBuilder(PackedInts.COMPACT);
bytesUsed = pending.ramBytesUsed() + pendingCounts.ramBytesUsed();
iwBytesUsed.addAndGet(bytesUsed);
}
public void addValue(int docID, BytesRef value) {
//检查的条件，略过
if (docID != currentDoc) {//结束这个doc
finishCurrentDoc();
}
// Fill in any holes:
while (currentDoc < docID) {
pendingCounts.add(0); //没有值的doc含有的byte[]的个数是0
currentDoc++;
}
addOneValue(value);//添加一个值
updateBytesUsed();//更新使用的内存
}
//结束一个doc
private void finishCurrentDoc() {
Arrays.sort(currentValues, 0, currentUpto);//将当前的doc的所有的值进行排序
int lastValue = -1;
int count = 0;
for (int i = 0; i < currentUpto; i++) {
int termID = currentValues[i];
// if its not a duplicate
if (termID != lastValue) {//重复的只记录一个
pending.add(termID); // record the term id
count++;
}
lastValue = termID;
}
// record the number of unique term ids for this doc
pendingCounts.add(count);//添加这个doc的byte[]的个数
maxCount = Math.max(maxCount, count);
currentUpto = 0;
currentDoc++;
}
//
private void addOneValue(BytesRef value) {
int termID = hash.add(value);//添加到hash表里面，如果返回的值是小于0的表示已经存在了，否则第一次出现。
if (termID < 0) {
termID = -termID - 1;
} else {
iwBytesUsed.addAndGet(2 * RamUsageEstimator.NUM_BYTES_INT);
}
if (currentUpto == currentValues.length) {
currentValues = ArrayUtil.grow(currentValues, currentValues.length + 1);
// reserve additional space for max # values per-doc
// when flushing, we need an int[] to sort the mapped-ords within
// the doc
iwBytesUsed.addAndGet((currentValues.length - currentUpto) * 2 * RamUsageEstimator.NUM_BYTES_INT);
}
currentValues[currentUpto] = termID;//添加到临时的数组里面去。
currentUpto++;
}
可以看到，他的处理逻辑和SortedNumericDocValue是差不多的，允许一个doc添加多个byte[]。在内存中保存的时候，是保存了一个doc的多个byte[]以及一个doc的byte[]的个数。再结束一个doc的多个byte[]的时候，是先进行了排序。
再看看如何写入到directory中去，先调用flush方法：
public void flush(SegmentWriteState state, DocValuesConsumer dvConsumer) throws IOException {
final int maxDoc = state.segmentInfo.getDocCount();
final int maxCountPerDoc = maxCount;
assert pendingCounts.size() == maxDoc;
final int valueCount = hash.size();//所有的byte[]的个数，
final PackedLongValues ords = pending.build();//所有的doc含有的所有的byte[]的id
final PackedLongValues ordCounts = pendingCounts.build();//每个doc含有的byte[]的个数
// 将所有的byte[]排序，并整理hash表，移动到数组里面去。
final int[] sortedValues = hash.sort(BytesRef.getUTF8SortedAsUnicodeComparator());
final int[] ordMap = new int[valueCount];//下标是term id，值是排序。可以快速的得到某个id的term的排序
for (int ord = 0; ord < valueCount; ord++) {
ordMap[sortedValues[ord]] = ord;
}
dvConsumer.addSortedSetField(fieldInfo,
// ord -> value
new Iterable<BytesRef>() {//返回所有的byte[],已经排好顺序了。
public Iterator<BytesRef> iterator() {
return new ValuesIterator(sortedValues, valueCount, hash);
}
},
// doc -> ordCount。每个doc含有的byte[]的个数
new Iterable<Number>() {
public Iterator<Number> iterator() {
return new OrdCountIterator(maxDoc, ordCounts);
}
},
//用于返回所有的doc的byte[]的排序
new Iterable<Number>() {
public Iterator<Number> iterator() {
return new OrdsIterator(ordMap, maxCountPerDoc, ords, ordCounts);
}
});
}
通过上面可以看出，在flush的过程中，是向最终的Consumer传递了三个参数，第一个是用于形成所有的词典表的，即所有的byte[]，第二个是每个doc含有的byte[]的个数，第三个是每个doc的所有的byte[] 的排序。有了这三个iterable，我们看一下具体的flush过程吧：方法是Lucene410DocValuesConsumer.addSortedSetField(FieldInfo, Iterable<BytesRef>, Iterable<Number>, Iterable<Number>)：
/**
* @param values：按照顺序返回的byte[]
* @param docToOrdCount：每个doc含有的顺序（也就是byte[]）的个数
* @param ords：所有的doc的byte[]的排序
*/
public void addSortedSetField(FieldInfo field, Iterable<BytesRef> values, final Iterable<Number> docToOrdCount, final Iterable<Number> ords) throws IOException {
meta.writeVInt(field.number);//
meta.writeByte(Lucene410DocValuesFormat.SORTED_SET);
if (isSingleValued(docToOrdCount)) {//如果全部的doc都只有一个byte[]，则和SortedDocValue是一样的，忽略这种情况
meta.writeVInt(SORTED_SINGLE_VALUED);
// The field is single-valued, we can encode it as SORTED
addSortedField(field, values, singletonView(docToOrdCount, ords, -1L));
} else {
meta.writeVInt(SORTED_WITH_ADDRESSES);
// write the ord -> byte[] as a binary field。
addTermsDict(field, values);//添加词典表，也就是记录所有的byte[]，这个方法在sortedDocValue中也使用到了，也就是存储格式和SortedDocValue是一个存储格式（可以回顾一下SortedDocValue的存储格式，地址是：http://suichangkele.iteye.com/blog/2410752）。使用这个格式的好处是可以快速的根据排序的到对应的byte[]
// 写入一个doc含有的所有的byte[]的排序，也就是一个doc对应的多个数字，这个和sortedDocValue的也是一样的。
addNumericField(field, ords, false);
// write the doc -> ord count as a absolute index to the stream
addAddresses(field, docToOrdCount);//写入一个doc的第一个排序在所有的排序中的开始位置， 这个和SortedNumericDocValue是一样的。
}
}
正如我在文章开头说的，如果之前看懂了其他四个docValue的存储格式，看这个很简单。上面的addSortedSetField方法，如果把addAddress方法去掉的话，就是和SortedDocValue一样，不同的地方是，对于SortedSetDocValue是多个值的，所以要记录每个doc含有的byte[]的个数，所以要加入第三个方法。如果把addTermsDict方法去掉，就是和SortedNumericDocValue一样了，理解思路是：SortedNumericDocValue也是多个值的，即一个doc含有多个数字，在SortedSetDocValue中也需要使用SortedNumericDocValue，只不过是作为一个doc的多个byte[]的排序，还需要存储具体的byte[]，所以要加上第一个部分addTermsDict。有了这三个方法，就可以大致的知道查找的思路了，在查找某个doc的byte[]的时候，先从addressses中查找他的第一个byte[]的排序是多少，一共多少个byte[]，这样在从numericField中查找具体的排序，再从termDict中根据排序找到对应的byte[]。下一篇博客中看一下对应的方法吧。