org.elasticsearch.index.fielddata.SortedBinaryDocValues Java Examples

@Override
public LeafBucketCollector getLeafCollector(LeafReaderContext ctx,
        final LeafBucketCollector sub) throws IOException {
    if (valuesSource == null) {
        return LeafBucketCollector.NO_OP_COLLECTOR;
    }
    final BigArrays bigArrays = context.bigArrays();
    final SortedBinaryDocValues values = valuesSource.bytesValues(ctx);
    return new LeafBucketCollectorBase(sub, values) {

        @Override
        public void collect(int doc, long bucket) throws IOException {
            counts = bigArrays.grow(counts, bucket + 1);
            values.setDocument(doc);
            counts.increment(bucket, values.count());
        }

    };
}
 

@Override
public DocIdSet getDocIdSet(LeafReaderContext context) throws IOException {
  final NumericTermsSet termsSet = this.getTermsSet();

  // make sure there are terms to filter on
  if (termsSet == null || termsSet.isEmpty()) return null;

  final SortedBinaryDocValues values = fieldData.load(context).getBytesValues(); // load fielddata
  return new DocValuesDocIdSet(context.reader().maxDoc(), context.reader().getLiveDocs()) {
    @Override
    protected boolean matchDoc(int doc) {
      values.setDocument(doc);
      final int numVals = values.count();
      for (int i = 0; i < numVals; i++) {
        final BytesRef term = values.valueAt(i);
        long termHash = LongBloomFilter.hash3_x64_128(term.bytes, term.offset, term.length, 0);
        if (termsSet.contains(termHash)) {
          return true;
        }
      }

      return false;
    }
  };
}
 

private HierarchyValues(SortedBinaryDocValues valuesSource, BytesRef separator, int minDepth, int maxDepth,
                        boolean keepBlankPath) {
    this.valuesSource = valuesSource;
    this.separator = separator;
    this.minDepth = minDepth;
    this.maxDepth = maxDepth;
    this.keepBlankPath = keepBlankPath;
}
 

@Override
public Bits docsWithValue(LeafReaderContext context) throws IOException {
    final SortedBinaryDocValues bytes = bytesValues(context);
    if (org.elasticsearch.index.fielddata.FieldData.unwrapSingleton(bytes) != null) {
        return org.elasticsearch.index.fielddata.FieldData.unwrapSingletonBits(bytes);
    } else {
        return org.elasticsearch.index.fielddata.FieldData.docsWithValue(bytes, context.reader().maxDoc());
    }
}
 

@Override
public SortedBinaryDocValues getBytesValues() {
    try {
        final BinaryDocValues values = DocValues.getBinary(reader, field);
        final Bits docsWithField = DocValues.getDocsWithField(reader, field);
        return FieldData.singleton(values, docsWithField);
    } catch (IOException e) {
        throw new IllegalStateException("Cannot load doc values", e);
    }
}
 

@Override
public final SortedBinaryDocValues getBytesValues() {
    return new SortedBinaryDocValues() {

        private final BytesRef[] terms = new BytesRef[2];
        private int count;

        @Override
        public void setDocument(int docId) {
            count = 0;
            for (String type : types()) {
                final SortedDocValues values = getOrdinalsValues(type);
                final int ord = values.getOrd(docId);
                if (ord >= 0) {
                    terms[count++] = values.lookupOrd(ord);
                }
            }
            assert count <= 2 : "A single doc can potentially be both parent and child, so the maximum allowed values is 2";
            if (count > 1) {
                int cmp = terms[0].compareTo(terms[1]);
                if (cmp > 0) {
                    ArrayUtil.swap(terms, 0, 1);
                } else if (cmp == 0) {
                    // If the id is the same between types the only omit one. For example: a doc has parent#1 in _uid field and has grand_parent#1 in _parent field.
                    count = 1;
                }
            }
        }

        @Override
        public int count() {
            return count;
        }

        @Override
        public BytesRef valueAt(int index) {
            return terms[index];
        }
    };
}
 

public BytesValues(SortedBinaryDocValues bytesValues, LeafSearchScript script) {
    this.bytesValues = bytesValues;
    this.script = script;
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) throws IOException {
    return new HierarchyValues(values.bytesValues(context), separator, minDepth, maxDepth, twoSepAsOne);
}
 

@Override
public final SortedBinaryDocValues getBytesValues() {
    return FieldData.toString(getOrdinalsValues());
}
 

@Override
public final SortedBinaryDocValues getBytesValues() {
    return FieldData.toString(getGeoPointValues());
}
 

@Override
public final SortedBinaryDocValues getBytesValues() {
    return FieldData.toString(getLongValues());
}
 

@Override
public final SortedBinaryDocValues getBytesValues() {
    return FieldData.toString(getDoubleValues());
}
 

protected SortedBinaryDocValues getValues(LeafReaderContext context) throws IOException {
    return indexFieldData.load(context).getBytesValues();
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext ctx) {
    throw new UnsupportedOperationException();
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext ctx) {
    throw new UnsupportedOperationException();
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) {
    return indexFieldData.load(context).getBytesValues();
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) throws IOException {
    return org.elasticsearch.index.fielddata.FieldData.emptySortedBinary(context.reader().maxDoc());
}
 

/**
 * Return a {@link MurmurHash3Values} instance that computes hashes on the fly for each binary value.
 */
public static MurmurHash3Values hash(SortedBinaryDocValues values) {
    return new Bytes(values);
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) throws IOException {
    return new BytesValues(delegate.bytesValues(context), script.getLeafSearchScript(context));
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) throws IOException {
    return new ScriptBytesValues(script.getLeafSearchScript(context));
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) {
    return indexFieldData.load(context).getBytesValues();
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) throws IOException {
    return new ValuesSource.WithScript.BytesValues(delegate.bytesValues(context), script.getLeafSearchScript(context));
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) throws IOException {
    return org.elasticsearch.index.fielddata.FieldData.emptySortedBinary(context.reader().maxDoc());
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) throws IOException {
    return new ScriptBytesValues(script.getLeafSearchScript(context));
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) {
    return indexFieldData.load(context).getBytesValues();
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) {
    final AtomicParentChildFieldData atomicFieldData = indexFieldData.load(context);
    return atomicFieldData.getBytesValues();
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) {
    final AtomicOrdinalsFieldData atomicFieldData = indexFieldData.load(context);
    return atomicFieldData.getBytesValues();
}
 

@Override
public SortedBinaryDocValues bytesValues(LeafReaderContext context) throws IOException {
    return org.elasticsearch.index.fielddata.FieldData.emptySortedBinary(context.reader().maxDoc());
}
 

public Bytes(SortedBinaryDocValues values) {
    this.values = values;
}
 

/**
 * Get the current {@link BytesValues}.
 */
public abstract SortedBinaryDocValues bytesValues(LeafReaderContext context) throws IOException;