Examples of org.elasticsearch.common.lucene.search.TermFilter

Package org.elasticsearch.common.lucene.search

Examples of org.elasticsearch.common.lucene.search.TermFilter

org.elasticsearch.common.lucene.search.TermFilter
A simple filter for a specific term. @author kimchy (shay.banon)

            if (smartNameFieldMappers.hasMapper()) {
                filter = smartNameFieldMappers.mapper().fieldFilter(value);
            }
        }
        if (filter == null) {
            filter = new TermFilter(new Term(fieldName, value));
        }


        if (cache) {
            filter = parseContext.cacheFilter(filter, cacheKey);
        }

View Full Code Here

        // if we filter by types, we don't need to filter by non nested docs
        // since they have different types (starting with __)
        if (types.length == 1) {
            DocumentMapper docMapper = documentMapper(types[0]);
            if (docMapper == null) {
                return new TermFilter(new Term(types[0]));
            }
            return docMapper.typeFilter();
        }
        // see if we can use terms filter
        boolean useTermsFilter = true;
        for (String type : types) {
            DocumentMapper docMapper = documentMapper(type);
            if (docMapper == null) {
                useTermsFilter = false;
                break;
            }
            if (!docMapper.typeMapper().indexed()) {
                useTermsFilter = false;
                break;
            }
        }
        if (useTermsFilter) {
            PublicTermsFilter termsFilter = new PublicTermsFilter();
            for (String type : types) {
                termsFilter.addTerm(TypeFieldMapper.TERM_FACTORY.createTerm(type));
            }
            return termsFilter;
        } else {
            XBooleanFilter bool = new XBooleanFilter();
            for (String type : types) {
                DocumentMapper docMapper = documentMapper(type);
                if (docMapper == null) {
                    bool.add(new FilterClause(new TermFilter(TypeFieldMapper.TERM_FACTORY.createTerm(type)), BooleanClause.Occur.SHOULD));
                } else {
                    bool.add(new FilterClause(docMapper.typeFilter(), BooleanClause.Occur.SHOULD));
                }
            }
            return bool;

View Full Code Here

                    .boost(i).build());
        }


        reader = refreshReader(reader);
        IndexSearcher searcher = new IndexSearcher(reader);
        assertThat(Lucene.count(searcher, new ConstantScoreQuery(filterCache.cache(new TermFilter(new Term("id", "1")))), -1), equalTo(1l));
        assertThat(Lucene.count(searcher, new FilteredQuery(new MatchAllDocsQuery(), filterCache.cache(new TermFilter(new Term("id", "1")))), -1), equalTo(1l));


        indexWriter.deleteDocuments(new Term("id", "1"));
        reader = refreshReader(reader);
        searcher = new IndexSearcher(reader);
        TermFilter filter = new TermFilter(new Term("id", "1"));
        Filter cachedFilter = filterCache.cache(filter);
        long constantScoreCount = filter == cachedFilter ? 0 : 1;
        // sadly, when caching based on cacheKey with NRT, this fails, that's why we have DeletionAware one
        assertThat(Lucene.count(searcher, new ConstantScoreQuery(cachedFilter), -1), equalTo(constantScoreCount));
        assertThat(Lucene.count(searcher, new DeletionAwareConstantScoreQuery(cachedFilter), -1), equalTo(0l));

View Full Code Here


    @Override public Filter fieldFilter(String value) {
        if (index == Field.Index.NO) {
            return new PrefixFilter(UidFieldMapper.TERM_FACTORY.createTerm(Uid.typePrefix(value)));
        }
        return new TermFilter(termFactory.createTerm(value));
    }

View Full Code Here

        String query = copyToStringFromClasspath("/org/elasticsearch/index/query/term-filter.json");
        Query parsedQuery = queryParser.parse(query).query();
        assertThat(parsedQuery, instanceOf(FilteredQuery.class));
        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery;
        assertThat(filteredQuery.getFilter(), instanceOf(TermFilter.class));
        TermFilter termFilter = (TermFilter) filteredQuery.getFilter();
        assertThat(termFilter.getTerm().field(), equalTo("name.last"));
        assertThat(termFilter.getTerm().text(), equalTo("banon"));
    }

View Full Code Here

        ParsedQuery parsedQuery = queryParser.parse(query);
        assertThat(parsedQuery.namedFilters().containsKey("test"), equalTo(true));
        assertThat(parsedQuery.query(), instanceOf(FilteredQuery.class));
        FilteredQuery filteredQuery = (FilteredQuery) parsedQuery.query();
        assertThat(filteredQuery.getFilter(), instanceOf(TermFilter.class));
        TermFilter termFilter = (TermFilter) filteredQuery.getFilter();
        assertThat(termFilter.getTerm().field(), equalTo("name.last"));
        assertThat(termFilter.getTerm().text(), equalTo("banon"));
    }

View Full Code Here

            searcher.release();
        }
    }


    private Filter indexQueriesFilter(String indexName) {
        return percolatorIndexService().cache().filter().cache(new TermFilter(new Term(TypeFieldMapper.NAME, indexName)));
    }

View Full Code Here

    @Override public Query fuzzyQuery(String value, double minSim, int prefixLength, int maxExpansions) {
        return new FuzzyQuery(termFactory.createTerm(value), (float) minSim, prefixLength, maxExpansions);
    }


    @Override public Filter fieldFilter(String value) {
        return new TermFilter(termFactory.createTerm(indexedValue(value)));
    }

View Full Code Here

        this.pathType = pathType;
        if (mappers != null) {
            this.mappers = copyOf(mappers);
        }
        this.nestedTypePath = "__" + fullPath;
        this.nestedTypeFilter = new TermFilter(TypeFieldMapper.TERM_FACTORY.createTerm(nestedTypePath));
    }

View Full Code Here

        parser.nextToken();


        Filter filter;
        DocumentMapper documentMapper = parseContext.mapperService().documentMapper(type);
        if (documentMapper == null) {
            filter = new TermFilter(new Term(TypeFieldMapper.NAME, type));
        } else {
            filter = documentMapper.typeFilter();
        }
        return parseContext.cacheFilter(filter, null);
    }

View Full Code Here

TOP

Related Classes of org.elasticsearch.common.lucene.search.TermFilter

org.apache.lucene.index.TermDocs

org.apache.lucene.util.OpenBitSet

org.elasticsearch.index.cache.filter.FilterCacheTests

org.elasticsearch.index.mapper.core.AbstractFieldMapper

org.elasticsearch.index.mapper.internal.TypeFieldMapper

org.elasticsearch.index.mapper.MapperService

org.elasticsearch.index.mapper.object.ObjectMapper

org.elasticsearch.index.percolator.PercolatorService

org.elasticsearch.index.query.SimpleIndexQueryParserTests

org.elasticsearch.index.query.TermFilterParser

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.