Java FieldMappingMetaData类代码示例

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
/**
 * Helper method to find out if the only included fieldmapping metadata is typed NULL, which means
 * that type and index exist, but the field did not
 */
private boolean isFieldMappingMissingField(Map<String, Map<String, Map<String, FieldMappingMetaData>>> mappingsByIndex) {
    if (mappingsByIndex.size() != 1) {
        return false;
    }

    for (Map<String, Map<String, FieldMappingMetaData>> value : mappingsByIndex.values()) {
        for (Map<String, FieldMappingMetaData> fieldValue : value.values()) {
            for (Map.Entry<String, FieldMappingMetaData> fieldMappingMetaDataEntry : fieldValue.entrySet()) {
                if (fieldMappingMetaDataEntry.getValue().isNull()) {
                    return true;
                }
            }
        }
    }
    return false;
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
public void testSerialization() throws IOException {
    Map<String, Map<String, Map<String, FieldMappingMetaData>>> mappings = new HashMap<>();
    FieldMappingMetaData fieldMappingMetaData = new FieldMappingMetaData("my field", new BytesArray("{}"));
    mappings.put("index", Collections.singletonMap("type", Collections.singletonMap("field", fieldMappingMetaData)));
    GetFieldMappingsResponse response = new GetFieldMappingsResponse(mappings);

    try (BytesStreamOutput out = new BytesStreamOutput()) {
        response.writeTo(out);
        GetFieldMappingsResponse serialized = new GetFieldMappingsResponse();
        try (StreamInput in = StreamInput.wrap(out.bytes().toBytesRef().bytes)) {
            serialized.readFrom(in);
            FieldMappingMetaData metaData = serialized.fieldMappings("index", "type", "field");
            assertNotNull(metaData);
            assertEquals(new BytesArray("{}"), metaData.getSource());
        }
    }
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
/**
 * Helper method to find out if the only included fieldmapping metadata is typed NULL, which means
 * that type and index exist, but the field did not
 */
private boolean isFieldMappingMissingField(ImmutableMap<String, ImmutableMap<String, ImmutableMap<String, FieldMappingMetaData>>> mappingsByIndex) throws IOException {
    if (mappingsByIndex.size() != 1) {
        return false;
    }

    for (ImmutableMap<String, ImmutableMap<String, FieldMappingMetaData>> value : mappingsByIndex.values()) {
        for (ImmutableMap<String, FieldMappingMetaData> fieldValue : value.values()) {
            for (Map.Entry<String, FieldMappingMetaData> fieldMappingMetaDataEntry : fieldValue.entrySet()) {
                if (fieldMappingMetaDataEntry.getValue().isNull()) {
                    return true;
                }
            }
        }
    }
    return false;
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    final String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    final String[] types = request.paramAsStringArrayOrEmptyIfAll("type");
    final String[] fields = Strings.splitStringByCommaToArray(request.param("fields"));
    GetFieldMappingsRequest getMappingsRequest = new GetFieldMappingsRequest();
    getMappingsRequest.indices(indices).types(types).fields(fields).includeDefaults(request.paramAsBoolean("include_defaults", false));
    getMappingsRequest.indicesOptions(IndicesOptions.fromRequest(request, getMappingsRequest.indicesOptions()));
    getMappingsRequest.local(request.paramAsBoolean("local", getMappingsRequest.local()));
    return channel ->
            client.admin().indices().getFieldMappings(getMappingsRequest, new RestBuilderListener<GetFieldMappingsResponse>(channel) {
                @Override
                public RestResponse buildResponse(GetFieldMappingsResponse response, XContentBuilder builder) throws Exception {
                    Map<String, Map<String, Map<String, FieldMappingMetaData>>> mappingsByIndex = response.mappings();

                    boolean isPossibleSingleFieldRequest = indices.length == 1 && types.length == 1 && fields.length == 1;
                    if (isPossibleSingleFieldRequest && isFieldMappingMissingField(mappingsByIndex)) {
                        return new BytesRestResponse(OK, builder.startObject().endObject());
                    }

                    RestStatus status = OK;
                    if (mappingsByIndex.isEmpty() && fields.length > 0) {
                        status = NOT_FOUND;
                    }
                    builder.startObject();
                    response.toXContent(builder, request);
                    builder.endObject();
                    return new BytesRestResponse(status, builder);
                }
            });
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
private void addFieldMapper(String field, FieldMapper fieldMapper, MapBuilder<String, FieldMappingMetaData> fieldMappings, boolean includeDefaults) {
    if (fieldMappings.containsKey(field)) {
        return;
    }
    try {
        XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON);
        builder.startObject();
        fieldMapper.toXContent(builder, includeDefaults ? includeDefaultsParams : ToXContent.EMPTY_PARAMS);
        builder.endObject();
        fieldMappings.put(field, new FieldMappingMetaData(fieldMapper.fieldType().name(), builder.bytes()));
    } catch (IOException e) {
        throw new ElasticsearchException("failed to serialize XContent of field [" + field + "]", e);
    }
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {
    final String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    final String[] types = request.paramAsStringArrayOrEmptyIfAll("type");
    final String[] fields = Strings.splitStringByCommaToArray(request.param("fields"));
    GetFieldMappingsRequest getMappingsRequest = new GetFieldMappingsRequest();
    getMappingsRequest.indices(indices).types(types).fields(fields).includeDefaults(request.paramAsBoolean("include_defaults", false));
    getMappingsRequest.indicesOptions(IndicesOptions.fromRequest(request, getMappingsRequest.indicesOptions()));
    getMappingsRequest.local(request.paramAsBoolean("local", getMappingsRequest.local()));
    client.admin().indices().getFieldMappings(getMappingsRequest, new RestBuilderListener<GetFieldMappingsResponse>(channel) {

        @SuppressWarnings("unchecked")
        @Override
        public RestResponse buildResponse(GetFieldMappingsResponse response, XContentBuilder builder) throws Exception {
            ImmutableMap<String, ImmutableMap<String, ImmutableMap<String, FieldMappingMetaData>>> mappingsByIndex = response.mappings();

            boolean isPossibleSingleFieldRequest = indices.length == 1 && types.length == 1 && fields.length == 1;
            if (isPossibleSingleFieldRequest && isFieldMappingMissingField(mappingsByIndex)) {
                return new BytesRestResponse(OK, builder.startObject().endObject());
            }

            RestStatus status = OK;
            if (mappingsByIndex.isEmpty() && fields.length > 0) {
                status = NOT_FOUND;
            }
            builder.startObject();
            response.toXContent(builder, request);
            builder.endObject();
            return new BytesRestResponse(status, builder);
        }
    });
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
private void addFieldMapper(String field, FieldMapper fieldMapper, MapBuilder<String, FieldMappingMetaData> fieldMappings, boolean includeDefaults) {
    if (fieldMappings.containsKey(field)) {
        return;
    }
    try {
        XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON);
        builder.startObject();
        fieldMapper.toXContent(builder, includeDefaults ? includeDefaultsParams : ToXContent.EMPTY_PARAMS);
        builder.endObject();
        fieldMappings.put(field, new FieldMappingMetaData(fieldMapper.fieldType().names().fullName(), builder.bytes()));
    } catch (IOException e) {
        throw new ElasticsearchException("failed to serialize XContent of field [" + field + "]", e);
    }
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
@Override
public ImmutableOpenMap<String, FieldMappingMetaData> getMappingsForField(String index,
        String field) {
    Object mappingss = cache.get(makeKey(index, field));
    if (mappingss == null) {
        mappingss = getClient().admin().indices().prepareGetMappings(index).execute()
                .actionGet();
        cache.put(makeKey(index, field), mappingss);
    }

    ImmutableOpenMap.Builder<String, FieldMappingMetaData> mappingsMapBuilder = new ImmutableOpenMap.Builder<>();
    // TODO: this workaround was implemented because of this ES 5.x issue
    // https://github.com/elastic/elasticsearch/issues/22209
    // revert this when the issue is fixed
    Object[] mappings = ((GetMappingsResponse) mappingss).getMappings().get(index).values()
            .toArray();
    for (Object mapping : mappings) {
        try (XContentBuilder contentBuilder = XContentFactory
                .contentBuilder(XContentType.JSON)) {
            MappingMetaData mappingMetaData = (MappingMetaData) mapping;
            Object fieldMapping = mappingMetaData.getSourceAsMap().get(field);
            contentBuilder.startObject();
            contentBuilder.field(field, fieldMapping);
            contentBuilder.endObject();
            mappingsMapBuilder.put(mappingMetaData.type(),
                    new FieldMappingMetaData(field, contentBuilder.bytes()));
        } catch (IOException e) {
            log.debug(e);
            throw new ODataRuntimeException("Can't parse elasticsearch mapping");
        }
    }

    return mappingsMapBuilder.build();
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
@Override
public FieldMappingMetaData getMappingForField(String index, String type, String field) {
    Object mapping = cache.get(makeKey(index, type, field));
    if (mapping == null) {
        mapping = getClient().admin().indices().prepareGetFieldMappings(index).setTypes(type)
                .setFields(field).execute().actionGet();
        cache.put(makeKey(index, type, field), mapping);
    }

    return ((GetFieldMappingsResponse) mapping).mappings().get(index).get(type).get(field);
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
@Test
public void getNavigationProperties_EntityTypeNameAndEmptyMappings_EmptyListRetrieved() {
    Builder<String, FieldMappingMetaData> builder = ImmutableOpenMap.builder();
    ImmutableOpenMap<String, FieldMappingMetaData> map = builder.build();
    when(metaDataProvider.getMappingsForField(AUTHORS_INDEX, ElasticConstants.PARENT_PROPERTY))
            .thenReturn(map);
    MultyElasticIndexCsdlEdmProvider edmProvider = new MultyElasticIndexCsdlEdmProvider(
            metaDataProvider, indices);
    assertTrue(edmProvider.getNavigationProperties(AUTHORS_INDEX, AUTHOR_TYPE).isEmpty());
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
@Test
public void getNavigationProperties_EntityTypeNameAndMappingsEmptyValueMap_EmptyListRetrieved() {
    Builder<String, FieldMappingMetaData> builder = ImmutableOpenMap.builder();
    FieldMappingMetaData mappingMetaData = mock(FieldMappingMetaData.class);
    when(mappingMetaData.sourceAsMap()).thenReturn(new HashMap<String, Object>());
    builder.put(BOOK_TYPE, mappingMetaData);
    ImmutableOpenMap<String, FieldMappingMetaData> map = builder.build();
    when(metaDataProvider.getMappingsForField(AUTHORS_INDEX, ElasticConstants.PARENT_PROPERTY))
            .thenReturn(map);
    MultyElasticIndexCsdlEdmProvider edmProvider = new MultyElasticIndexCsdlEdmProvider(
            metaDataProvider, indices);
    assertTrue(edmProvider.getNavigationProperties(AUTHORS_INDEX, AUTHOR_TYPE).isEmpty());
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
private static ImmutableOpenMap<String, FieldMappingMetaData> getParentChildMappings() {
    Builder<String, FieldMappingMetaData> mappingsBuilder = ImmutableOpenMap.builder();
    FieldMappingMetaData mappingMetaData = mock(FieldMappingMetaData.class);
    HashMap<Object, Object> parentProperties = new HashMap<>();
    parentProperties.put("type", AUTHOR_TYPE);
    mappingsBuilder.put(BOOK_TYPE, mappingMetaData);
    HashMap<String, Object> parent = new HashMap<String, Object>();
    parent.put(ElasticConstants.PARENT_PROPERTY, parentProperties);
    when(mappingMetaData.sourceAsMap()).thenReturn(parent);
    return mappingsBuilder.build();
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
private boolean containsKibanaUserIndex(ActionResponse response) {
    String index = "";

    if (response instanceof MultiGetResponse) {
        for (MultiGetItemResponse item : ((MultiGetResponse) response).getResponses()) {
            GetResponse itemResponse = item.getResponse();
            Failure itemFailure = item.getFailure();

            if (itemResponse == null) {
                if (isKibanaUserIndex(itemFailure.getIndex())) {
                    return true;
                }
            } else {
                if (isKibanaUserIndex(itemResponse.getIndex())) {
                    return true;
                }
            }
        }

        return false;
    }

    if (response instanceof IndexResponse) {
        index = ((IndexResponse) response).getIndex();
    } else if (response instanceof GetResponse) {
        index = ((GetResponse) response).getIndex();
    } else if (response instanceof DeleteResponse) {
        index = ((DeleteResponse) response).getIndex();
    } else if (response instanceof GetFieldMappingsResponse) {
        ImmutableMap<String, ImmutableMap<String, ImmutableMap<String, FieldMappingMetaData>>> mappings = ((GetFieldMappingsResponse) response)
                .mappings();
        for (String key : mappings.keySet()) {
            index = key;
        }
    }

    return isKibanaUserIndex(index);
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
public void updateMappingResponse(StreamOutput out, String index,
        ImmutableMap<String, ImmutableMap<String, ImmutableMap<String, FieldMappingMetaData>>> mappings)
        throws IOException {
    super.writeTo(out);
    out.writeVInt(mappings.size());
    for (Map.Entry<String, ImmutableMap<String, ImmutableMap<String, FieldMappingMetaData>>> indexEntry : mappings
            .entrySet()) {
        out.writeString(index);
        out.writeVInt(indexEntry.getValue().size());
        for (Map.Entry<String, ImmutableMap<String, FieldMappingMetaData>> typeEntry : indexEntry.getValue()
                .entrySet()) {
            out.writeString(typeEntry.getKey());
            out.writeVInt(typeEntry.getValue().size());

            for (Map.Entry<String, FieldMappingMetaData> fieldEntry : typeEntry.getValue().entrySet()) {
                out.writeString(fieldEntry.getKey());
                FieldMappingMetaData fieldMapping = fieldEntry.getValue();
                out.writeString(fieldMapping.fullName());

                // below replaces logic of
                // out.writeBytesReference(fieldMapping.source);
                Map<String, Object> map = fieldMapping.sourceAsMap();

                XContentBuilder builder = XContentBuilder.builder(JsonXContent.jsonXContent);

                builder.map(map).close();
                out.writeBytesReference(builder.bytes());
            }
        }
    }
}
 

import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetaData; //导入依赖的package包/类
/**
 * Get all mappings for fields with the requested name within a single
 * instance.
 * 
 * @param index
 *            name of the index.
 * @param field
 *            name of the field.
 * @return type/field mapping map.
 */
ImmutableOpenMap<String, FieldMappingMetaData> getMappingsForField(String index, String field);