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

Introduction

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

Prototype

public static MemoryIndex fromDocument(Iterable<? extends IndexableField> document, Analyzer analyzer,
        boolean storeOffsets, boolean storePayloads) 

Source Link

Document

Builds a MemoryIndex from a lucene Document using an analyzer

Usage

From source file:org.elasticsearch.index.query.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  .  j  a v  a2s  .  co 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(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);
    }

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

    PercolateQuery.Builder builder = new PercolateQuery.Builder(documentType, registry, document, docSearcher);
    Settings indexSettings = registry.getIndexSettings().getSettings();
    if (indexSettings.getAsVersion(IndexMetaData.SETTING_VERSION_CREATED, null)
            .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.PercolatorFieldType)) {
            throw new QueryShardException(context, "expected field [" + field
                    + "] to be of type [percolator], but is of type [" + fieldType.typeName() + "]");
        }
        PercolatorFieldMapper.PercolatorFieldType pft = (PercolatorFieldMapper.PercolatorFieldType) fieldType;
        builder.extractQueryTermsQuery(pft.getExtractedTermsField(), pft.getUnknownQueryFieldName());
    } else {
        Query percolateTypeQuery = new TermQuery(
                new Term(TypeFieldMapper.NAME, PercolatorFieldMapper.LEGACY_TYPE_NAME));
        builder.setPercolateTypeQuery(percolateTypeQuery);
    }
    return builder.build();
}

---

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

License:Apache License

private IndexSearcher createMultiDocumentSearcher(Analyzer analyzer, ParsedDocument doc) {
    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 = MemoryIndex.fromDocument(d, analyzer, true, false);
        memoryIndices[i] = memoryIndex.createSearcher().getIndexReader();
    }//from  w ww .  j a va2  s  .c o  m
    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.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 .j  av  a 2 s  .com*/

    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"));
    }
}

---