Examples with Mapper org.opensearch.index.mapper.Mapper used on opensource projects

Example 1 with Mapper

use of org.opensearch.index.mapper.Mapper in project OpenSearch by opensearch-project.

the class TransportGetFieldMappingsIndexAction method findFieldMappingsByType.

private static Map<String, FieldMappingMetadata> findFieldMappingsByType(Predicate<String> fieldPredicate, DocumentMapper documentMapper, GetFieldMappingsIndexRequest request) {
    Map<String, FieldMappingMetadata> fieldMappings = new HashMap<>();
    final MappingLookup 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);
}

Example 2 with Mapper

use of org.opensearch.index.mapper.Mapper in project OpenSearch by opensearch-project.

the class CategoryContextMappingTests method testIndexingWithContextList.

public void testIndexingWithContextList() throws Exception {
    String mapping = Strings.toString(jsonBuilder().startObject().startObject("type1").startObject("properties").startObject("completion").field("type", "completion").startArray("contexts").startObject().field("name", "ctx").field("type", "category").endObject().endArray().endObject().endObject().endObject().endObject());
    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type1", new CompressedXContent(mapping));
    Mapper fieldMapper = defaultMapper.mappers().getMapper("completion");
    ParsedDocument parsedDocument = defaultMapper.parse(new SourceToParse("test", "type1", "1", BytesReference.bytes(jsonBuilder().startObject().startObject("completion").array("input", "suggestion5", "suggestion6", "suggestion7").startObject("contexts").array("ctx", "ctx1", "ctx2", "ctx3").endObject().field("weight", 5).endObject().endObject()), XContentType.JSON));
    IndexableField[] fields = parsedDocument.rootDoc().getFields(fieldMapper.name());
    assertContextSuggestFields(fields, 3);
}

Example 3 with Mapper

use of org.opensearch.index.mapper.Mapper in project OpenSearch by opensearch-project.

the class CategoryContextMappingTests method testIndexingWithSimpleContexts.

public void testIndexingWithSimpleContexts() throws Exception {
    String mapping = Strings.toString(jsonBuilder().startObject().startObject("type1").startObject("properties").startObject("completion").field("type", "completion").startArray("contexts").startObject().field("name", "ctx").field("type", "category").endObject().endArray().endObject().endObject().endObject().endObject());
    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type1", new CompressedXContent(mapping));
    Mapper fieldMapper = defaultMapper.mappers().getMapper("completion");
    ParsedDocument parsedDocument = defaultMapper.parse(new SourceToParse("test", "type1", "1", BytesReference.bytes(jsonBuilder().startObject().startArray("completion").startObject().array("input", "suggestion5", "suggestion6", "suggestion7").startObject("contexts").field("ctx", "ctx1").endObject().field("weight", 5).endObject().endArray().endObject()), XContentType.JSON));
    IndexableField[] fields = parsedDocument.rootDoc().getFields(fieldMapper.name());
    assertContextSuggestFields(fields, 3);
}

Example 4 with Mapper

use of org.opensearch.index.mapper.Mapper in project OpenSearch by opensearch-project.

the class AggregatorTestCase method testSupportedFieldTypes.

/**
 * This test will validate that an aggregator succeeds or fails to run against all the field types
 * that are registered in {@link IndicesModule} (e.g. all the core field types).  An aggregator
 * is provided by the implementor class, and it is executed against each field type in turn.  If
 * an exception is thrown when the field is supported, that will fail the test.  Similarly, if
 * an exception _is not_ thrown when a field is unsupported, that will also fail the test.
 *
 * Exception types/messages are not currently checked, just presence/absence of an exception.
 */
public void testSupportedFieldTypes() throws IOException {
    MapperRegistry mapperRegistry = new IndicesModule(Collections.emptyList()).getMapperRegistry();
    Settings settings = Settings.builder().put("index.version.created", Version.CURRENT.id).build();
    String fieldName = "typeTestFieldName";
    List<ValuesSourceType> supportedVSTypes = getSupportedValuesSourceTypes();
    List<String> unsupportedMappedFieldTypes = unsupportedMappedFieldTypes();
    if (supportedVSTypes.isEmpty()) {
        // If the test says it doesn't support any VStypes, it has not been converted yet so skip
        return;
    }
    for (Map.Entry<String, Mapper.TypeParser> mappedType : mapperRegistry.getMapperParsers().entrySet()) {
        // Some field types should not be tested, or require more work and are not ready yet
        if (TYPE_TEST_DENYLIST.contains(mappedType.getKey())) {
            continue;
        }
        Map<String, Object> source = new HashMap<>();
        source.put("type", mappedType.getKey());
        // Text is the only field that doesn't support DVs, instead FD
        if (mappedType.getKey().equals(TextFieldMapper.CONTENT_TYPE) == false) {
            source.put("doc_values", "true");
        }
        Mapper.Builder builder = mappedType.getValue().parse(fieldName, source, new MockParserContext());
        FieldMapper mapper = (FieldMapper) builder.build(new BuilderContext(settings, new ContentPath()));
        MappedFieldType fieldType = mapper.fieldType();
        // Non-aggregatable fields are not testable (they will throw an error on all aggs anyway), so skip
        if (fieldType.isAggregatable() == false) {
            continue;
        }
        try (Directory directory = newDirectory()) {
            RandomIndexWriter indexWriter = new RandomIndexWriter(random(), directory);
            writeTestDoc(fieldType, fieldName, indexWriter);
            indexWriter.close();
            try (IndexReader indexReader = DirectoryReader.open(directory)) {
                IndexSearcher indexSearcher = newIndexSearcher(indexReader);
                AggregationBuilder aggregationBuilder = createAggBuilderForTypeTest(fieldType, fieldName);
                ValuesSourceType vst = fieldToVST(fieldType);
                // TODO in the future we can make this more explicit with expectThrows(), when the exceptions are standardized
                AssertionError failure = null;
                try {
                    searchAndReduce(indexSearcher, new MatchAllDocsQuery(), aggregationBuilder, fieldType);
                    if (supportedVSTypes.contains(vst) == false || unsupportedMappedFieldTypes.contains(fieldType.typeName())) {
                        failure = new AssertionError("Aggregator [" + aggregationBuilder.getType() + "] should not support field type [" + fieldType.typeName() + "] but executing against the field did not throw an exception");
                    }
                } catch (Exception | AssertionError e) {
                    if (supportedVSTypes.contains(vst) && unsupportedMappedFieldTypes.contains(fieldType.typeName()) == false) {
                        failure = new AssertionError("Aggregator [" + aggregationBuilder.getType() + "] supports field type [" + fieldType.typeName() + "] but executing against the field threw an exception: [" + e.getMessage() + "]", e);
                    }
                }
                if (failure != null) {
                    throw failure;
                }
            }
        }
    }
}

Example 5 with Mapper

use of org.opensearch.index.mapper.Mapper in project OpenSearch by opensearch-project.

the class TransportGetFieldMappingsIndexAction method shardOperation.

@Override
protected GetFieldMappingsResponse shardOperation(final GetFieldMappingsIndexRequest request, ShardId shardId) {
    assert shardId != null;
    IndexService indexService = indicesService.indexServiceSafe(shardId.getIndex());
    Version indexCreatedVersion = indexService.mapperService().getIndexSettings().getIndexVersionCreated();
    Predicate<String> metadataFieldPredicate = (f) -> indicesService.isMetadataField(indexCreatedVersion, f);
    Predicate<String> fieldPredicate = metadataFieldPredicate.or(indicesService.getFieldFilter().apply(shardId.getIndexName()));
    DocumentMapper mapper = indexService.mapperService().documentMapper();
    Collection<String> typeIntersection;
    if (request.types().length == 0) {
        typeIntersection = mapper == null ? Collections.emptySet() : Collections.singleton(mapper.type());
    } else {
        typeIntersection = mapper != null && Regex.simpleMatch(request.types(), mapper.type()) ? Collections.singleton(mapper.type()) : Collections.emptySet();
        if (typeIntersection.isEmpty()) {
            throw new TypeMissingException(shardId.getIndex(), request.types());
        }
    }
    Map<String, Map<String, FieldMappingMetadata>> typeMappings = new HashMap<>();
    for (String type : typeIntersection) {
        DocumentMapper documentMapper = indexService.mapperService().documentMapper(type);
        Map<String, FieldMappingMetadata> fieldMapping = findFieldMappingsByType(fieldPredicate, documentMapper, request);
        if (!fieldMapping.isEmpty()) {
            typeMappings.put(type, fieldMapping);
        }
    }
    return new GetFieldMappingsResponse(singletonMap(shardId.getIndexName(), Collections.unmodifiableMap(typeMappings)));
}