Java FilterBuilders.termFilter方法代码示例

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
private FilterBuilder getBaseFilterBuilder(String facetName, String fieldValue)
    {
        if(facetName.startsWith(SearchFacetName.SEARCH_FACET_TYPE_FACET_PREFIX))
        {
            return getTermFilter(SearchFacetName.CATEGORIES_FIELD_PREFIX + facetName + "." + SearchDocumentFieldName.FACETFILTER.getFieldName(), fieldValue.toLowerCase());
        }
        else if(facetName.startsWith(SearchFacetName.PRODUCT_PRICE_RANGE.getCode()))
        {
            return FilterBuilders.rangeFilter(SearchDocumentFieldName.PRICE.getFieldName()).includeLower(true).includeUpper(false).from(fieldValue.split("-")[0]).to(fieldValue.split("-")[1]);
        }
        else
        {
            return FilterBuilders.termFilter(facetName, fieldValue);
        }
//        return null;
    }
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
private FilterBuilder getBaseFilterBuilder(final String facetName, final String fieldValue)
{
    if (facetName.startsWith(SearchFacetName.SEARCH_FACET_TYPE_FACET_PREFIX))
    {
        return getTermFilter(
                SearchFacetName.CATEGORIES_FIELD_PREFIX + facetName + "." + SearchDocumentFieldName.FACETFILTER.getFieldName(),
                fieldValue.toLowerCase());
    }
    else if (facetName.startsWith(SearchFacetName.PRODUCT_PRICE_RANGE.getCode()))
    {
        return FilterBuilders.rangeFilter(SearchDocumentFieldName.PRICE.getFieldName()).includeLower(true).includeUpper(false)
                .from(fieldValue.split("-")[0]).to(fieldValue.split("-")[1]);
    }
    else
    {
        return FilterBuilders.termFilter(facetName, fieldValue);
    }
    // return null;
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
private static FilterBuilder fromValueType(String field, String value, int valueType){
	if(value.contains("*") || value.contains("?")){
		if( value.length() > 1 && value.indexOf('*') == (value.length()-1))
			return FilterBuilders.prefixFilter(field, value.substring(0, value.length()-1));
		else
			return FilterBuilders.queryFilter(QueryBuilders.wildcardQuery(field, value));
	}
	
	switch(valueType){
	case AST_TermExpression.TERM:
		return FilterBuilders.termFilter(field, value);
	case AST_TermExpression.PHRASE:
		/*for(byte b: value.getBytes()){
			System.out.printf("0x%02X ", b);		        
		}*/
		return FilterBuilders.queryFilter(QueryBuilders.matchPhraseQuery(field, value));
	}
	return null;
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
private FilterBuilder getBaseFilterBuilder(final String facetName,
		final String fieldValue) {
	if (facetName
			.startsWith(SearchFacetName.SEARCH_FACET_TYPE_FACET_PREFIX)) {
		return getTermFilter(
				SearchFacetName.CATEGORIES_FIELD_PREFIX
						+ facetName
						+ "."
						+ SearchDocumentFieldName.FACETFILTER
								.getFieldName(),
				fieldValue.toLowerCase());
	} else if (facetName.startsWith(SearchFacetName.PRODUCT_PRICE_RANGE
			.getCode())) {
		return FilterBuilders
				.rangeFilter(SearchDocumentFieldName.PRICE.getFieldName())
				.includeLower(true).includeUpper(false)
				.from(fieldValue.split("-")[0])
				.to(fieldValue.split("-")[1]);
	} else {
		return FilterBuilders.termFilter(facetName, fieldValue);
	}
	// return null;
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
@Test
public void testTermFilter() {
  FilterBuilder termFilter = FilterBuilders.termFilter("text_entry", "havoc");

  QueryBuilder filteredQuery =
      QueryBuilders.filteredQuery(QueryBuilders.matchAllQuery(), termFilter);

  SearchResponse response = srb.setQuery(filteredQuery).execute().actionGet();

  // read response
  long totalMatched = response.getHits().getTotalHits();
  System.out.println("Total matched: " + totalMatched);
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
@Override
public void buildSearchForIndexedDocumentsNotUpdatedAfter(SearchRequestBuilder srb, String spaceKey, Date date) {
	FilterBuilder filterTime = FilterBuilders.rangeFilter("_timestamp").lt(date);
	FilterBuilder filterSpaceKey = FilterBuilders.termFilter(indexFieldForSpaceKey, spaceKey);
	FilterBuilder filterSource = FilterBuilders.termFilter(indexFieldForRiverName, riverName);
	FilterBuilder filter = FilterBuilders.boolFilter().must(filterTime, filterSpaceKey, filterSource);
	srb.setQuery(QueryBuilders.matchAllQuery()).addField("_id").setPostFilter(filter);
	if (commentIndexingMode.isExtraDocumentIndexed())
		srb.setTypes(issueTypeName, commentTypeName);
	else
		srb.setTypes(issueTypeName);
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
@Override
public void buildSearchForIndexedDocumentsWithRemoteId(SearchRequestBuilder srb, String spaceKey, String remoteId) {
	FilterBuilder filterRemoteId = FilterBuilders.termFilter(indexFieldForRemoteDocumentId, remoteId);
	FilterBuilder filterSpaceKey = FilterBuilders.termFilter(indexFieldForSpaceKey, spaceKey);
	FilterBuilder filterSource = FilterBuilders.termFilter(indexFieldForRiverName, riverName);
	FilterBuilder filter = FilterBuilders.boolFilter().must(filterRemoteId, filterSpaceKey, filterSource);
	srb.setQuery(QueryBuilders.matchAllQuery()).addField("_id").setPostFilter(filter);
	if (commentIndexingMode.isExtraDocumentIndexed())
		srb.setTypes(issueTypeName, commentTypeName);
	else
		srb.setTypes(issueTypeName);
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
@Override
public FilterBuilder buildQuery(QueryNode queryNode) {
    if (queryNode == null)
        return null;
    if (queryNode.getType().equals(QueryNodeType.BOOLEAN)) {
        List<FilterBuilder> filterBuilders = new ArrayList<>();
        for (QueryNode node : queryNode.getNodes()) {
            filterBuilders.add(buildQuery(node));
        }
        if (queryNode.getOperator().equals(AND)) {
            FilterBuilder andFilterBuilder = FilterBuilders.andFilter(filterBuilders.toArray(new FilterBuilder[filterBuilders.size()]));
            return andFilterBuilder;
        } else {
            FilterBuilder orFilterBuilder = FilterBuilders.orFilter(filterBuilders.toArray(new FilterBuilder[filterBuilders.size()]));
            return orFilterBuilder;
        }
    } else {
        if (queryNode.getValue() != null && queryNode.getValue().getAttribute() != null) {
            String key = ATT_PREFIX + Strings.slugify(queryNode.getValue().getAttribute().getCode()).replace(Char.MINUS, Char.UNDERSCORE) + HASH_SUFFIX;
            if (queryNode.getValue().getOptionIds() != null && queryNode.getValue().getOptionIds().size() > 1) {
                List<String> values = new ArrayList<>();
                for (Id id : queryNode.getValue().getOptionIds()) {
                    values.add(Str.UNDERSCORE_2X + id + Str.UNDERSCORE_2X);
                }
                return FilterBuilders.termsFilter(key, values).execution(OR);
            } else if (queryNode.getValue().getOptionIds() != null && queryNode.getValue().getOptionIds().size() > 0) {
                return FilterBuilders.termsFilter(key, Str.UNDERSCORE_2X + queryNode.getValue().getOptionId() + Str.UNDERSCORE_2X);
            } else if (queryNode.getValue().getVal() != null) {
                if(queryNode.getValue().getAttribute().isAllowMultipleValues()){
                    key = ATT_PREFIX + Strings.slugify(queryNode.getValue().getAttribute().getCode()).replace(Char.MINUS, Char.UNDERSCORE) + RAW_SUFFIX;
                    return FilterBuilders.termsFilter(key, queryNode.getValue().getVal());
                } else {
                    key = ATT_PREFIX + Strings.slugify(queryNode.getValue().getAttribute().getCode()).replace(Char.MINUS, Char.UNDERSCORE) + RAW_SUFFIX;
                    return FilterBuilders.termFilter(key, queryNode.getValue().getVal());
                }
            } else {
                return FilterBuilders.missingFilter(key);
            }
        }
    }
    return null;
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
@Override
public FilterBuilder buildQuery(QueryNode queryNode) {
    if (queryNode == null)
        return null;
    if (queryNode.getType().equals(QueryNodeType.BOOLEAN)) {
        List<FilterBuilder> filterBuilders = new ArrayList<>();
        if(queryNode.getNodes() != null) {
            for (QueryNode node : queryNode.getNodes()) {
                filterBuilders.add(buildQuery(node));
            }
            if (queryNode.getOperator().equals(AND)) {
                FilterBuilder andFilterBuilder = FilterBuilders.andFilter(filterBuilders.toArray(new FilterBuilder[filterBuilders.size()]));
                return andFilterBuilder;
            } else {
                FilterBuilder orFilterBuilder = FilterBuilders.orFilter(filterBuilders.toArray(new FilterBuilder[filterBuilders.size()]));
                return orFilterBuilder;
            }
        }
    } else {
        if (queryNode.getValue() != null && queryNode.getValue().getAttribute() != null) {
            String key = ATT_PREFIX + Strings.slugify(queryNode.getValue().getAttribute().getCode()).replace(Char.MINUS, Char.UNDERSCORE) + HASH_SUFFIX;
            if (queryNode.getValue().getOptionIds() != null && queryNode.getValue().getOptionIds().size() > 1) {
                List<String> values = new ArrayList<>();
                for (Id id : queryNode.getValue().getOptionIds()) {
                    values.add(Str.UNDERSCORE_2X + id + Str.UNDERSCORE_2X);
                }
                return FilterBuilders.termsFilter(key, values).execution(OR);
            } else if (queryNode.getValue().getOptionIds() != null && queryNode.getValue().getOptionIds().size() > 0) {
                return FilterBuilders.termsFilter(key, Str.UNDERSCORE_2X + queryNode.getValue().getOptionId() + Str.UNDERSCORE_2X);
            } else if (queryNode.getValue().getVal() != null) {
                if(queryNode.getValue().getAttribute().isAllowMultipleValues()){
                    key = ATT_PREFIX + Strings.slugify(queryNode.getValue().getAttribute().getCode()).replace(Char.MINUS, Char.UNDERSCORE) + RAW_SUFFIX;
                    return FilterBuilders.termsFilter(key, queryNode.getValue().getVal());
                } else {
                    if(StringUtils.isEmpty(queryNode.getComparator()) || "is".equals(queryNode.getComparator())){
                        key = ATT_PREFIX + Strings.slugify(queryNode.getValue().getAttribute().getCode()).replace(Char.MINUS, Char.UNDERSCORE) + RAW_SUFFIX;
                        return FilterBuilders.termFilter(key, queryNode.getValue().getVal());
                    } else {
                        key = ATT_PREFIX + Strings.slugify(queryNode.getValue().getAttribute().getCode()).replace(Char.MINUS, Char.UNDERSCORE) + RAW_SUFFIX;
                        if(queryNode.getComparator().equals("gt")){
                            return FilterBuilders.rangeFilter(key).gt(queryNode.getValue().getVal());
                        }
                        if(queryNode.getComparator().equals("gte")){
                            return FilterBuilders.rangeFilter(key).gte(queryNode.getValue().getVal());
                        }
                        if(queryNode.getComparator().equals("lt")){
                            return FilterBuilders.rangeFilter(key).lt(queryNode.getValue().getVal());
                        }
                        if(queryNode.getComparator().equals("lte")){
                            return FilterBuilders.rangeFilter(key).lte(queryNode.getValue().getVal());
                        }
                    }
                }
            } else {
                return FilterBuilders.missingFilter(key);
            }
        }
    }
    return null;
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
private TermFilterBuilder getTermFilter(String fieldName, String fieldValue)
{
    return FilterBuilders.termFilter(fieldName, fieldValue);
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
private TermFilterBuilder getTermFilter(final String fieldName, final String fieldValue)
{
    return FilterBuilders.termFilter(fieldName, fieldValue);
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
private TermFilterBuilder getTermFilter(final String fieldName,
		final String fieldValue) {
	return FilterBuilders.termFilter(fieldName, fieldValue);
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
/**
 * Create our filter builder.  We need to restrict our results on edge search, as well as on types, and any filters
 * that came from the grammar.
 */
private FilterBuilder createFilterBuilder( final SearchEdge searchEdge, final QueryVisitor visitor,
                                           final SearchTypes searchTypes ) {
    String context = createContextName( applicationScope, searchEdge );


    // Add our filter for context to our query for fast execution.
    // Fast because it utilizes bitsets internally. See this post for more detail.
    // http://www.elasticsearch.org/blog/all-about-elasticsearch-filter-bitsets/

    // TODO evaluate performance when it's an all query.
    // Do we need to put the context term first for performance?

    //make sure we have entity in the context
    BoolFilterBuilder boolQueryFilter = FilterBuilders.boolFilter();

    //add our edge search
    boolQueryFilter.must( FilterBuilders.termFilter( IndexingUtils.EDGE_SEARCH_FIELDNAME, context ) );


    /**
     * For the types the user specified, add them to an OR so 1 of them must match
     */
    final String[] sourceTypes = searchTypes.getTypeNames( applicationScope );


    if ( sourceTypes.length > 0 ) {
        final FilterBuilder[] typeTerms = new FilterBuilder[sourceTypes.length];

        for ( int i = 0; i < sourceTypes.length; i++ ) {
            typeTerms[i] = FilterBuilders.termFilter( IndexingUtils.ENTITY_TYPE_FIELDNAME, sourceTypes[i] );
        }

        //add all our types, 1 type must match per query
        boolQueryFilter.must( FilterBuilders.orFilter( typeTerms ) );
    }

    //if we have a filter from our visitor, add it

    Optional<FilterBuilder> queryBuilder = visitor.getFilterBuilder();

    if ( queryBuilder.isPresent() ) {
        boolQueryFilter.must( queryBuilder.get() );
    }

    return boolQueryFilter;
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
@Override
public void visit( Equal op ) throws NoIndexException {
    final String name = op.getProperty().getValue().toLowerCase();
    final Object value = op.getLiteral().getValue();

    //special case so we support our '*' char with wildcard, also should work for uuids
    if ( value instanceof String || value instanceof UUID ) {
        String stringValue = ((value instanceof String) ? (String)value : value.toString()).toLowerCase().trim();

        // or field is just a string that does need a prefix us a query
        if ( stringValue.contains( "*" ) ) {

            //Because of our legacy behavior, where we match CCCC*, we need to use the unanalyzed string to ensure that
            //we start
            final WildcardQueryBuilder wildcardQuery =
                    QueryBuilders.wildcardQuery( IndexingUtils.FIELD_STRING_NESTED_UNANALYZED, stringValue );
            queryBuilders.push( fieldNameTerm( name, wildcardQuery ) );
            filterBuilders.push( NoOpFilterBuilder.INSTANCE );
            return;
        }

        // Usergrid query parser allows single quotes to be escaped in values
        if ( stringValue.contains("\\'")) {
            stringValue = stringValue.replace("\\'", "'");
        }

        //it's an exact match, use a filter
        final TermFilterBuilder termFilter =
                FilterBuilders.termFilter( IndexingUtils.FIELD_STRING_NESTED_UNANALYZED, stringValue );

        queryBuilders.push( NoOpQueryBuilder.INSTANCE );
        filterBuilders.push( fieldNameTerm( name, termFilter ) );

        return;
    }

    // assume all other types need prefix

    final TermFilterBuilder termQuery =
            FilterBuilders.termFilter(getFieldNameForType(value), sanitize(value));

    filterBuilders.push( fieldNameTerm( name, termQuery ) );

    queryBuilders.push( NoOpQueryBuilder.INSTANCE );
}
 

import org.elasticsearch.index.query.FilterBuilders; //导入方法依赖的package包/类
/**
 * Create a term filter for our sorts
 */
public static TermFilterBuilder sortPropertyTermFilter( final String propertyName ) {
    return FilterBuilders.termFilter( IndexingUtils.FIELD_NAME, propertyName );
}