@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { if (indexCreatedBefore2x == false) { return builder; } boolean includeDefaults = params.paramAsBoolean("include_defaults", false); // if all are defaults, no sense to write it at all if (!includeDefaults && fieldType().stored() == Defaults.FIELD_TYPE.stored() && fieldType().indexOptions() == Defaults.FIELD_TYPE.indexOptions() && path == Defaults.PATH && hasCustomFieldDataSettings() == false) { return builder; } builder.startObject(CONTENT_TYPE); if (includeDefaults || fieldType().stored() != Defaults.FIELD_TYPE.stored()) { builder.field("store", fieldType().stored()); } if (includeDefaults || fieldType().indexOptions() != Defaults.FIELD_TYPE.indexOptions()) { builder.field( "index", indexTokenizeOptionToString( fieldType().indexOptions() != IndexOptions.NONE, fieldType().tokenized())); } if (includeDefaults || path != Defaults.PATH) { builder.field("path", path); } if (includeDefaults || hasCustomFieldDataSettings()) { builder.field("fielddata", (Map) fieldType().fieldDataType().getSettings().getAsMap()); } builder.endObject(); return builder; }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { boolean includeDefaults = params.paramAsBoolean("include_defaults", false); // if all are defaults, no sense to write it at all boolean indexed = fieldType.indexOptions() != IndexOptions.NONE; boolean indexedDefault = Defaults.FIELD_TYPE.indexOptions() != IndexOptions.NONE; if (!includeDefaults && indexed == indexedDefault && fieldType.stored() == Defaults.FIELD_TYPE.stored() && required == Defaults.REQUIRED && path == Defaults.PATH) { return builder; } builder.startObject(CONTENT_TYPE); if (indexCreatedBefore2x && (includeDefaults || indexed != indexedDefault)) { builder.field("index", indexTokenizeOptionToString(indexed, fieldType.tokenized())); } if (indexCreatedBefore2x && (includeDefaults || fieldType.stored() != Defaults.FIELD_TYPE.stored())) { builder.field("store", fieldType.stored()); } if (includeDefaults || required != Defaults.REQUIRED) { builder.field("required", required); } if (indexCreatedBefore2x && (includeDefaults || path != Defaults.PATH)) { builder.field("path", path); } builder.endObject(); return builder; }
private ParentFieldMapper(Settings indexSettings, MappedFieldType existing, String parentType) { this( existing == null ? Defaults.FIELD_TYPE.clone() : existing.clone(), joinFieldTypeForParentType(parentType, indexSettings), null, null, indexSettings); }
private static MappedFieldType idFieldType(Settings indexSettings, MappedFieldType existing) { if (existing != null) { return existing.clone(); } MappedFieldType fieldType = Defaults.FIELD_TYPE.clone(); boolean pre2x = Version.indexCreated(indexSettings).before(Version.V_2_0_0_beta1); if (pre2x && indexSettings.getAsBoolean("index.mapping._id.indexed", true) == false) { fieldType.setTokenized(false); } return fieldType; }
private static MappedFieldType defaultFieldType(Settings indexSettings) { MappedFieldType defaultFieldType = Defaults.FIELD_TYPE.clone(); Version indexCreated = Version.indexCreated(indexSettings); if (indexCreated.before(Version.V_2_1_0)) { // enables fielddata loading, doc values was disabled on _type between 2.0 and 2.1. ((TypeFieldType) defaultFieldType).setFielddata(true); } else { defaultFieldType.setHasDocValues(true); } return defaultFieldType; }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { boolean includeDefaults = params.paramAsBoolean("include_defaults", false); // if all are defaults, no sense to write it at all if (!includeDefaults && fieldType.stored() == Defaults.FIELD_TYPE.stored() && fieldType.indexed() == Defaults.FIELD_TYPE.indexed()) { return builder; } builder.startObject(CONTENT_TYPE); if (includeDefaults || fieldType.stored() != Defaults.FIELD_TYPE.stored()) { builder.field("store", fieldType.stored()); } if (includeDefaults || fieldType.indexed() != Defaults.FIELD_TYPE.indexed()) { builder.field( "index", indexTokenizeOptionToString(fieldType.indexed(), fieldType.tokenized())); } builder.endObject(); return builder; }
private FieldNamesFieldMapper(Settings indexSettings, MappedFieldType existing) { this(existing == null ? Defaults.FIELD_TYPE.clone() : existing.clone(), indexSettings); }
public FieldNamesFieldMapper(Settings indexSettings) { this(Defaults.FIELD_TYPE.clone(), null, indexSettings); }
private void innerToXContent(XContentBuilder builder, boolean includeDefaults) throws IOException { if (includeDefaults || enabled != Defaults.ENABLED) { builder.field("enabled", enabled); } if (includeDefaults || autoBoost != false) { builder.field("auto_boost", autoBoost); } if (includeDefaults || fieldType.stored() != Defaults.FIELD_TYPE.stored()) { builder.field("store", fieldType.stored()); } if (includeDefaults || fieldType.storeTermVectors() != Defaults.FIELD_TYPE.storeTermVectors()) { builder.field("store_term_vectors", fieldType.storeTermVectors()); } if (includeDefaults || fieldType.storeTermVectorOffsets() != Defaults.FIELD_TYPE.storeTermVectorOffsets()) { builder.field("store_term_vector_offsets", fieldType.storeTermVectorOffsets()); } if (includeDefaults || fieldType.storeTermVectorPositions() != Defaults.FIELD_TYPE.storeTermVectorPositions()) { builder.field("store_term_vector_positions", fieldType.storeTermVectorPositions()); } if (includeDefaults || fieldType.storeTermVectorPayloads() != Defaults.FIELD_TYPE.storeTermVectorPayloads()) { builder.field("store_term_vector_payloads", fieldType.storeTermVectorPayloads()); } if (includeDefaults || fieldType.omitNorms() != Defaults.FIELD_TYPE.omitNorms()) { builder.field("omit_norms", fieldType.omitNorms()); } if (indexAnalyzer == null && searchAnalyzer == null) { if (includeDefaults) { builder.field("analyzer", "default"); } } else if (indexAnalyzer == null) { // searchAnalyzer != null if (includeDefaults || !searchAnalyzer.name().startsWith("_")) { builder.field("search_analyzer", searchAnalyzer.name()); } } else if (searchAnalyzer == null) { // indexAnalyzer != null if (includeDefaults || !indexAnalyzer.name().startsWith("_")) { builder.field("index_analyzer", indexAnalyzer.name()); } } else if (indexAnalyzer.name().equals(searchAnalyzer.name())) { // indexAnalyzer == searchAnalyzer if (includeDefaults || !indexAnalyzer.name().startsWith("_")) { builder.field("analyzer", indexAnalyzer.name()); } } else { // both are there but different if (includeDefaults || !indexAnalyzer.name().startsWith("_")) { builder.field("index_analyzer", indexAnalyzer.name()); } if (includeDefaults || !searchAnalyzer.name().startsWith("_")) { builder.field("search_analyzer", searchAnalyzer.name()); } } if (similarity() != null) { builder.field("similarity", similarity().name()); } else if (includeDefaults) { builder.field("similarity", SimilarityLookupService.DEFAULT_SIMILARITY); } if (customFieldDataSettings != null) { builder.field("fielddata", (Map) customFieldDataSettings.getAsMap()); } else if (includeDefaults) { builder.field("fielddata", (Map) fieldDataType.getSettings().getAsMap()); } }
@Override public AttachmentMapper build(BuilderContext context) { ContentPath.Type origPathType = context.path().pathType(); context.path().pathType(pathType); FieldMapper contentMapper; if (context.indexCreatedVersion().before(Version.V_2_0_0_beta1)) { // old behavior, we need the content to be indexed under the attachment field name if (contentBuilder instanceof FieldMapper.Builder == false) { throw new IllegalStateException("content field for attachment must be a field mapper"); } ((FieldMapper.Builder) contentBuilder).indexName(name); contentBuilder.name = name + "." + FieldNames.CONTENT; contentMapper = (FieldMapper) contentBuilder.build(context); context.path().add(name); } else { context.path().add(name); contentMapper = (FieldMapper) contentBuilder.build(context); } FieldMapper dateMapper = (FieldMapper) dateBuilder.build(context); FieldMapper authorMapper = (FieldMapper) authorBuilder.build(context); FieldMapper titleMapper = (FieldMapper) titleBuilder.build(context); FieldMapper nameMapper = (FieldMapper) nameBuilder.build(context); FieldMapper keywordsMapper = (FieldMapper) keywordsBuilder.build(context); FieldMapper contentTypeMapper = (FieldMapper) contentTypeBuilder.build(context); FieldMapper contentLength = (FieldMapper) contentLengthBuilder.build(context); FieldMapper language = (FieldMapper) languageBuilder.build(context); context.path().remove(); context.path().pathType(origPathType); if (defaultIndexedChars == null && context.indexSettings() != null) { defaultIndexedChars = context.indexSettings().getAsInt("index.mapping.attachment.indexed_chars", 100000); } if (defaultIndexedChars == null) { defaultIndexedChars = 100000; } if (ignoreErrors == null && context.indexSettings() != null) { ignoreErrors = context .indexSettings() .getAsBoolean("index.mapping.attachment.ignore_errors", Boolean.TRUE); } if (ignoreErrors == null) { ignoreErrors = Boolean.TRUE; } if (langDetect == null && context.indexSettings() != null) { langDetect = context .indexSettings() .getAsBoolean("index.mapping.attachment.detect_language", Boolean.FALSE); } if (langDetect == null) { langDetect = Boolean.FALSE; } MappedFieldType defaultFieldType = Defaults.FIELD_TYPE.clone(); if (this.fieldType.indexOptions() != IndexOptions.NONE && !this.fieldType.tokenized()) { defaultFieldType.setOmitNorms(true); defaultFieldType.setIndexOptions(IndexOptions.DOCS); if (!this.omitNormsSet && this.fieldType.boost() == 1.0F) { this.fieldType.setOmitNorms(true); } if (!this.indexOptionsSet) { this.fieldType.setIndexOptions(IndexOptions.DOCS); } } defaultFieldType.freeze(); this.setupFieldType(context); return new AttachmentMapper( name, fieldType, defaultFieldType, pathType, defaultIndexedChars, ignoreErrors, langDetect, contentMapper, dateMapper, titleMapper, nameMapper, authorMapper, keywordsMapper, contentTypeMapper, contentLength, language, context.indexSettings(), multiFieldsBuilder.build(this, context), copyTo); }