static Analyzer getAnalyzer(DocumentMapper docMapper, MappedFieldType type) { if (type instanceof KeywordFieldMapper.KeywordFieldType) { KeywordFieldMapper.KeywordFieldType keywordFieldType = (KeywordFieldMapper.KeywordFieldType) type; if (keywordFieldType.normalizer() != null) { return keywordFieldType.normalizer(); } } return docMapper.mappers().indexAnalyzer(); } }
public Builder(RootObjectMapper.Builder builder, MapperService mapperService) { final Settings indexSettings = mapperService.getIndexSettings().getSettings(); this.builderContext = new Mapper.BuilderContext(indexSettings, new ContentPath(1)); this.rootObjectMapper = builder.build(builderContext); final String type = rootObjectMapper.name(); final DocumentMapper existingMapper = mapperService.documentMapper(type); final Map<String, TypeParser> metadataMapperParsers = mapperService.mapperRegistry.getMetadataMapperParsers(); for (Map.Entry<String, MetadataFieldMapper.TypeParser> entry : metadataMapperParsers.entrySet()) { final String name = entry.getKey(); final MetadataFieldMapper existingMetadataMapper = existingMapper == null ? null : (MetadataFieldMapper) existingMapper.mappers().getMapper(name); final MetadataFieldMapper metadataMapper; if (existingMetadataMapper == null) { final TypeParser parser = entry.getValue(); metadataMapper = parser.getDefault(mapperService.fullName(name), mapperService.documentMapperParser().parserContext(builder.name())); } else { metadataMapper = existingMetadataMapper; } metadataMappers.put(metadataMapper.getClass(), metadataMapper); } }
this.fieldMappers = new DocumentFieldMappers(newFieldMappers, newFieldAliasMappers, indexAnalyzers.getDefaultIndexAnalyzer(),
public DocumentFieldMappers(Collection<FieldMapper> mappers, Collection<FieldAliasMapper> aliasMappers, Analyzer defaultIndex, Analyzer defaultSearch, Analyzer defaultSearchQuote) { Map<String, Mapper> fieldMappers = new HashMap<>(); Map<String, Analyzer> indexAnalyzers = new HashMap<>(); Map<String, Analyzer> searchAnalyzers = new HashMap<>(); Map<String, Analyzer> searchQuoteAnalyzers = new HashMap<>(); for (FieldMapper mapper : mappers) { fieldMappers.put(mapper.name(), mapper); MappedFieldType fieldType = mapper.fieldType(); put(indexAnalyzers, fieldType.name(), fieldType.indexAnalyzer(), defaultIndex); put(searchAnalyzers, fieldType.name(), fieldType.searchAnalyzer(), defaultSearch); put(searchQuoteAnalyzers, fieldType.name(), fieldType.searchQuoteAnalyzer(), defaultSearchQuote); } for (FieldAliasMapper aliasMapper : aliasMappers) { fieldMappers.put(aliasMapper.name(), aliasMapper); } this.fieldMappers = Collections.unmodifiableMap(fieldMappers); this.indexAnalyzer = new FieldNameAnalyzer(indexAnalyzers); this.searchAnalyzer = new FieldNameAnalyzer(searchAnalyzers); this.searchQuoteAnalyzer = new FieldNameAnalyzer(searchQuoteAnalyzers); }
public static XContentBuilder buildDocument(DocumentMapper documentMapper, Map<String, Object> docMap, boolean humanReadable, boolean forStaticDocument) throws IOException { XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON).humanReadable(true); builder.startObject(); for(String field : docMap.keySet()) { if (field.equals(ParentFieldMapper.NAME)) continue; FieldMapper fieldMapper = documentMapper.mappers().smartNameFieldMapper(field); if (fieldMapper != null) { if (forStaticDocument && !isStaticOrPartitionKey(fieldMapper)) continue; toXContent(builder, fieldMapper, field, docMap.get(field)); } else { ObjectMapper objectMapper = documentMapper.objectMappers().get(field); if (objectMapper != null) { if (forStaticDocument && !isStaticOrPartitionKey(objectMapper)) continue; toXContent(builder, objectMapper, field, docMap.get(field)); } else { Loggers.getLogger(ClusterService.class).error("No mapper found for field "+field); throw new IOException("No mapper found for field "+field); } } } builder.endObject(); return builder; }
/** * Waits till a (pattern) field name mappings concretely exists on all nodes. Note, this waits for the current * started shards and checks for concrete mappings. */ public void assertConcreteMappingsOnAll(final String index, final String type, final String... fieldNames) throws Exception { Set<String> nodes = internalCluster().nodesInclude(index); assertThat(nodes, Matchers.not(Matchers.emptyIterable())); for (String node : nodes) { IndicesService indicesService = internalCluster().getInstance(IndicesService.class, node); IndexService indexService = indicesService.indexService(resolveIndex(index)); assertThat("index service doesn't exists on " + node, indexService, notNullValue()); DocumentMapper documentMapper = indexService.mapperService().documentMapper(type); assertThat("document mapper doesn't exists on " + node, documentMapper, notNullValue()); for (String fieldName : fieldNames) { Collection<String> matches = documentMapper.mappers().simpleMatchToFullName(fieldName); assertThat("field " + fieldName + " doesn't exists on " + node, matches, Matchers.not(emptyIterable())); } } assertMappingOnMaster(index, type, fieldNames); }
public DocumentFieldMappers(Collection<FieldMapper> mappers, Analyzer defaultIndex, Analyzer defaultSearch, Analyzer defaultSearchQuote) { Map<String, FieldMapper> fieldMappers = new HashMap<>(); Map<String, Analyzer> indexAnalyzers = new HashMap<>(); Map<String, Analyzer> searchAnalyzers = new HashMap<>(); Map<String, Analyzer> searchQuoteAnalyzers = new HashMap<>(); for (FieldMapper mapper : mappers) { fieldMappers.put(mapper.name(), mapper); MappedFieldType fieldType = mapper.fieldType(); put(indexAnalyzers, fieldType.name(), fieldType.indexAnalyzer(), defaultIndex); put(searchAnalyzers, fieldType.name(), fieldType.searchAnalyzer(), defaultSearch); put(searchQuoteAnalyzers, fieldType.name(), fieldType.searchQuoteAnalyzer(), defaultSearchQuote); } this.fieldMappers = Collections.unmodifiableMap(fieldMappers); this.indexAnalyzer = new FieldNameAnalyzer(indexAnalyzers); this.searchAnalyzer = new FieldNameAnalyzer(searchAnalyzers); this.searchQuoteAnalyzer = new FieldNameAnalyzer(searchQuoteAnalyzers); }
private FieldMapper getMapperForField(String fieldName, SearchContext searchContext, HitContext hitContext) { DocumentMapper documentMapper = searchContext.mapperService().documentMapper(hitContext.hit().type()); // TODO: no need to lookup the doc mapper with unambiguous field names? just look at the mapper service return documentMapper.mappers().smartNameFieldMapper(fieldName); } }
if (Regex.isSimpleMatchPattern(field.field())) { DocumentMapper documentMapper = context.mapperService().documentMapper(hitContext.hit().type()); fieldNamesToHighlight = documentMapper.mappers().simpleMatchToFullName(field.field()); } else { fieldNamesToHighlight = Collections.singletonList(field.field());
/** Creates an copy of the current field with given field name and boost */ private static void parseCopy(String field, ParseContext context) throws IOException { Mapper mapper = context.docMapper().mappers().getMapper(field); if (mapper != null) { if (mapper instanceof FieldMapper) { ((FieldMapper) mapper).parse(context); } else if (mapper instanceof FieldAliasMapper) { throw new IllegalArgumentException("Cannot copy to a field alias [" + mapper.name() + "]."); } else { throw new IllegalStateException("The provided mapper [" + mapper.name() + "] has an unrecognized type [" + mapper.getClass().getSimpleName() + "]."); } } else { // The path of the dest field might be completely different from the current one so we need to reset it context = context.overridePath(new ContentPath(0)); final String[] paths = splitAndValidatePath(field); final String fieldName = paths[paths.length-1]; Tuple<Integer, ObjectMapper> parentMapperTuple = getDynamicParentMapper(context, paths, null); ObjectMapper objectMapper = parentMapperTuple.v2(); parseDynamicValue(context, objectMapper, fieldName, context.parser().currentToken()); for (int i = 0; i < parentMapperTuple.v1(); i++) { context.path().remove(); } } }
static Analyzer getAnalyzer(DocumentMapper docMapper, MappedFieldType type) { if (type instanceof KeywordFieldMapper.KeywordFieldType) { KeywordFieldMapper.KeywordFieldType keywordFieldType = (KeywordFieldMapper.KeywordFieldType) type; if (keywordFieldType.normalizer() != null) { return keywordFieldType.normalizer(); } } return docMapper.mappers().indexAnalyzer(); } }
public DocumentFieldMappers(Collection<FieldMapper> mappers, Collection<FieldAliasMapper> aliasMappers, Analyzer defaultIndex, Analyzer defaultSearch, Analyzer defaultSearchQuote) { Map<String, Mapper> fieldMappers = new HashMap<>(); Map<String, Analyzer> indexAnalyzers = new HashMap<>(); Map<String, Analyzer> searchAnalyzers = new HashMap<>(); Map<String, Analyzer> searchQuoteAnalyzers = new HashMap<>(); for (FieldMapper mapper : mappers) { fieldMappers.put(mapper.name(), mapper); MappedFieldType fieldType = mapper.fieldType(); put(indexAnalyzers, fieldType.name(), fieldType.indexAnalyzer(), defaultIndex); put(searchAnalyzers, fieldType.name(), fieldType.searchAnalyzer(), defaultSearch); put(searchQuoteAnalyzers, fieldType.name(), fieldType.searchQuoteAnalyzer(), defaultSearchQuote); } for (FieldAliasMapper aliasMapper : aliasMappers) { fieldMappers.put(aliasMapper.name(), aliasMapper); } this.fieldMappers = Collections.unmodifiableMap(fieldMappers); this.indexAnalyzer = new FieldNameAnalyzer(indexAnalyzers); this.searchAnalyzer = new FieldNameAnalyzer(searchAnalyzers); this.searchQuoteAnalyzer = new FieldNameAnalyzer(searchQuoteAnalyzers); }
this.fieldMappers = new DocumentFieldMappers(newFieldMappers, newFieldAliasMappers, indexAnalyzers.getDefaultIndexAnalyzer(),
private FieldMapper getMapperForField(String fieldName, SearchContext searchContext, HitContext hitContext) { DocumentMapper documentMapper = searchContext.mapperService().documentMapper(hitContext.hit().type()); // TODO: no need to lookup the doc mapper with unambiguous field names? just look at the mapper service return documentMapper.mappers().smartNameFieldMapper(fieldName); } }
if (Regex.isSimpleMatchPattern(field.field())) { DocumentMapper documentMapper = context.mapperService().documentMapper(hitContext.hit().type()); fieldNamesToHighlight = documentMapper.mappers().simpleMatchToFullName(field.field()); } else { fieldNamesToHighlight = Collections.singletonList(field.field());
private static Map<String, FieldMappingMetaData> findFieldMappingsByType(Predicate<String> fieldPredicate, DocumentMapper documentMapper, GetFieldMappingsIndexRequest request) { Map<String, FieldMappingMetaData> fieldMappings = new HashMap<>(); final DocumentFieldMappers allFieldMappers = documentMapper.mappers(); for (String field : request.fields()) { if (Regex.isMatchAllPattern(field)) { for (Mapper fieldMapper : allFieldMappers) { addFieldMapper(fieldPredicate, fieldMapper.name(), fieldMapper, fieldMappings, request.includeDefaults()); } } else if (Regex.isSimpleMatchPattern(field)) { for (Mapper fieldMapper : allFieldMappers) { if (Regex.simpleMatch(field, fieldMapper.name())) { addFieldMapper(fieldPredicate, fieldMapper.name(), fieldMapper, fieldMappings, request.includeDefaults()); } } } else { // not a pattern Mapper fieldMapper = allFieldMappers.getMapper(field); if (fieldMapper != null) { addFieldMapper(fieldPredicate, field, fieldMapper, fieldMappings, request.includeDefaults()); } else if (request.probablySingleFieldRequest()) { fieldMappings.put(field, FieldMappingMetaData.NULL); } } } return Collections.unmodifiableMap(fieldMappings); }
private Analyzer findAnalyzer(ParseContext context) { Analyzer analyzer = fieldType().indexAnalyzer(); if (analyzer == null) { analyzer = context.docMapper().mappers().indexAnalyzer(); if (analyzer == null) { // This should not happen, should we log warn it? analyzer = Lucene.STANDARD_ANALYZER; } } return analyzer; }
public DocumentFieldMappers(Collection<FieldMapper> mappers, Analyzer defaultIndex, Analyzer defaultSearch, Analyzer defaultSearchQuote) { Map<String, FieldMapper> fieldMappers = new HashMap<>(); Map<String, Analyzer> indexAnalyzers = new HashMap<>(); Map<String, Analyzer> searchAnalyzers = new HashMap<>(); Map<String, Analyzer> searchQuoteAnalyzers = new HashMap<>(); for (FieldMapper mapper : mappers) { fieldMappers.put(mapper.name(), mapper); MappedFieldType fieldType = mapper.fieldType(); put(indexAnalyzers, fieldType.names().indexName(), fieldType.indexAnalyzer(), defaultIndex); put(searchAnalyzers, fieldType.names().indexName(), fieldType.searchAnalyzer(), defaultSearch); put(searchQuoteAnalyzers, fieldType.names().indexName(), fieldType.searchQuoteAnalyzer(), defaultSearchQuote); } this.fieldMappers = Collections.unmodifiableMap(fieldMappers); this.indexAnalyzer = new FieldNameAnalyzer(indexAnalyzers); this.searchAnalyzer = new FieldNameAnalyzer(searchAnalyzers); this.searchQuoteAnalyzer = new FieldNameAnalyzer(searchQuoteAnalyzers); }
this.fieldMappers = new DocumentFieldMappers(newFieldMappers, indexAnalyzers.getDefaultIndexAnalyzer(), indexAnalyzers.getDefaultSearchAnalyzer(),
DocumentMapper docMapper = indexInfo.indexService.mapperService().documentMapper(typeName); Mapper mapper = fields[i].startsWith(ParentFieldMapper.NAME) ? docMapper.parentFieldMapper() : docMapper.mappers().smartNameFieldMapper(fields[i]); // workaround for _parent#<join_type> if (mapper != null) { indexInfo.mappers[i] = mapper;