Example usage for org.apache.lucene.index.memory MemoryIndex createSearcher

Introduction

In this page you can find the example usage for org.apache.lucene.index.memory MemoryIndex createSearcher.

Prototype

public IndexSearcher createSearcher() 

Source Link

Document

Creates and returns a searcher that can be used to execute arbitrary Lucene queries and to collect the resulting query results as hits.

Usage

From source file:org.elasticsearch.index.query.PercolatorQueryBuilder.java

License:Apache License

@Override
protected Query doToQuery(QueryShardContext context) throws IOException {
    if (indexedDocumentIndex != null || indexedDocumentType != null || indexedDocumentId != null) {
        throw new IllegalStateException("query builder must be rewritten first");
    }// w  w w.  j av a2  s .  c  o m

    if (document == null) {
        throw new IllegalStateException("nothing to percolator");
    }

    MapperService mapperService = context.getMapperService();
    DocumentMapperForType docMapperForType = mapperService.documentMapperWithAutoCreate(documentType);
    DocumentMapper docMapper = docMapperForType.getDocumentMapper();

    ParsedDocument doc = docMapper
            .parse(source(document).index(context.index().getName()).id("_temp_id").type(documentType));

    Analyzer defaultAnalyzer = context.getAnalysisService().defaultIndexAnalyzer();
    final IndexSearcher docSearcher;
    if (doc.docs().size() > 1) {
        assert docMapper.hasNestedObjects();
        docSearcher = createMultiDocumentSearcher(docMapper, defaultAnalyzer, doc);
    } else {
        // TODO: we may want to bring to MemoryIndex thread local cache back...
        // but I'm unsure about the real benefits.
        MemoryIndex memoryIndex = new MemoryIndex(true);
        indexDoc(docMapper, defaultAnalyzer, doc.rootDoc(), memoryIndex);
        docSearcher = memoryIndex.createSearcher();
        docSearcher.setQueryCache(null);
    }

    PercolatorQueryCache registry = context.getPercolatorQueryCache();
    if (registry == null) {
        throw new QueryShardException(context, "no percolator query registry");
    }

    Query percolateTypeQuery = new TermQuery(new Term(TypeFieldMapper.NAME, PercolatorFieldMapper.TYPE_NAME));
    PercolatorQuery.Builder builder = new PercolatorQuery.Builder(documentType, registry, document, docSearcher,
            percolateTypeQuery);
    Settings indexSettings = registry.getIndexSettings().getSettings();
    if (indexSettings.getAsVersion(IndexMetaData.SETTING_VERSION_CREATED, null).onOrAfter(Version.V_5_0_0)) {
        builder.extractQueryTermsQuery(PercolatorFieldMapper.EXTRACTED_TERMS_FULL_FIELD_NAME,
                PercolatorFieldMapper.UNKNOWN_QUERY_FULL_FIELD_NAME);
    }
    return builder.build();
}

---

From source file:org.elasticsearch.index.query.PercolatorQueryBuilder.java

License:Apache License

private IndexSearcher createMultiDocumentSearcher(DocumentMapper docMapper, Analyzer defaultAnalyzer,
        ParsedDocument doc) {/*from   w  w  w.  j a va  2  s . c  o m*/
    IndexReader[] memoryIndices = new IndexReader[doc.docs().size()];
    List<ParseContext.Document> docs = doc.docs();
    int rootDocIndex = docs.size() - 1;
    assert rootDocIndex > 0;
    for (int i = 0; i < docs.size(); i++) {
        ParseContext.Document d = docs.get(i);
        MemoryIndex memoryIndex = new MemoryIndex(true);
        indexDoc(docMapper, defaultAnalyzer, d, memoryIndex);
        memoryIndices[i] = memoryIndex.createSearcher().getIndexReader();
    }
    try {
        MultiReader mReader = new MultiReader(memoryIndices, true);
        LeafReader slowReader = SlowCompositeReaderWrapper.wrap(mReader);
        final IndexSearcher slowSearcher = new IndexSearcher(slowReader) {

            @Override
            public Weight createNormalizedWeight(Query query, boolean needsScores) throws IOException {
                BooleanQuery.Builder bq = new BooleanQuery.Builder();
                bq.add(query, BooleanClause.Occur.MUST);
                bq.add(Queries.newNestedFilter(), BooleanClause.Occur.MUST_NOT);
                return super.createNormalizedWeight(bq.build(), needsScores);
            }

        };
        slowSearcher.setQueryCache(null);
        return slowSearcher;
    } catch (IOException e) {
        throw new ElasticsearchException("Failed to create index for percolator with nested document ", e);
    }
}

---

From source file:org.elasticsearch.index.query.PercolatorQueryTests.java

License:Apache License

public void testVariousQueries() throws Exception {
    addPercolatorQuery("1", new TermQuery(new Term("field", "brown")));
    addPercolatorQuery("2", new TermQuery(new Term("field", "monkey")));
    addPercolatorQuery("3", new TermQuery(new Term("field", "fox")));
    BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
    bq1.add(new TermQuery(new Term("field", "fox")), BooleanClause.Occur.SHOULD);
    bq1.add(new TermQuery(new Term("field", "monkey")), BooleanClause.Occur.SHOULD);
    addPercolatorQuery("4", bq1.build());
    BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
    bq2.add(new TermQuery(new Term("field", "fox")), BooleanClause.Occur.MUST);
    bq2.add(new TermQuery(new Term("field", "monkey")), BooleanClause.Occur.MUST);
    addPercolatorQuery("5", bq2.build());
    BooleanQuery.Builder bq3 = new BooleanQuery.Builder();
    bq3.add(new TermQuery(new Term("field", "fox")), BooleanClause.Occur.MUST);
    bq3.add(new TermQuery(new Term("field", "apes")), BooleanClause.Occur.MUST_NOT);
    addPercolatorQuery("6", bq3.build());
    BooleanQuery.Builder bq4 = new BooleanQuery.Builder();
    bq4.add(new TermQuery(new Term("field", "fox")), BooleanClause.Occur.MUST_NOT);
    bq4.add(new TermQuery(new Term("field", "apes")), BooleanClause.Occur.MUST);
    addPercolatorQuery("7", bq4.build());
    PhraseQuery.Builder pq1 = new PhraseQuery.Builder();
    pq1.add(new Term("field", "lazy"));
    pq1.add(new Term("field", "dog"));
    addPercolatorQuery("8", pq1.build());

    indexWriter.close();/*ww w  . j av a2 s  .  co m*/
    directoryReader = DirectoryReader.open(directory);
    IndexSearcher shardSearcher = newSearcher(directoryReader);

    MemoryIndex memoryIndex = new MemoryIndex();
    memoryIndex.addField("field", "the quick brown fox jumps over the lazy dog", new WhitespaceAnalyzer());
    IndexSearcher percolateSearcher = memoryIndex.createSearcher();

    PercolatorQuery.Builder builder = new PercolatorQuery.Builder("docType", queryRegistry,
            new BytesArray("{}"), percolateSearcher, new MatchAllDocsQuery());
    builder.extractQueryTermsQuery(EXTRACTED_TERMS_FIELD_NAME, UNKNOWN_QUERY_FIELD_NAME);
    TopDocs topDocs = shardSearcher.search(builder.build(), 10);
    assertThat(topDocs.totalHits, equalTo(5));
    assertThat(topDocs.scoreDocs.length, equalTo(5));
    assertThat(topDocs.scoreDocs[0].doc, equalTo(0));
    assertThat(topDocs.scoreDocs[1].doc, equalTo(2));
    assertThat(topDocs.scoreDocs[2].doc, equalTo(3));
    assertThat(topDocs.scoreDocs[3].doc, equalTo(5));
    assertThat(topDocs.scoreDocs[4].doc, equalTo(7));
}

---

From source file:org.elasticsearch.index.query.PercolatorQueryTests.java

License:Apache License

public void testDuel() throws Exception {
    int numQueries = scaledRandomIntBetween(32, 256);
    for (int i = 0; i < numQueries; i++) {
        String id = Integer.toString(i);
        Query query;//w ww  . ja va 2 s.  co  m
        if (randomBoolean()) {
            query = new PrefixQuery(new Term("field", id));
        } else if (randomBoolean()) {
            query = new WildcardQuery(new Term("field", id + "*"));
        } else if (randomBoolean()) {
            query = new CustomQuery(new Term("field", id + "*"));
        } else {
            query = new TermQuery(new Term("field", id));
        }
        addPercolatorQuery(id, query);
    }

    indexWriter.close();
    directoryReader = DirectoryReader.open(directory);
    IndexSearcher shardSearcher = newSearcher(directoryReader);

    for (int i = 0; i < numQueries; i++) {
        MemoryIndex memoryIndex = new MemoryIndex();
        String id = Integer.toString(i);
        memoryIndex.addField("field", id, new WhitespaceAnalyzer());
        IndexSearcher percolateSearcher = memoryIndex.createSearcher();

        PercolatorQuery.Builder builder1 = new PercolatorQuery.Builder("docType", queryRegistry,
                new BytesArray("{}"), percolateSearcher, new MatchAllDocsQuery());
        // enables the optimization that prevents queries from being evaluated that don't match
        builder1.extractQueryTermsQuery(EXTRACTED_TERMS_FIELD_NAME, UNKNOWN_QUERY_FIELD_NAME);
        TopDocs topDocs1 = shardSearcher.search(builder1.build(), 10);

        PercolatorQuery.Builder builder2 = new PercolatorQuery.Builder("docType", queryRegistry,
                new BytesArray("{}"), percolateSearcher, new MatchAllDocsQuery());
        TopDocs topDocs2 = shardSearcher.search(builder2.build(), 10);

        assertThat(topDocs1.totalHits, equalTo(topDocs2.totalHits));
        assertThat(topDocs1.scoreDocs.length, equalTo(topDocs2.scoreDocs.length));
        for (int j = 0; j < topDocs1.scoreDocs.length; j++) {
            assertThat(topDocs1.scoreDocs[j].doc, equalTo(topDocs2.scoreDocs[j].doc));
        }
    }
}

---

From source file:org.elasticsearch.index.query.WrapperQueryBuilderTests.java

License:Apache License

@Override
protected Query rewrite(Query query) throws IOException {
    // WrapperQueryBuilder adds some optimization if the wrapper and query builder have boosts / query names that wraps
    // the actual QueryBuilder that comes from the binary blob into a BooleanQueryBuilder to give it an outer boost / name
    // this causes some queries to be not exactly equal but equivalent such that we need to rewrite them before comparing.
    if (query != null) {
        MemoryIndex idx = new MemoryIndex();
        return idx.createSearcher().rewrite(query);
    }//from   w  w  w.jav a 2s .co m
    return new MatchAllDocsQuery(); // null == *:*
}

---

From source file:org.elasticsearch.index.termvectors.ShardTermVectorsService.java

License:Apache License

private Fields generateTermVectors(Collection<GetField> getFields, boolean withOffsets,
        @Nullable Map<String, String> perFieldAnalyzer, Set<String> fields) throws IOException {
    /* store document in memory index */
    MemoryIndex index = new MemoryIndex(withOffsets);
    for (GetField getField : getFields) {
        String field = getField.getName();
        if (fields.contains(field) == false) {
            // some fields are returned even when not asked for, eg. _timestamp
            continue;
        }/*  ww w  .j a v  a 2 s  .  com*/
        Analyzer analyzer = getAnalyzerAtField(field, perFieldAnalyzer);
        for (Object text : getField.getValues()) {
            index.addField(field, text.toString(), analyzer);
        }
    }
    /* and read vectors from it */
    return MultiFields.getFields(index.createSearcher().getIndexReader());
}

---

From source file:org.elasticsearch.index.termvectors.TermVectorsService.java

License:Apache License

private static Fields generateTermVectors(IndexShard indexShard, Map<String, Object> source,
        Collection<GetField> getFields, boolean withOffsets, @Nullable Map<String, String> perFieldAnalyzer,
        Set<String> fields) throws IOException {
    Map<String, Collection<Object>> values = new HashMap<>();
    for (GetField getField : getFields) {
        String field = getField.getName();
        if (fields.contains(field)) { // some fields are returned even when not asked for, eg. _timestamp
            values.put(field, getField.getValues());
        }//w w  w. j ava  2s  .c o m
    }
    if (source != null) {
        for (String field : fields) {
            if (values.containsKey(field) == false) {
                List<Object> v = XContentMapValues.extractRawValues(field, source);
                if (v.isEmpty() == false) {
                    values.put(field, v);
                }
            }
        }
    }

    /* store document in memory index */
    MemoryIndex index = new MemoryIndex(withOffsets);
    for (Map.Entry<String, Collection<Object>> entry : values.entrySet()) {
        String field = entry.getKey();
        Analyzer analyzer = getAnalyzerAtField(indexShard, field, perFieldAnalyzer);
        for (Object text : entry.getValue()) {
            index.addField(field, text.toString(), analyzer);
        }
    }
    /* and read vectors from it */
    return MultiFields.getFields(index.createSearcher().getIndexReader());
}

---

From source file:org.elasticsearch.percolator.CandidateQueryTests.java

License:Apache License

private void duelRun(PercolateQuery.QueryStore queryStore, MemoryIndex memoryIndex, IndexSearcher shardSearcher)
        throws IOException {
    boolean requireScore = randomBoolean();
    IndexSearcher percolateSearcher = memoryIndex.createSearcher();
    Query percolateQuery = fieldType.percolateQuery("type", queryStore, new BytesArray("{}"),
            percolateSearcher);/*from   w  ww .j  av a  2  s  .co m*/
    Query query = requireScore ? percolateQuery : new ConstantScoreQuery(percolateQuery);
    TopDocs topDocs = shardSearcher.search(query, 10);

    Query controlQuery = new ControlQuery(memoryIndex, queryStore);
    controlQuery = requireScore ? controlQuery : new ConstantScoreQuery(controlQuery);
    TopDocs controlTopDocs = shardSearcher.search(controlQuery, 10);
    assertThat(topDocs.totalHits, equalTo(controlTopDocs.totalHits));
    assertThat(topDocs.scoreDocs.length, equalTo(controlTopDocs.scoreDocs.length));
    for (int j = 0; j < topDocs.scoreDocs.length; j++) {
        assertThat(topDocs.scoreDocs[j].doc, equalTo(controlTopDocs.scoreDocs[j].doc));
        assertThat(topDocs.scoreDocs[j].score, equalTo(controlTopDocs.scoreDocs[j].score));
        if (requireScore) {
            Explanation explain1 = shardSearcher.explain(query, topDocs.scoreDocs[j].doc);
            Explanation explain2 = shardSearcher.explain(controlQuery, controlTopDocs.scoreDocs[j].doc);
            assertThat(explain1.isMatch(), equalTo(explain2.isMatch()));
            assertThat(explain1.getValue(), equalTo(explain2.getValue()));
        }
    }
}

---

From source file:org.elasticsearch.percolator.ExtractQueryTermsServiceTests.java

License:Apache License

public void testCreateQueryMetadataQuery() throws Exception {
    MemoryIndex memoryIndex = new MemoryIndex(false);
    memoryIndex.addField("field1", "the quick brown fox jumps over the lazy dog", new WhitespaceAnalyzer());
    memoryIndex.addField("field2", "some more text", new WhitespaceAnalyzer());
    memoryIndex.addField("_field3", "unhide me", new WhitespaceAnalyzer());
    memoryIndex.addField("field4", "123", new WhitespaceAnalyzer());

    IndexReader indexReader = memoryIndex.createSearcher().getIndexReader();
    TermsQuery query = (TermsQuery) createQueryTermsQuery(indexReader, QUERY_TERMS_FIELD,
            new Term(EXTRACTION_RESULT_FIELD, EXTRACTION_FAILED));

    PrefixCodedTerms terms = query.getTermData();
    assertThat(terms.size(), equalTo(15L));
    PrefixCodedTerms.TermIterator termIterator = terms.iterator();
    assertTermIterator(termIterator, "_field3\u0000me", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "_field3\u0000unhide", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field1\u0000brown", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field1\u0000dog", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field1\u0000fox", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field1\u0000jumps", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field1\u0000lazy", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field1\u0000over", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field1\u0000quick", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field1\u0000the", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field2\u0000more", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field2\u0000some", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field2\u0000text", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, "field4\u0000123", QUERY_TERMS_FIELD);
    assertTermIterator(termIterator, EXTRACTION_FAILED, EXTRACTION_RESULT_FIELD);
}

---

From source file:org.elasticsearch.percolator.PercolateQueryBuilder.java

License:Apache License

@Override
protected Query doToQuery(QueryShardContext context) throws IOException {
    if (indexedDocumentIndex != null || indexedDocumentType != null || indexedDocumentId != null) {
        throw new IllegalStateException("query builder must be rewritten first");
    }/* w w w  . ja v  a 2s.c o m*/

    if (document == null) {
        throw new IllegalStateException("no document to percolate");
    }

    MapperService mapperService = context.getMapperService();
    DocumentMapperForType docMapperForType = mapperService.documentMapperWithAutoCreate(documentType);
    DocumentMapper docMapper = docMapperForType.getDocumentMapper();

    ParsedDocument doc = docMapper.parse(source(context.index().getName(), documentType, "_temp_id", document));

    FieldNameAnalyzer fieldNameAnalyzer = (FieldNameAnalyzer) docMapper.mappers().indexAnalyzer();
    // Need to this custom impl because FieldNameAnalyzer is strict and the percolator sometimes isn't when
    // 'index.percolator.map_unmapped_fields_as_string' is enabled:
    Analyzer analyzer = new DelegatingAnalyzerWrapper(Analyzer.PER_FIELD_REUSE_STRATEGY) {
        @Override
        protected Analyzer getWrappedAnalyzer(String fieldName) {
            Analyzer analyzer = fieldNameAnalyzer.analyzers().get(fieldName);
            if (analyzer != null) {
                return analyzer;
            } else {
                return context.getAnalysisService().defaultIndexAnalyzer();
            }
        }
    };
    final IndexSearcher docSearcher;
    if (doc.docs().size() > 1) {
        assert docMapper.hasNestedObjects();
        docSearcher = createMultiDocumentSearcher(analyzer, doc);
    } else {
        MemoryIndex memoryIndex = MemoryIndex.fromDocument(doc.rootDoc(), analyzer, true, false);
        docSearcher = memoryIndex.createSearcher();
        docSearcher.setQueryCache(null);
    }

    Version indexVersionCreated = context.getIndexSettings().getIndexVersionCreated();
    boolean mapUnmappedFieldsAsString = context.getIndexSettings()
            .getValue(PercolatorFieldMapper.INDEX_MAP_UNMAPPED_FIELDS_AS_STRING_SETTING);
    if (indexVersionCreated.onOrAfter(Version.V_5_0_0_alpha1)) {
        MappedFieldType fieldType = context.fieldMapper(field);
        if (fieldType == null) {
            throw new QueryShardException(context, "field [" + field + "] does not exist");
        }

        if (!(fieldType instanceof PercolatorFieldMapper.FieldType)) {
            throw new QueryShardException(context, "expected field [" + field
                    + "] to be of type [percolator], but is of type [" + fieldType.typeName() + "]");
        }
        PercolatorFieldMapper.FieldType pft = (PercolatorFieldMapper.FieldType) fieldType;
        PercolateQuery.QueryStore queryStore = createStore(pft, context, mapUnmappedFieldsAsString);
        return pft.percolateQuery(documentType, queryStore, document, docSearcher);
    } else {
        Query percolateTypeQuery = new TermQuery(
                new Term(TypeFieldMapper.NAME, MapperService.PERCOLATOR_LEGACY_TYPE_NAME));
        PercolateQuery.QueryStore queryStore = createLegacyStore(context, mapUnmappedFieldsAsString);
        return new PercolateQuery(documentType, queryStore, document, percolateTypeQuery, docSearcher,
                new MatchNoDocsQuery("pre 5.0.0-alpha1 index, no verified matches"));
    }
}

---

• «
• 1
• 2
• 3
• »