1. 包列表
  2. 类列表
  3. org.apache.lucene.index.IndexableField

Java 类org.apache.lucene.index.IndexableField 实例源码

项目：elasticsearch_my    文件：PercolatorFieldMapperTests.java    
public void testExtractTerms() throws Exception {
    addQueryMapping();
    BooleanQuery.Builder bq = new BooleanQuery.Builder();
    TermQuery termQuery1 = new TermQuery(new Term("field", "term1"));
    bq.add(termQuery1, BooleanClause.Occur.SHOULD);
    TermQuery termQuery2 = new TermQuery(new Term("field", "term2"));
    bq.add(termQuery2, BooleanClause.Occur.SHOULD);

    DocumentMapper documentMapper = mapperService.documentMapper(typeName);
    PercolatorFieldMapper fieldMapper = (PercolatorFieldMapper) documentMapper.mappers().getMapper(fieldName);
    ParseContext.InternalParseContext parseContext = new ParseContext.InternalParseContext(Settings.EMPTY,
            mapperService.documentMapperParser(), documentMapper, null, null);
    fieldMapper.processQuery(bq.build(), parseContext);
    ParseContext.Document document = parseContext.doc();

    PercolatorFieldMapper.FieldType fieldType = (PercolatorFieldMapper.FieldType) fieldMapper.fieldType();
    assertThat(document.getField(fieldType.extractionResultField.name()).stringValue(), equalTo(EXTRACTION_COMPLETE));
    List<IndexableField> fields = new ArrayList<>(Arrays.asList(document.getFields(fieldType.queryTermsField.name())));
    Collections.sort(fields, (field1, field2) -> field1.binaryValue().compareTo(field2.binaryValue()));
    assertThat(fields.size(), equalTo(2));
    assertThat(fields.get(0).binaryValue().utf8ToString(), equalTo("field\u0000term1"));
    assertThat(fields.get(1).binaryValue().utf8ToString(), equalTo("field\u0000term2"));
}
项目：elasticsearch_my    文件：CompletionFieldMapperTests.java    
public void testParsingMultiValueWithWeight() throws Exception {
    String mapping = jsonBuilder().startObject().startObject("type1")
            .startObject("properties").startObject("completion")
            .field("type", "completion")
            .endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type1", new CompressedXContent(mapping));
    FieldMapper fieldMapper = defaultMapper.mappers().getMapper("completion");
    MappedFieldType completionFieldType = fieldMapper.fieldType();
    ParsedDocument parsedDocument = defaultMapper.parse("test", "type1", "1", XContentFactory.jsonBuilder()
            .startObject()
            .startObject("completion")
            .array("input", "suggestion1", "suggestion2", "suggestion3")
            .field("weight", 2)
            .endObject()
            .endObject()
            .bytes());
    IndexableField[] fields = parsedDocument.rootDoc().getFields(completionFieldType.name());
    assertSuggestFields(fields, 3);
}
项目：elasticsearch_my    文件：IpFieldMapperTests.java    
public void testStore() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "ip").field("store", true).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "::1")
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(3, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(1, pointField.fieldType().pointDimensionCount());
    IndexableField dvField = fields[1];
    assertEquals(DocValuesType.SORTED_SET, dvField.fieldType().docValuesType());
    IndexableField storedField = fields[2];
    assertTrue(storedField.fieldType().stored());
    assertEquals(new BytesRef(InetAddressPoint.encode(InetAddress.getByName("::1"))),
            storedField.binaryValue());
}
项目：elasticsearch_my    文件：FieldNamesFieldMapper.java    
@Override
protected void parseCreateField(ParseContext context, List<IndexableField> fields) throws IOException {
    if (fieldType().isEnabled() == false) {
        return;
    }
    for (ParseContext.Document document : context.docs()) {
        final List<String> paths = new ArrayList<>();
        for (IndexableField field : document.getFields()) {
            paths.add(field.name());
        }
        for (String path : paths) {
            for (String fieldName : extractFieldNames(path)) {
                if (fieldType().indexOptions() != IndexOptions.NONE || fieldType().stored()) {
                    document.add(new Field(fieldType().name(), fieldName, fieldType()));
                }
            }
        }
    }
}
项目：elasticsearch_my    文件：TokenCountFieldMapper.java    
@Override
protected void parseCreateField(ParseContext context, List<IndexableField> fields) throws IOException {
    final String value;
    if (context.externalValueSet()) {
        value = context.externalValue().toString();
    } else {
        value = context.parser().textOrNull();
    }

    final int tokenCount;
    if (value == null) {
        tokenCount = (Integer) fieldType().nullValue();
    } else {
        tokenCount = countPositions(analyzer, name(), value);
    }

    boolean indexed = fieldType().indexOptions() != IndexOptions.NONE;
    boolean docValued = fieldType().hasDocValues();
    boolean stored = fieldType().stored();
    fields.addAll(NumberFieldMapper.NumberType.INTEGER.createFields(fieldType().name(), tokenCount, indexed, docValued, stored));
}
项目：elasticsearch_my    文件：FieldMapper.java    
/**
 * Parse using the provided {@link ParseContext} and return a mapping
 * update if dynamic mappings modified the mappings, or {@code null} if
 * mappings were not modified.
 */
public Mapper parse(ParseContext context) throws IOException {
    final List<IndexableField> fields = new ArrayList<>(2);
    try {
        parseCreateField(context, fields);
        for (IndexableField field : fields) {
            if (!customBoost()
                    // don't set boosts eg. on dv fields
                    && field.fieldType().indexOptions() != IndexOptions.NONE
                    && indexCreatedVersion.before(Version.V_5_0_0_alpha1)) {
                ((Field)(field)).setBoost(fieldType().boost());
            }
            context.doc().add(field);
        }
    } catch (Exception e) {
        throw new MapperParsingException("failed to parse [" + fieldType().name() + "]", e);
    }
    multiFields.parse(this, context);
    return null;
}
项目：elasticsearch_my    文件：DocumentParser.java    
private static ParseContext nestedContext(ParseContext context, ObjectMapper mapper) {
    context = context.createNestedContext(mapper.fullPath());
    ParseContext.Document nestedDoc = context.doc();
    ParseContext.Document parentDoc = nestedDoc.getParent();
    // pre add the uid field if possible (id was already provided)
    IndexableField uidField = parentDoc.getField(UidFieldMapper.NAME);
    if (uidField != null) {
        // we don't need to add it as a full uid field in nested docs, since we don't need versioning
        // we also rely on this for UidField#loadVersion

        // this is a deeply nested field
        nestedDoc.add(new Field(UidFieldMapper.NAME, uidField.stringValue(), UidFieldMapper.Defaults.NESTED_FIELD_TYPE));
    }
    // the type of the nested doc starts with __, so we can identify that its a nested one in filters
    // note, we don't prefix it with the type of the doc since it allows us to execute a nested query
    // across types (for example, with similar nested objects)
    nestedDoc.add(new Field(TypeFieldMapper.NAME, mapper.nestedTypePathAsString(), TypeFieldMapper.Defaults.FIELD_TYPE));
    return context;
}
项目：elasticsearch_my    文件：TextFieldMapper.java    
@Override
protected void parseCreateField(ParseContext context, List<IndexableField> fields) throws IOException {
    final String value;
    if (context.externalValueSet()) {
        value = context.externalValue().toString();
    } else {
        value = context.parser().textOrNull();
    }

    if (value == null) {
        return;
    }

    if (context.includeInAll(includeInAll, this)) {
        context.allEntries().addText(fieldType().name(), value, fieldType().boost());
    }

    if (fieldType().indexOptions() != IndexOptions.NONE || fieldType().stored()) {
        Field field = new Field(fieldType().name(), value, fieldType());
        fields.add(field);
    }
}
项目：elasticsearch_my    文件：CompletionFieldMapperTests.java    
public void testParsingMultiValued() throws Exception {
    String mapping = jsonBuilder().startObject().startObject("type1")
            .startObject("properties").startObject("completion")
            .field("type", "completion")
            .endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type1", new CompressedXContent(mapping));
    FieldMapper fieldMapper = defaultMapper.mappers().getMapper("completion");
    MappedFieldType completionFieldType = fieldMapper.fieldType();
    ParsedDocument parsedDocument = defaultMapper.parse("test", "type1", "1", XContentFactory.jsonBuilder()
            .startObject()
            .array("completion", "suggestion1", "suggestion2")
            .endObject()
            .bytes());
    IndexableField[] fields = parsedDocument.rootDoc().getFields(completionFieldType.name());
    assertSuggestFields(fields, 2);
}
项目：elasticsearch_my    文件：SourceFieldMapperTests.java    
public void testExcludes() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
        .startObject("_source").array("excludes", new String[]{"path1*"}).endObject()
        .endObject().endObject().string();

    DocumentMapper documentMapper = createIndex("test").mapperService().documentMapperParser().parse("type", new CompressedXContent(mapping));

    ParsedDocument doc = documentMapper.parse("test", "type", "1", XContentFactory.jsonBuilder().startObject()
        .startObject("path1").field("field1", "value1").endObject()
        .startObject("path2").field("field2", "value2").endObject()
        .endObject().bytes());

    IndexableField sourceField = doc.rootDoc().getField("_source");
    Map<String, Object> sourceAsMap;
    try (XContentParser parser = createParser(JsonXContent.jsonXContent, new BytesArray(sourceField.binaryValue()))) {
        sourceAsMap = parser.map();
    }
    assertThat(sourceAsMap.containsKey("path1"), equalTo(false));
    assertThat(sourceAsMap.containsKey("path2"), equalTo(true));
}
项目：elasticsearch_my    文件：HalfFloatFielddataTests.java    
public void testSingleValued() throws IOException {
    Directory dir = newDirectory();
    // we need the default codec to check for singletons
    IndexWriter w = new IndexWriter(dir, new IndexWriterConfig(null).setCodec(TestUtil.getDefaultCodec()));
    Document doc = new Document();
    for (IndexableField f : NumberFieldMapper.NumberType.HALF_FLOAT.createFields("half_float", 3f, false, true, false)) {
        doc.add(f);
    }
    w.addDocument(doc);
    final DirectoryReader dirReader = DirectoryReader.open(w);
    LeafReader reader = getOnlyLeafReader(dirReader);
    SortedNumericDoubleValues values = new SortedNumericDVIndexFieldData.SortedNumericHalfFloatFieldData(
            reader, "half_float").getDoubleValues();
    assertNotNull(FieldData.unwrapSingleton(values));
    values.setDocument(0);
    assertEquals(1, values.count());
    assertEquals(3f, values.valueAt(0), 0f);
    IOUtils.close(dirReader, w, dir);
}
项目：elasticsearch_my    文件：KeywordFieldMapperTests.java    
public void testEnableStore() throws IOException {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "keyword").field("store", true).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "1234")
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(2, fields.length);
    assertTrue(fields[0].fieldType().stored());
}
项目：elasticsearch_my    文件：KeywordFieldMapperTests.java    
public void testDisableIndex() throws IOException {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "keyword").field("index", false).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "1234")
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    assertEquals(IndexOptions.NONE, fields[0].fieldType().indexOptions());
    assertEquals(DocValuesType.SORTED_SET, fields[0].fieldType().docValuesType());
}
项目：elasticsearch_my    文件：KeywordFieldMapperTests.java    
public void testEnableNorms() throws IOException {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "keyword").field("norms", true).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "1234")
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(2, fields.length);
    assertFalse(fields[0].fieldType().omitNorms());
}
项目：elasticsearch_my    文件：RangeFieldMapperTests.java    
@Override
public void doTestDefaults(String type) throws Exception {
    XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
        .startObject("properties").startObject("field").field("type", type);
    if (type.equals("date_range")) {
        mapping = mapping.field("format", DATE_FORMAT);
    }
    mapping = mapping.endObject().endObject().endObject().endObject();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping.string()));
    assertEquals(mapping.string(), mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
        .startObject()
        .startObject("field")
        .field(getFromField(), getFrom(type))
        .field(getToField(), getTo(type))
        .endObject()
        .endObject().bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(2, pointField.fieldType().pointDimensionCount());
    assertFalse(pointField.fieldType().stored());
}
项目：elasticsearch_my    文件：CompletionFieldMapperTests.java    
public void testParsingWithWeight() throws Exception {
    String mapping = jsonBuilder().startObject().startObject("type1")
            .startObject("properties").startObject("completion")
            .field("type", "completion")
            .endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type1", new CompressedXContent(mapping));
    FieldMapper fieldMapper = defaultMapper.mappers().getMapper("completion");
    MappedFieldType completionFieldType = fieldMapper.fieldType();
    ParsedDocument parsedDocument = defaultMapper.parse("test", "type1", "1", XContentFactory.jsonBuilder()
            .startObject()
            .startObject("completion")
            .field("input", "suggestion")
            .field("weight", 2)
            .endObject()
            .endObject()
            .bytes());
    IndexableField[] fields = parsedDocument.rootDoc().getFields(completionFieldType.name());
    assertSuggestFields(fields, 1);
}
项目：elasticsearch_my    文件：RangeFieldMapperTests.java    
@Override
protected void doTestNoDocValues(String type) throws Exception {
    XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
        .startObject("properties").startObject("field").field("type", type).field("doc_values", false);
    if (type.equals("date_range")) {
        mapping = mapping.field("format", DATE_FORMAT);
    }
    mapping = mapping.endObject().endObject().endObject().endObject();
    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping.string()));
    assertEquals(mapping.string(), mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
        .startObject()
        .startObject("field")
        .field(getFromField(), getFrom(type))
        .field(getToField(), getTo(type))
        .endObject()
        .endObject().bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(2, pointField.fieldType().pointDimensionCount());
}
项目：elasticsearch_my    文件：ScaledFloatFieldMapperTests.java    
public void testNoDocValues() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "scaled_float")
            .field("doc_values", false).field("scaling_factor", 10.0).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", 123)
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(1, pointField.fieldType().pointDimensionCount());
    assertEquals(1230, pointField.numericValue().longValue());
}
项目：elasticsearch_my    文件：DateFieldMapperTests.java    
public void testNotIndexed() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "date").field("index", false).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "2016-03-11")
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField dvField = fields[0];
    assertEquals(DocValuesType.SORTED_NUMERIC, dvField.fieldType().docValuesType());
}
项目：elasticsearch_my    文件：Murmur3FieldMapper.java    
@Override
protected void parseCreateField(ParseContext context, List<IndexableField> fields)
        throws IOException {
    final Object value;
    if (context.externalValueSet()) {
        value = context.externalValue();
    } else {
        value = context.parser().textOrNull();
    }
    if (value != null) {
        final BytesRef bytes = new BytesRef(value.toString());
        final long hash = MurmurHash3.hash128(bytes.bytes, bytes.offset, bytes.length, 0, new MurmurHash3.Hash128()).h1;
        fields.add(new SortedNumericDocValuesField(fieldType().name(), hash));
        if (fieldType().stored()) {
            fields.add(new StoredField(name(), hash));
        }
    }
}
项目：elasticsearch_my    文件：NumberFieldMapperTests.java    
@Override
public void doTestNoDocValues(String type) throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", type).field("doc_values", false).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", 123)
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(1, pointField.fieldType().pointDimensionCount());
    assertEquals(123, pointField.numericValue().doubleValue(), 0d);
}
项目：elasticsearch_my    文件：FakeStringFieldMapper.java    
@Override
protected void parseCreateField(ParseContext context, List<IndexableField> fields) throws IOException {
    String value;
    if (context.externalValueSet()) {
        value = context.externalValue().toString();
    } else {
        value = context.parser().textOrNull();
    }

    if (value == null) {
        return;
    }

    if (fieldType().indexOptions() != IndexOptions.NONE || fieldType().stored()) {
        Field field = new Field(fieldType().name(), value, fieldType());
        fields.add(field);
    }
    if (fieldType().hasDocValues()) {
        fields.add(new SortedSetDocValuesField(fieldType().name(), new BytesRef(value)));
    }
}
项目：elasticsearch_my    文件：TextFieldMapperTests.java    
public void testEnableStore() throws IOException {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "text").field("store", true).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "1234")
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    assertTrue(fields[0].fieldType().stored());
}
项目：elasticsearch_my    文件：IpFieldMapperTests.java    
public void testNoDocValues() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "ip").field("doc_values", false).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "::1")
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(1, pointField.fieldType().pointDimensionCount());
    assertEquals(new BytesRef(InetAddressPoint.encode(InetAddresses.forString("::1"))), pointField.binaryValue());
}
项目：Elasticsearch    文件：FieldNamesFieldMapper.java    
@Override
protected void parseCreateField(ParseContext context, List<Field> fields) throws IOException {
    if (fieldType().isEnabled() == false) {
        return;
    }
    for (ParseContext.Document document : context.docs()) {
        final List<String> paths = new ArrayList<>();
        for (IndexableField field : document.getFields()) {
            paths.add(field.name());
        }
        for (String path : paths) {
            for (String fieldName : extractFieldNames(path)) {
                if (fieldType().indexOptions() != IndexOptions.NONE || fieldType().stored()) {
                    document.add(new Field(fieldType().names().indexName(), fieldName, fieldType()));
                }
            }
        }
    }
}
项目：elasticsearch_my    文件：NumberFieldMapperTests.java    
@Override
public void doTestDefaults(String type) throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", type).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", 123)
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(2, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(1, pointField.fieldType().pointDimensionCount());
    assertFalse(pointField.fieldType().stored());
    assertEquals(123, pointField.numericValue().doubleValue(), 0d);
    IndexableField dvField = fields[1];
    assertEquals(DocValuesType.SORTED_NUMERIC, dvField.fieldType().docValuesType());
    assertFalse(dvField.fieldType().stored());
}
项目：elasticsearch_my    文件：NumberFieldMapperTests.java    
@Override
public void doTestNotIndexed(String type) throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", type).field("index", false).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", 123)
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField dvField = fields[0];
    assertEquals(DocValuesType.SORTED_NUMERIC, dvField.fieldType().docValuesType());
}
项目：elasticsearch_my    文件：BinaryFieldMapper.java    
@Override
protected void parseCreateField(ParseContext context, List<IndexableField> fields) throws IOException {
    if (!fieldType().stored() && !fieldType().hasDocValues()) {
        return;
    }
    byte[] value = context.parseExternalValue(byte[].class);
    if (value == null) {
        if (context.parser().currentToken() == XContentParser.Token.VALUE_NULL) {
            return;
        } else {
            value = context.parser().binaryValue();
        }
    }
    if (value == null) {
        return;
    }
    if (fieldType().stored()) {
        fields.add(new Field(fieldType().name(), value, fieldType()));
    }

    if (fieldType().hasDocValues()) {
        CustomBinaryDocValuesField field = (CustomBinaryDocValuesField) context.doc().getByKey(fieldType().name());
        if (field == null) {
            field = new CustomBinaryDocValuesField(fieldType().name(), value);
            context.doc().addWithKey(fieldType().name(), field);
        } else {
            field.add(value);
        }
    }

}
项目：elasticsearch_my    文件：RangeFieldMapper.java    
public List<IndexableField> createFields(String name, Range range, boolean indexed, boolean docValued, boolean stored) {
    assert range != null : "range cannot be null when creating fields";
    List<IndexableField> fields = new ArrayList<>();
    if (indexed) {
        fields.add(getRangeField(name, range));
    }
    // todo add docValues ranges once aggregations are supported
    if (stored) {
        fields.add(new StoredField(name, range.toString()));
    }
    return fields;
}
项目：Sound.je    文件：JodaPeriodSplitBridge.java    
@Override
public Object get(final String name, final Document document) {
    final IndexableField stringPeriod = document.getField(name);
    if (stringPeriod != null) {
        return Period.seconds((Integer) stringPeriod.numericValue());
    } else {
        return null;
    }
}
项目：elasticsearch_my    文件：BooleanFieldMapperTests.java    
public void testDocValues() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties")
            .startObject("bool1")
                .field("type", "boolean")
            .endObject()
            .startObject("bool2")
                .field("type", "boolean")
                .field("index", false)
            .endObject()
            .startObject("bool3")
                .field("type", "boolean")
                .field("index", true)
            .endObject()
            .endObject()
            .endObject().endObject().string();

    DocumentMapper defaultMapper = indexService.mapperService().documentMapperParser().parse("type", new CompressedXContent(mapping));

    ParsedDocument parsedDoc = defaultMapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("bool1", true)
            .field("bool2", true)
            .field("bool3", true)
            .endObject()
            .bytes());
    Document doc = parsedDoc.rootDoc();
    IndexableField[] fields = doc.getFields("bool1");
    assertEquals(2, fields.length);
    assertEquals(DocValuesType.NONE, fields[0].fieldType().docValuesType());
    assertEquals(DocValuesType.SORTED_NUMERIC, fields[1].fieldType().docValuesType());
    fields = doc.getFields("bool2");
    assertEquals(1, fields.length);
    assertEquals(DocValuesType.SORTED_NUMERIC, fields[0].fieldType().docValuesType());
    fields = doc.getFields("bool3");
    assertEquals(DocValuesType.NONE, fields[0].fieldType().docValuesType());
    assertEquals(DocValuesType.SORTED_NUMERIC, fields[1].fieldType().docValuesType());
}
项目：Elasticsearch    文件：ParseContext.java    
public IndexableField getField(String name) {
    for (IndexableField field : fields) {
        if (field.name().equals(name)) {
            return field;
        }
    }
    return null;
}
项目：elasticsearch_my    文件：ParseContext.java    
/** Add fields so that they can later be fetched using {@link #getByKey(Object)}. */
public void addWithKey(Object key, IndexableField field) {
    if (keyedFields == null) {
        keyedFields = new ObjectObjectHashMap<>();
    } else if (keyedFields.containsKey(key)) {
        throw new IllegalStateException("Only one field can be stored per key");
    }
    keyedFields.put(key, field);
    add(field);
}
项目：elasticsearch_my    文件：ParseContext.java    
public IndexableField getField(String name) {
    for (IndexableField field : fields) {
        if (field.name().equals(name)) {
            return field;
        }
    }
    return null;
}
项目：elasticsearch_my    文件：ParseContext.java    
public String get(String name) {
    for (IndexableField f : fields) {
        if (f.name().equals(name) && f.stringValue() != null) {
            return f.stringValue();
        }
    }
    return null;
}
项目：elasticsearch_my    文件：FieldNamesFieldMapperTests.java    
public void testSeesFieldsFromPlugins() throws IOException {
    IndexService indexService = createIndex("test");
    IndicesModule indicesModule = newTestIndicesModule(
        Collections.emptyMap(),
        Collections.singletonMap("_dummy", new DummyMetadataFieldMapper.TypeParser())
    );
    final MapperRegistry mapperRegistry = indicesModule.getMapperRegistry();
    Supplier<QueryShardContext> queryShardContext = () -> {
        return indexService.newQueryShardContext(0, null, () -> { throw new UnsupportedOperationException(); });
    };
    MapperService mapperService = new MapperService(indexService.getIndexSettings(), indexService.getIndexAnalyzers(),
            indexService.xContentRegistry(), indexService.similarityService(), mapperRegistry, queryShardContext);
    DocumentMapperParser parser = new DocumentMapperParser(indexService.getIndexSettings(), mapperService,
            indexService.getIndexAnalyzers(), indexService.xContentRegistry(), indexService.similarityService(), mapperRegistry,
            queryShardContext);
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").endObject().endObject().string();
    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
    ParsedDocument parsedDocument = mapper.parse("index", "type", "id", new BytesArray("{}"));
    IndexableField[] fields = parsedDocument.rootDoc().getFields(FieldNamesFieldMapper.NAME);
    boolean found = false;
    for (IndexableField f : fields) {
        if ("_dummy".equals(f.stringValue())) {
            found = true;
            break;
        }
    }
    assertTrue("Could not find the dummy field among " + Arrays.toString(fields), found);
}
项目：elasticsearch_my    文件：TypeFieldMapper.java    
@Override
protected void parseCreateField(ParseContext context, List<IndexableField> fields) throws IOException {
    if (fieldType().indexOptions() == IndexOptions.NONE && !fieldType().stored()) {
        return;
    }
    fields.add(new Field(fieldType().name(), context.sourceToParse().type(), fieldType()));
    if (fieldType().hasDocValues()) {
        fields.add(new SortedSetDocValuesField(fieldType().name(), new BytesRef(context.sourceToParse().type())));
    }
}
项目：lams    文件：Document.java    
/**
 * Returns an array of values of the field specified as the method parameter.
 * This method returns an empty array when there are no
 * matching fields.  It never returns null.
 * For {@link IntField}, {@link LongField}, {@link
 * FloatField} and {@link DoubleField} it returns the string value of the number. If you want
 * the actual numeric field instances back, use {@link #getFields}.
 * @param name the name of the field
 * @return a <code>String[]</code> of field values
 */
public final String[] getValues(String name) {
  List<String> result = new ArrayList<>();
  for (IndexableField field : fields) {
    if (field.name().equals(name) && field.stringValue() != null) {
      result.add(field.stringValue());
    }
  }

  if (result.size() == 0) {
    return NO_STRINGS;
  }

  return result.toArray(new String[result.size()]);
}
项目：elasticsearch_my    文件：UidFieldMapper.java    
@Override
protected void parseCreateField(ParseContext context, List<IndexableField> fields) throws IOException {
    Field uid = new Field(NAME, Uid.createUid(context.sourceToParse().type(), context.sourceToParse().id()), Defaults.FIELD_TYPE);
    fields.add(uid);
    if (fieldType().hasDocValues()) {
        fields.add(new BinaryDocValuesField(NAME, new BytesRef(uid.stringValue())));
    }
}
项目：elasticsearch_my    文件：NumberFieldMapperTests.java    
@Override
public void doTestCoerce(String type) throws IOException {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", type).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "123")
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(2, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(1, pointField.fieldType().pointDimensionCount());
    assertEquals(123, pointField.numericValue().doubleValue(), 0d);
    IndexableField dvField = fields[1];
    assertEquals(DocValuesType.SORTED_NUMERIC, dvField.fieldType().docValuesType());

    mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", type).field("coerce", false).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper2 = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper2.mappingSource().toString());

    ThrowingRunnable runnable = () -> mapper2.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "123")
            .endObject()
            .bytes());
    MapperParsingException e = expectThrows(MapperParsingException.class, runnable);
    assertThat(e.getCause().getMessage(), containsString("passed as String"));
}