Examples with SpanQuery org.apache.lucene.queries.spans.SpanQuery used on opensource projects

Example 11 with SpanQuery

use of org.apache.lucene.queries.spans.SpanQuery in project OpenSearch by opensearch-project.

the class SpanOrQueryBuilderTests method doAssertLuceneQuery.

@Override
protected void doAssertLuceneQuery(SpanOrQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException {
    assertThat(query, instanceOf(SpanOrQuery.class));
    SpanOrQuery spanOrQuery = (SpanOrQuery) query;
    assertThat(spanOrQuery.getClauses().length, equalTo(queryBuilder.clauses().size()));
    Iterator<SpanQueryBuilder> spanQueryBuilderIterator = queryBuilder.clauses().iterator();
    for (SpanQuery spanQuery : spanOrQuery.getClauses()) {
        assertThat(spanQuery, equalTo(spanQueryBuilderIterator.next().toQuery(context)));
    }
}

Example 12 with SpanQuery

use of org.apache.lucene.queries.spans.SpanQuery in project OpenSearch by opensearch-project.

the class SpanMatchNoDocsQueryTests method testQuery.

public void testQuery() throws Exception {
    Directory dir = newDirectory();
    Analyzer analyzer = new MockAnalyzer(random());
    IndexWriter iw = new IndexWriter(dir, newIndexWriterConfig(analyzer).setMaxBufferedDocs(2).setMergePolicy(newLogMergePolicy()));
    addDoc("one", iw);
    addDoc("two", iw);
    addDoc("three", iw);
    IndexReader ir = DirectoryReader.open(iw);
    IndexSearcher searcher = new IndexSearcher(ir);
    Query query = new SpanMatchNoDocsQuery("unknown", "field not found");
    assertEquals(searcher.count(query), 0);
    ScoreDoc[] hits;
    hits = searcher.search(query, 1000).scoreDocs;
    assertEquals(0, hits.length);
    assertEquals(query.toString(), "SpanMatchNoDocsQuery(\"field not found\")");
    SpanOrQuery orQuery = new SpanOrQuery(new SpanMatchNoDocsQuery("unknown", "field not found"), new SpanTermQuery(new Term("unknown", "one")));
    assertEquals(searcher.count(orQuery), 0);
    hits = searcher.search(orQuery, 1000).scoreDocs;
    assertEquals(0, hits.length);
    orQuery = new SpanOrQuery(new SpanMatchNoDocsQuery("key", "a good reason"), new SpanTermQuery(new Term("key", "one")));
    assertEquals(searcher.count(orQuery), 1);
    hits = searcher.search(orQuery, 1000).scoreDocs;
    assertEquals(1, hits.length);
    Query rewrite = orQuery.rewrite(ir);
    assertEquals(rewrite, orQuery);
    SpanNearQuery nearQuery = new SpanNearQuery(new SpanQuery[] { new SpanMatchNoDocsQuery("same", ""), new SpanMatchNoDocsQuery("same", "") }, 0, true);
    assertEquals(searcher.count(nearQuery), 0);
    hits = searcher.search(nearQuery, 1000).scoreDocs;
    assertEquals(0, hits.length);
    rewrite = nearQuery.rewrite(ir);
    assertEquals(rewrite, nearQuery);
    iw.close();
    ir.close();
    dir.close();
}

Example 13 with SpanQuery

use of org.apache.lucene.queries.spans.SpanQuery in project OpenSearch by opensearch-project.

the class MatchQueryBuilderTests method testMultiWordSynonymsPhrase.

public void testMultiWordSynonymsPhrase() throws Exception {
    final MatchQuery matchQuery = new MatchQuery(createShardContext());
    matchQuery.setAnalyzer(new MockSynonymAnalyzer());
    final Query actual = matchQuery.parse(Type.PHRASE, TEXT_FIELD_NAME, "guinea pig dogs");
    Query expected = SpanNearQuery.newOrderedNearQuery(TEXT_FIELD_NAME).addClause(new SpanOrQuery(new SpanQuery[] { SpanNearQuery.newOrderedNearQuery(TEXT_FIELD_NAME).addClause(new SpanTermQuery(new Term(TEXT_FIELD_NAME, "guinea"))).addClause(new SpanTermQuery(new Term(TEXT_FIELD_NAME, "pig"))).setSlop(0).build(), new SpanTermQuery(new Term(TEXT_FIELD_NAME, "cavy")) })).addClause(new SpanOrQuery(new SpanQuery[] { new SpanTermQuery(new Term(TEXT_FIELD_NAME, "dogs")), new SpanTermQuery(new Term(TEXT_FIELD_NAME, "dog")) })).build();
    assertEquals(expected, actual);
}

Example 14 with SpanQuery

use of org.apache.lucene.queries.spans.SpanQuery in project OpenSearch by opensearch-project.

the class SpanNearQueryBuilderTests method doAssertLuceneQuery.

@Override
protected void doAssertLuceneQuery(SpanNearQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException {
    assertThat(query, either(instanceOf(SpanNearQuery.class)).or(instanceOf(SpanTermQuery.class)).or(instanceOf(SpanMatchNoDocsQuery.class)).or(instanceOf(MatchAllQueryBuilder.class)));
    if (query instanceof SpanNearQuery) {
        SpanNearQuery spanNearQuery = (SpanNearQuery) query;
        assertThat(spanNearQuery.getSlop(), equalTo(queryBuilder.slop()));
        assertThat(spanNearQuery.isInOrder(), equalTo(queryBuilder.inOrder()));
        assertThat(spanNearQuery.getClauses().length, equalTo(queryBuilder.clauses().size()));
        Iterator<SpanQueryBuilder> spanQueryBuilderIterator = queryBuilder.clauses().iterator();
        for (SpanQuery spanQuery : spanNearQuery.getClauses()) {
            assertThat(spanQuery, equalTo(spanQueryBuilderIterator.next().toQuery(context)));
        }
    } else if (query instanceof SpanTermQuery) {
        assertThat(queryBuilder.clauses().size(), equalTo(1));
        assertThat(query, equalTo(queryBuilder.clauses().get(0).toQuery(context)));
    }
}

Example 15 with SpanQuery

use of org.apache.lucene.queries.spans.SpanQuery in project OpenSearch by opensearch-project.

the class TextFieldMapper method createPhrasePrefixQuery.

public static Query createPhrasePrefixQuery(TokenStream stream, String field, int slop, int maxExpansions, String prefixField, IntPredicate usePrefixField) throws IOException {
    MultiPhrasePrefixQuery builder = new MultiPhrasePrefixQuery(field);
    builder.setSlop(slop);
    builder.setMaxExpansions(maxExpansions);
    List<Term> currentTerms = new ArrayList<>();
    TermToBytesRefAttribute termAtt = stream.getAttribute(TermToBytesRefAttribute.class);
    PositionIncrementAttribute posIncrAtt = stream.getAttribute(PositionIncrementAttribute.class);
    stream.reset();
    int position = -1;
    while (stream.incrementToken()) {
        if (posIncrAtt.getPositionIncrement() != 0) {
            if (currentTerms.isEmpty() == false) {
                builder.add(currentTerms.toArray(new Term[0]), position);
            }
            position += posIncrAtt.getPositionIncrement();
            currentTerms.clear();
        }
        currentTerms.add(new Term(field, termAtt.getBytesRef()));
    }
    builder.add(currentTerms.toArray(new Term[0]), position);
    if (prefixField == null) {
        return builder;
    }
    int lastPos = builder.getTerms().length - 1;
    final Term[][] terms = builder.getTerms();
    final int[] positions = builder.getPositions();
    for (Term term : terms[lastPos]) {
        String value = term.text();
        if (usePrefixField.test(value.length()) == false) {
            return builder;
        }
    }
    if (terms.length == 1) {
        SynonymQuery.Builder sb = new SynonymQuery.Builder(prefixField);
        Arrays.stream(terms[0]).map(term -> new Term(prefixField, term.bytes())).forEach(sb::addTerm);
        return sb.build();
    }
    SpanNearQuery.Builder spanQuery = new SpanNearQuery.Builder(field, true);
    spanQuery.setSlop(slop);
    int previousPos = -1;
    for (int i = 0; i < terms.length; i++) {
        Term[] posTerms = terms[i];
        int posInc = positions[i] - previousPos;
        previousPos = positions[i];
        if (posInc > 1) {
            spanQuery.addGap(posInc - 1);
        }
        if (i == lastPos) {
            if (posTerms.length == 1) {
                FieldMaskingSpanQuery fieldMask = new FieldMaskingSpanQuery(new SpanTermQuery(new Term(prefixField, posTerms[0].bytes())), field);
                spanQuery.addClause(fieldMask);
            } else {
                SpanQuery[] queries = Arrays.stream(posTerms).map(term -> new FieldMaskingSpanQuery(new SpanTermQuery(new Term(prefixField, term.bytes())), field)).toArray(SpanQuery[]::new);
                spanQuery.addClause(new SpanOrQuery(queries));
            }
        } else {
            if (posTerms.length == 1) {
                spanQuery.addClause(new SpanTermQuery(posTerms[0]));
            } else {
                SpanTermQuery[] queries = Arrays.stream(posTerms).map(SpanTermQuery::new).toArray(SpanTermQuery[]::new);
                spanQuery.addClause(new SpanOrQuery(queries));
            }
        }
    }
    return spanQuery.build();
}