Examples with Version org.opensearch.Version used on opensource projects

Example 6 with Version

use of org.opensearch.Version in project OpenSearch by opensearch-project.

the class CandidateQueryTests method testRangeQueries.

public void testRangeQueries() throws Exception {
    List<ParseContext.Document> docs = new ArrayList<>();
    addQuery(IntPoint.newRangeQuery("int_field", 0, 5), docs);
    addQuery(LongPoint.newRangeQuery("long_field", 5L, 10L), docs);
    addQuery(HalfFloatPoint.newRangeQuery("half_float_field", 10, 15), docs);
    addQuery(FloatPoint.newRangeQuery("float_field", 15, 20), docs);
    addQuery(DoublePoint.newRangeQuery("double_field", 20, 25), docs);
    addQuery(InetAddressPoint.newRangeQuery("ip_field", forString("192.168.0.1"), forString("192.168.0.10")), docs);
    indexWriter.addDocuments(docs);
    indexWriter.close();
    directoryReader = DirectoryReader.open(directory);
    IndexSearcher shardSearcher = newSearcher(directoryReader);
    shardSearcher.setQueryCache(null);
    Version v = VersionUtils.randomIndexCompatibleVersion(random());
    MemoryIndex memoryIndex = MemoryIndex.fromDocument(Collections.singleton(new IntPoint("int_field", 3)), new WhitespaceAnalyzer());
    IndexSearcher percolateSearcher = memoryIndex.createSearcher();
    Query query = fieldType.percolateQuery("_name", queryStore, Collections.singletonList(new BytesArray("{}")), percolateSearcher, false, v);
    TopDocs topDocs = shardSearcher.search(query, 1);
    assertEquals(1L, topDocs.totalHits.value);
    assertEquals(1, topDocs.scoreDocs.length);
    assertEquals(0, topDocs.scoreDocs[0].doc);
    memoryIndex = MemoryIndex.fromDocument(Collections.singleton(new LongPoint("long_field", 7L)), new WhitespaceAnalyzer());
    percolateSearcher = memoryIndex.createSearcher();
    query = fieldType.percolateQuery("_name", queryStore, Collections.singletonList(new BytesArray("{}")), percolateSearcher, false, v);
    topDocs = shardSearcher.search(query, 1);
    assertEquals(1L, topDocs.totalHits.value);
    assertEquals(1, topDocs.scoreDocs.length);
    assertEquals(1, topDocs.scoreDocs[0].doc);
    memoryIndex = MemoryIndex.fromDocument(Collections.singleton(new HalfFloatPoint("half_float_field", 12)), new WhitespaceAnalyzer());
    percolateSearcher = memoryIndex.createSearcher();
    query = fieldType.percolateQuery("_name", queryStore, Collections.singletonList(new BytesArray("{}")), percolateSearcher, false, v);
    topDocs = shardSearcher.search(query, 1);
    assertEquals(1L, topDocs.totalHits.value);
    assertEquals(1, topDocs.scoreDocs.length);
    assertEquals(2, topDocs.scoreDocs[0].doc);
    memoryIndex = MemoryIndex.fromDocument(Collections.singleton(new FloatPoint("float_field", 17)), new WhitespaceAnalyzer());
    percolateSearcher = memoryIndex.createSearcher();
    query = fieldType.percolateQuery("_name", queryStore, Collections.singletonList(new BytesArray("{}")), percolateSearcher, false, v);
    topDocs = shardSearcher.search(query, 1);
    assertEquals(1, topDocs.totalHits.value);
    assertEquals(1, topDocs.scoreDocs.length);
    assertEquals(3, topDocs.scoreDocs[0].doc);
    memoryIndex = MemoryIndex.fromDocument(Collections.singleton(new DoublePoint("double_field", 21)), new WhitespaceAnalyzer());
    percolateSearcher = memoryIndex.createSearcher();
    query = fieldType.percolateQuery("_name", queryStore, Collections.singletonList(new BytesArray("{}")), percolateSearcher, false, v);
    topDocs = shardSearcher.search(query, 1);
    assertEquals(1, topDocs.totalHits.value);
    assertEquals(1, topDocs.scoreDocs.length);
    assertEquals(4, topDocs.scoreDocs[0].doc);
    memoryIndex = MemoryIndex.fromDocument(Collections.singleton(new InetAddressPoint("ip_field", forString("192.168.0.4"))), new WhitespaceAnalyzer());
    percolateSearcher = memoryIndex.createSearcher();
    query = fieldType.percolateQuery("_name", queryStore, Collections.singletonList(new BytesArray("{}")), percolateSearcher, false, v);
    topDocs = shardSearcher.search(query, 1);
    assertEquals(1, topDocs.totalHits.value);
    assertEquals(1, topDocs.scoreDocs.length);
    assertEquals(5, topDocs.scoreDocs[0].doc);
}

Example 7 with Version

use of org.opensearch.Version in project OpenSearch by opensearch-project.

the class QueryBuilderStoreTests method testStoringQueryBuilders.

public void testStoringQueryBuilders() throws IOException {
    try (Directory directory = newDirectory()) {
        TermQueryBuilder[] queryBuilders = new TermQueryBuilder[randomIntBetween(1, 16)];
        IndexWriterConfig config = new IndexWriterConfig(new WhitespaceAnalyzer());
        config.setMergePolicy(NoMergePolicy.INSTANCE);
        Settings settings = Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT).build();
        BinaryFieldMapper fieldMapper = PercolatorFieldMapper.Builder.createQueryBuilderFieldBuilder(new Mapper.BuilderContext(settings, new ContentPath(0)));
        Version version = Version.CURRENT;
        try (IndexWriter indexWriter = new IndexWriter(directory, config)) {
            for (int i = 0; i < queryBuilders.length; i++) {
                queryBuilders[i] = new TermQueryBuilder(randomAlphaOfLength(4), randomAlphaOfLength(8));
                ParseContext parseContext = mock(ParseContext.class);
                ParseContext.Document document = new ParseContext.Document();
                when(parseContext.doc()).thenReturn(document);
                PercolatorFieldMapper.createQueryBuilderField(version, fieldMapper, queryBuilders[i], parseContext);
                indexWriter.addDocument(document);
            }
        }
        QueryShardContext queryShardContext = mock(QueryShardContext.class);
        when(queryShardContext.indexVersionCreated()).thenReturn(version);
        when(queryShardContext.getWriteableRegistry()).thenReturn(writableRegistry());
        when(queryShardContext.getXContentRegistry()).thenReturn(xContentRegistry());
        when(queryShardContext.getForField(fieldMapper.fieldType())).thenReturn(new BytesBinaryIndexFieldData(fieldMapper.name(), CoreValuesSourceType.BYTES));
        when(queryShardContext.fieldMapper(Mockito.anyString())).thenAnswer(invocation -> {
            final String fieldName = (String) invocation.getArguments()[0];
            return new KeywordFieldMapper.KeywordFieldType(fieldName);
        });
        PercolateQuery.QueryStore queryStore = PercolateQueryBuilder.createStore(fieldMapper.fieldType(), queryShardContext);
        try (IndexReader indexReader = DirectoryReader.open(directory)) {
            LeafReaderContext leafContext = indexReader.leaves().get(0);
            CheckedFunction<Integer, Query, IOException> queries = queryStore.getQueries(leafContext);
            assertEquals(queryBuilders.length, leafContext.reader().numDocs());
            for (int i = 0; i < queryBuilders.length; i++) {
                TermQuery query = (TermQuery) queries.apply(i);
                assertEquals(queryBuilders[i].fieldName(), query.getTerm().field());
                assertEquals(queryBuilders[i].value(), query.getTerm().text());
            }
        }
    }
}

Example 8 with Version

use of org.opensearch.Version in project OpenSearch by opensearch-project.

the class PercolatorFieldMapper method processQuery.

void processQuery(Query query, ParseContext context) {
    ParseContext.Document doc = context.doc();
    PercolatorFieldType pft = (PercolatorFieldType) this.fieldType();
    QueryAnalyzer.Result result;
    Version indexVersion = context.mapperService().getIndexSettings().getIndexVersionCreated();
    result = QueryAnalyzer.analyze(query, indexVersion);
    if (result == QueryAnalyzer.Result.UNKNOWN) {
        doc.add(new Field(pft.extractionResultField.name(), EXTRACTION_FAILED, INDEXED_KEYWORD));
        return;
    }
    for (QueryAnalyzer.QueryExtraction extraction : result.extractions) {
        if (extraction.term != null) {
            BytesRefBuilder builder = new BytesRefBuilder();
            builder.append(new BytesRef(extraction.field()));
            builder.append(FIELD_VALUE_SEPARATOR);
            builder.append(extraction.bytes());
            doc.add(new Field(queryTermsField.name(), builder.toBytesRef(), INDEXED_KEYWORD));
        } else if (extraction.range != null) {
            byte[] min = extraction.range.lowerPoint;
            byte[] max = extraction.range.upperPoint;
            doc.add(new BinaryRange(rangeFieldMapper.name(), encodeRange(extraction.range.fieldName, min, max)));
        }
    }
    if (result.matchAllDocs) {
        doc.add(new Field(extractionResultField.name(), EXTRACTION_FAILED, INDEXED_KEYWORD));
        if (result.verified) {
            doc.add(new Field(extractionResultField.name(), EXTRACTION_COMPLETE, INDEXED_KEYWORD));
        }
    } else if (result.verified) {
        doc.add(new Field(extractionResultField.name(), EXTRACTION_COMPLETE, INDEXED_KEYWORD));
    } else {
        doc.add(new Field(extractionResultField.name(), EXTRACTION_PARTIAL, INDEXED_KEYWORD));
    }
    createFieldNamesField(context);
    doc.add(new NumericDocValuesField(minimumShouldMatchFieldMapper.name(), result.minimumShouldMatch));
}

Example 9 with Version

use of org.opensearch.Version in project OpenSearch by opensearch-project.

the class RecoveryIT method testRecoveryClosedIndex.

/**
 * This test creates an index in the non upgraded cluster and closes it. It then checks that the index
 * is effectively closed and potentially replicated (if the version the index was created on supports
 * the replication of closed indices) during the rolling upgrade.
 */
public void testRecoveryClosedIndex() throws Exception {
    final String indexName = "closed_index_created_on_old";
    if (CLUSTER_TYPE == ClusterType.OLD) {
        createIndex(indexName, Settings.builder().put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 1).put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), 1).put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "100ms").put(SETTING_ALLOCATION_MAX_RETRY.getKey(), // fail faster
        "0").build());
        ensureGreen(indexName);
        closeIndex(indexName);
    }
    final Version indexVersionCreated = indexVersionCreated(indexName);
    if (indexVersionCreated.onOrAfter(LegacyESVersion.V_7_2_0)) {
        // index was created on a version that supports the replication of closed indices,
        // so we expect the index to be closed and replicated
        ensureGreen(indexName);
        assertClosedIndex(indexName, true);
    } else {
        assertClosedIndex(indexName, false);
    }
}

Example 10 with Version

use of org.opensearch.Version in project OpenSearch by opensearch-project.

the class RecoveryIT method testAutoExpandIndicesDuringRollingUpgrade.

public void testAutoExpandIndicesDuringRollingUpgrade() throws Exception {
    final String indexName = "test-auto-expand-filtering";
    final Version minimumNodeVersion = minimumNodeVersion();
    Response response = client().performRequest(new Request("GET", "_nodes"));
    ObjectPath objectPath = ObjectPath.createFromResponse(response);
    final Map<String, Object> nodeMap = objectPath.evaluate("nodes");
    List<String> nodes = new ArrayList<>(nodeMap.keySet());
    if (CLUSTER_TYPE == ClusterType.OLD) {
        createIndex(indexName, Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, randomInt(2)).put(IndexMetadata.SETTING_AUTO_EXPAND_REPLICAS, "0-all").build());
        ensureGreen(indexName);
        updateIndexSettings(indexName, Settings.builder().put(IndexMetadata.INDEX_ROUTING_EXCLUDE_GROUP_PREFIX + "._id", nodes.get(randomInt(2))));
    }
    final int numberOfReplicas = Integer.parseInt(getIndexSettingsAsMap(indexName).get(IndexMetadata.SETTING_NUMBER_OF_REPLICAS).toString());
    if (minimumNodeVersion.onOrAfter(LegacyESVersion.V_7_6_0)) {
        assertEquals(nodes.size() - 2, numberOfReplicas);
        ensureGreen(indexName);
    } else {
        assertEquals(nodes.size() - 1, numberOfReplicas);
    }
}