private boolean assertMappersShareSameFieldType() { for (DocumentMapper mapper : docMappers(false)) { List<FieldMapper> fieldMappers = new ArrayList<>(); Collections.addAll(fieldMappers, mapper.mapping().metadataMappers); MapperUtils.collect(mapper.root(), new ArrayList<>(), fieldMappers, new ArrayList<>()); for (FieldMapper fieldMapper : fieldMappers) { assert fieldMapper.fieldType() == fieldTypes.get(fieldMapper.name()) : fieldMapper.name(); } } return true; }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(simpleName()); boolean includeDefaults = params.paramAsBoolean("include_defaults", false); doXContentBody(builder, includeDefaults, params); return builder.endObject(); }
/** * Merge changes coming from {@code mergeWith} in place. * @param updateAllTypes TODO */ protected void doMerge(Mapper mergeWith, boolean updateAllTypes) { if (!this.getClass().equals(mergeWith.getClass())) { String mergedType = mergeWith.getClass().getSimpleName(); if (mergeWith instanceof FieldMapper) { mergedType = ((FieldMapper) mergeWith).contentType(); } throw new IllegalArgumentException("mapper [" + fieldType().name() + "] of different type, current_type [" + contentType() + "], merged_type [" + mergedType + "]"); } FieldMapper fieldMergeWith = (FieldMapper) mergeWith; multiFields = multiFields.merge(fieldMergeWith.multiFields); // apply changeable values this.fieldType = fieldMergeWith.fieldType; this.copyTo = fieldMergeWith.copyTo; }
builder.field("type", contentType()); if (includeDefaults || fieldType().boost() != 1.0f) { builder.field("boost", fieldType().boost()); boolean indexed = fieldType().indexOptions() != IndexOptions.NONE; boolean defaultIndexed = defaultFieldType.indexOptions() != IndexOptions.NONE; if (includeDefaults || indexed != defaultIndexed) { builder.field("index", indexed); if (includeDefaults || fieldType().stored() != defaultFieldType.stored()) { builder.field("store", fieldType().stored()); doXContentDocValues(builder, includeDefaults); if (includeDefaults || fieldType().storeTermVectors() != defaultFieldType.storeTermVectors()) { builder.field("term_vector", termVectorOptionsToString(fieldType())); if (includeDefaults || fieldType().omitNorms() != defaultFieldType.omitNorms()) { builder.field("norms", fieldType().omitNorms() == false); if (indexed && (includeDefaults || fieldType().indexOptions() != defaultFieldType.indexOptions())) { builder.field("index_options", indexOptionToString(fieldType().indexOptions())); if (includeDefaults || fieldType().eagerGlobalOrdinals() != defaultFieldType.eagerGlobalOrdinals()) { builder.field("eager_global_ordinals", fieldType().eagerGlobalOrdinals()); if (fieldType().similarity() != null) { builder.field("similarity", fieldType().similarity().name()); } else if (includeDefaults) {
@Override public IpFieldType fieldType() { return (IpFieldType) super.fieldType(); }
builder.field("type", contentType()); if (indexCreatedBefore2x && (includeDefaults || !simpleName().equals(fieldType().names().originalIndexName()))) { builder.field("index_name", fieldType().names().originalIndexName()); if (includeDefaults || fieldType().boost() != 1.0f) { builder.field("boost", fieldType().boost()); boolean indexed = fieldType().indexOptions() != IndexOptions.NONE; boolean defaultIndexed = defaultFieldType.indexOptions() != IndexOptions.NONE; if (includeDefaults || indexed != defaultIndexed || fieldType().tokenized() != defaultFieldType.tokenized()) { builder.field("index", indexTokenizeOptionToString(indexed, fieldType().tokenized())); if (includeDefaults || fieldType().stored() != defaultFieldType.stored()) { builder.field("store", fieldType().stored()); doXContentDocValues(builder, includeDefaults); if (includeDefaults || fieldType().storeTermVectors() != defaultFieldType.storeTermVectors()) { builder.field("term_vector", termVectorOptionsToString(fieldType())); if (includeDefaults || fieldType().omitNorms() != defaultFieldType.omitNorms() || fieldType().normsLoading() != null) { builder.startObject("norms"); if (includeDefaults || fieldType().omitNorms() != defaultFieldType.omitNorms()) { builder.field("enabled", !fieldType().omitNorms()); if (fieldType().normsLoading() != null) { builder.field(MappedFieldType.Loading.KEY, fieldType().normsLoading()); if (indexed && (includeDefaults || fieldType().indexOptions() != defaultFieldType.indexOptions())) {
@Override protected void doMerge(Mapper mergeWith, boolean updateAllTypes) { super.doMerge(mergeWith, updateAllTypes); this.includeInAll = ((KeywordFieldMapper) mergeWith).includeInAll; this.ignoreAbove = ((KeywordFieldMapper) mergeWith).ignoreAbove; }
if (fieldMapper != null) { Map<String, Object> mapper = new HashMap(); mapper.put("fullName", fieldMapper.names().fullName()); mapper.put("indexName", fieldMapper.names().indexName()); mapper.put("indexNameClean", fieldMapper.names().indexNameClean()); mapper.put("boost", fieldMapper.boost()); if (fieldMapper.indexAnalyzer() != null) { mapper.put("indexAnalyzer", fieldMapper.indexAnalyzer().toString()); if (fieldMapper.searchAnalyzer() != null) { mapper.put("searchAnalyzer", fieldMapper.searchAnalyzer().toString()); if (fieldMapper.searchQuoteAnalyzer() != null) { mapper.put("searchQuoteAnalyzer", fieldMapper.searchQuoteAnalyzer().toString()); FieldDataType dataType = fieldMapper.fieldDataType(); if (dataType != null) { mapper.put("fieldDataType", dataType.getType()); FieldType type = fieldMapper.fieldType(); if (type != null) { mapper.put("indexed", type.indexed()); SimilarityProvider similarityProvider = fieldMapper.similarity(); if (similarityProvider != null) { mapper.put("similarityPovider", similarityProvider.name());
public MultiFields updateFieldType(Map<String, MappedFieldType> fullNameToFieldType) { ImmutableOpenMap.Builder<String, FieldMapper> newMappersBuilder = null; for (ObjectCursor<FieldMapper> cursor : mappers.values()) { FieldMapper updated = cursor.value.updateFieldType(fullNameToFieldType); if (updated != cursor.value) { if (newMappersBuilder == null) { newMappersBuilder = ImmutableOpenMap.builder(mappers); } newMappersBuilder.put(updated.simpleName(), updated); } } if (newMappersBuilder == null) { return this; } ImmutableOpenMap<String, FieldMapper> mappers = newMappersBuilder.build(); return new MultiFields(mappers); }
@Override protected KeywordFieldMapper clone() { return (KeywordFieldMapper) super.clone(); }
@Override public FieldMapper updateFieldType(Map<String, MappedFieldType> fullNameToFieldType) { BaseGeoPointFieldMapper updated = (BaseGeoPointFieldMapper) super.updateFieldType(fullNameToFieldType); FieldMapper geoUpdated = geoHashMapper == null ? null : geoHashMapper.updateFieldType(fullNameToFieldType); FieldMapper latUpdated = latMapper == null ? null : latMapper.updateFieldType(fullNameToFieldType); FieldMapper lonUpdated = lonMapper == null ? null : lonMapper.updateFieldType(fullNameToFieldType); if (updated == this && geoUpdated == geoHashMapper && latUpdated == latMapper && lonUpdated == lonMapper) { return this; } if (updated == this) { updated = (BaseGeoPointFieldMapper) updated.clone(); } updated.geoHashMapper = geoUpdated; updated.latMapper = latUpdated; updated.lonMapper = lonUpdated; return updated; }
@Override protected void doXContentBody(XContentBuilder builder, boolean includeDefaults, Params params) throws IOException { super.doXContentBody(builder, includeDefaults, params); if (includeDefaults || fieldType().nullValue() != null) { builder.field("null_value", fieldType().nullValue()); } } }
public void parse(FieldMapper mainField, ParseContext context) throws IOException { // TODO: multi fields are really just copy fields, we just need to expose "sub fields" or something that can be part // of the mappings if (mappers.isEmpty()) { return; } context = context.createMultiFieldContext(); context.path().add(mainField.simpleName()); for (ObjectCursor<FieldMapper> cursor : mappers.values()) { cursor.value.parse(context); } context.path().remove(); }
private static void parseObjectOrField(ParseContext context, Mapper mapper) throws IOException { if (mapper instanceof ObjectMapper) { parseObjectOrNested(context, (ObjectMapper) mapper); } else if (mapper instanceof FieldMapper) { FieldMapper fieldMapper = (FieldMapper) mapper; fieldMapper.parse(context); parseCopyFields(context, fieldMapper.copyTo().copyToFields()); } else if (mapper instanceof FieldAliasMapper) { throw new IllegalArgumentException("Cannot write to a field alias [" + mapper.name() + "]."); } else { throw new IllegalStateException("The provided mapper [" + mapper.name() + "] has an unrecognized type [" + mapper.getClass().getSimpleName() + "]."); } }
private LongArrayIndexFieldData getKeyFieldData(final String facetName, final String fieldName, final SearchContext context) { if(fieldName != null) { final FieldMapper<?> mapper = context.smartNameFieldMapper(fieldName); if(mapper == null) { throw new FacetPhaseExecutionException(facetName, "no mapping found for " + fieldName); } if(!"long".equals(mapper.fieldDataType().getType())) { throw new FacetPhaseExecutionException(facetName, "key field " + fieldName + " is not of type long"); } return context.fieldData().getForField(mapper); } else throw new FacetPhaseExecutionException(facetName, "[key_field] is required to be set for date facet"); }
private static void validateCopyTo(List<FieldMapper> fieldMappers, Map<String, ObjectMapper> fullPathObjectMappers, FieldTypeLookup fieldTypes) { for (FieldMapper mapper : fieldMappers) { if (mapper.copyTo() != null && mapper.copyTo().copyToFields().isEmpty() == false) { String sourceParent = parentObject(mapper.name()); if (sourceParent != null && fieldTypes.get(sourceParent) != null) { throw new IllegalArgumentException("[copy_to] may not be used to copy from a multi-field: [" + mapper.name() + "]"); } final String sourceScope = getNestedScope(mapper.name(), fullPathObjectMappers); for (String copyTo : mapper.copyTo().copyToFields()) { String copyToParent = parentObject(copyTo); if (copyToParent != null && fieldTypes.get(copyToParent) != null) { throw new IllegalArgumentException("[copy_to] may not be used to copy to a multi-field: [" + copyTo + "]"); } if (fullPathObjectMappers.containsKey(copyTo)) { throw new IllegalArgumentException("Cannot copy to field [" + copyTo + "] since it is mapped as an object"); } final String targetScope = getNestedScope(copyTo, fullPathObjectMappers); checkNestedScopeCompatibility(sourceScope, targetScope); } } } }
@Override public Iterator<Mapper> iterator() { List<Mapper> subIterators = new ArrayList<>(); if (prefixFieldMapper != null) { subIterators.add(prefixFieldMapper); } if (phraseFieldMapper != null) { subIterators.add(phraseFieldMapper); } if (subIterators.size() == 0) { return super.iterator(); } return Iterators.concat(super.iterator(), subIterators.iterator()); }
if (smartMappers.mapper().fieldDataType() != FieldDataType.DefaultTypes.STRING) { throw new ElasticSearchIllegalArgumentException( "Field [" + fieldName + "] is not of string type, can't run hashed string facet collector on it"); this.indexFieldName = smartMappers.mapper().names().indexName(); this.fieldDataType = smartMappers.mapper().fieldDataType(); this.fieldIndexAnalyzer = smartMappers.mapper().indexAnalyzer(); if (this.fieldIndexAnalyzer == null && smartMappers.docMapper() != null) this.fieldIndexAnalyzer = smartMappers.docMapper().indexAnalyzer();
private Map<String, String> getFieldTypes(DocumentMapper documentMapper) { Map<String, String> fieldNameToDataType = new HashMap<>(); for (FieldMapper<?> fieldMapper : documentMapper.mappers()) { String type; if (fieldMapper instanceof AbstractFieldMapper) { try { type = (String) abstractFieldMapperContentTypeMethod.invoke(fieldMapper); } catch (Exception ex) { throw new RuntimeException("Could not find content type", ex); } } else { type = fieldMapper.fieldDataType().getType(); } fieldNameToDataType.put(fieldMapper.name(), type); } return fieldNameToDataType; } }