/** * @param spaceKey to get info for * @return spaces indexing info or null if not found. */ protected SpaceIndexingInfo getLastSpaceIndexingInfo(String spaceKey) { SpaceIndexingInfo lastIndexing = lastSpaceIndexingInfo.get(spaceKey); if (lastIndexing == null && activityLogIndexName != null) { try { refreshSearchIndex(activityLogIndexName); SearchResponse sr = client .prepareSearch(activityLogIndexName) .setTypes(activityLogTypeName) .setPostFilter( FilterBuilders.andFilter( FilterBuilders.termFilter(SpaceIndexingInfo.DOCFIELD_SPACE_KEY, spaceKey), FilterBuilders.termFilter( SpaceIndexingInfo.DOCFIELD_RIVER_NAME, riverName().getName()))) .setQuery(QueryBuilders.matchAllQuery()) .addSort(SpaceIndexingInfo.DOCFIELD_START_DATE, SortOrder.DESC) .addField("_source") .setSize(1) .execute() .actionGet(); if (sr.getHits().getTotalHits() > 0) { SearchHit hit = sr.getHits().getAt(0); lastIndexing = SpaceIndexingInfo.readFromDocument(hit.sourceAsMap()); } else { logger.debug("No last indexing info found in activity log for space {}", spaceKey); } } catch (Exception e) { logger.warn( "Error during LastSpaceIndexingInfo reading from activity log ES index: {} {}", e.getClass().getName(), e.getMessage()); } } return lastIndexing; }
private FilterBuilder createFilterFromTerm(Terms selection) { FilterBuilder[] includes = new FilterBuilder[selection.getValues().size()]; int i = 0; for (String value : selection.getValues()) { includes[i] = FilterBuilders.termFilter(selection.getField(), value); i++; } FilterBuilder[] excludes = new FilterBuilder[selection.getExcludes().size()]; i = 0; for (String value : selection.getExcludes()) { excludes[i] = FilterBuilders.termFilter(selection.getField(), value); i++; } if (includes.length == 0) { return FilterBuilders.notFilter(FilterBuilders.orFilter(excludes)); } FilterBuilder include = null; if (selection.getOperator() == Operator.or) { include = FilterBuilders.orFilter(includes); } else { include = FilterBuilders.andFilter(includes); } if (excludes.length == 0) { return include; } return FilterBuilders.andFilter( include, FilterBuilders.notFilter(FilterBuilders.orFilter(excludes))); }
public SearchResponse doSearch(ActivityQuery query, SearchOptions options) { SearchRequestBuilder requestBuilder = getClient() .prepareSearch(ActivityIndexDefinition.INDEX) .setTypes(ActivityIndexDefinition.TYPE); requestBuilder.setFrom(options.getOffset()); requestBuilder.setSize(options.getLimit()); requestBuilder.addSort(ActivityIndexDefinition.FIELD_CREATED_AT, SortOrder.DESC); AndFilterBuilder filter = FilterBuilders.andFilter(); if (!query.getTypes().isEmpty()) { OrFilterBuilder typeFilter = FilterBuilders.orFilter(); for (String type : query.getTypes()) { typeFilter.add(FilterBuilders.termFilter(ActivityIndexDefinition.FIELD_TYPE, type)); } filter.add(typeFilter); } if (!query.getDataOrFilters().isEmpty()) { for (Map.Entry<String, Object> entry : query.getDataOrFilters().entrySet()) { OrFilterBuilder orFilter = FilterBuilders.orFilter(); orFilter.add( FilterBuilders.nestedFilter( ActivityIndexDefinition.FIELD_DETAILS, FilterBuilders.termFilter( ActivityIndexDefinition.FIELD_DETAILS + "." + entry.getKey(), entry.getValue()))); filter.add(orFilter); } } Date since = query.getSince(); if (since != null) { filter.add( FilterBuilders.rangeFilter(ActivityIndexDefinition.FIELD_CREATED_AT) .gt(since) .cache(false)); } Date to = query.getTo(); if (to != null) { filter.add( FilterBuilders.rangeFilter(ActivityIndexDefinition.FIELD_CREATED_AT).lt(to).cache(false)); } requestBuilder.setQuery(QueryBuilders.filteredQuery(QueryBuilders.matchAllQuery(), filter)); return requestBuilder.get(); }
@Test public void testExplainWithAlias() throws Exception { cluster().ensureAtLeastNumNodes(2); try { client().admin().indices().prepareDelete("test").execute().actionGet(); } catch (IndexMissingException e) { } client().admin().indices().prepareCreate("test").execute().actionGet(); client().admin().cluster().prepareHealth("test").setWaitForGreenStatus().execute().actionGet(); client() .admin() .indices() .prepareAliases() .addAlias("test", "alias1", FilterBuilders.termFilter("field2", "value2")) .execute() .actionGet(); client() .prepareIndex("test", "test", "1") .setSource("field1", "value1", "field2", "value1") .execute() .actionGet(); client().admin().indices().prepareRefresh("test").execute().actionGet(); ExplainResponse response = client() .prepareExplain("alias1", "test", "1") .setQuery(QueryBuilders.matchAllQuery()) .execute() .actionGet(); assertNotNull(response); assertTrue(response.isExists()); assertFalse(response.isMatch()); }
protected BoolFilterBuilder addTermFilter( BoolFilterBuilder filter, String field, @Nullable String value) { if (value != null && !value.isEmpty()) { filter.must(FilterBuilders.termFilter(field, value)); } return filter; }
@Test public void testDuplicateAlias() throws Exception { client() .admin() .indices() .preparePutTemplate("template_1") .setTemplate("te*") .addAlias(new Alias("my_alias").filter(FilterBuilders.termFilter("field", "value1"))) .addAlias(new Alias("my_alias").filter(FilterBuilders.termFilter("field", "value2"))) .get(); GetIndexTemplatesResponse response = client().admin().indices().prepareGetTemplates("template_1").get(); assertThat(response.getIndexTemplates().size(), equalTo(1)); assertThat(response.getIndexTemplates().get(0).getAliases().size(), equalTo(1)); assertThat( response.getIndexTemplates().get(0).getAliases().get("my_alias").filter().string(), containsString("\"value1\"")); }
private OrFilterBuilder buildAndFilter(String name, List<String> values) { OrFilterBuilder filterBuilder = FilterBuilders.orFilter(); values.forEach( e -> { TermFilterBuilder termFilterBuilder = FilterBuilders.termFilter(name, e); filterBuilder.add(termFilterBuilder); }); return filterBuilder; }
public void deleteByFile(String fileUuid) { SearchRequestBuilder searchRequest = esClient .prepareSearch(INDEX) .setTypes(TYPE) .setQuery( QueryBuilders.filteredQuery( QueryBuilders.matchAllQuery(), FilterBuilders.termFilter(FIELD_FILE_UUID, fileUuid).cache(false))); BulkIndexer.delete(esClient, INDEX, searchRequest); }
protected BoolFilterBuilder addTermFilter( BoolFilterBuilder filter, String field, @Nullable Collection<String> values) { if (values != null && !values.isEmpty()) { BoolFilterBuilder valuesFilter = FilterBuilders.boolFilter(); for (String value : values) { FilterBuilder valueFilter = FilterBuilders.termFilter(field, value); valuesFilter.should(valueFilter); } filter.must(valuesFilter); } return filter; }
public void deleteByProject(String projectUuid) { SearchRequestBuilder searchRequest = esClient .prepareSearch(INDEX) .setRouting(projectUuid) .setTypes(TYPE) .setQuery( QueryBuilders.filteredQuery( QueryBuilders.matchAllQuery(), FilterBuilders.termFilter(TestIndexDefinition.FIELD_PROJECT_UUID, projectUuid) .cache(false))); BulkIndexer.delete(esClient, INDEX, searchRequest); }
FilterBuilder getSessionFilter(SessionYear sessionYear) { return FilterBuilders.termFilter("sessionYear", sessionYear.getYear()); }
public ActiveRecordFilter() { TermFilterBuilder termFilter = FilterBuilders.termFilter("metaData.status", "active"); this.boolFilter = FilterBuilders.boolFilter().must(termFilter); }
@Test public void testClearCacheFilterKeys() { client().admin().indices().prepareDelete().execute().actionGet(); client() .admin() .indices() .prepareCreate("test") .setSettings(ImmutableSettings.settingsBuilder().put("index.number_of_shards", 1)) .execute() .actionGet(); client().prepareIndex("test", "type", "1").setSource("field", "value").execute().actionGet(); client().admin().indices().prepareRefresh().execute().actionGet(); NodesStatsResponse nodesStats = client().admin().cluster().prepareNodesStats().setIndices(true).execute().actionGet(); assertThat( nodesStats.getNodes()[0].getIndices().getFilterCache().getMemorySizeInBytes(), equalTo(0l)); IndicesStatsResponse indicesStats = client() .admin() .indices() .prepareStats("test") .clear() .setFilterCache(true) .execute() .actionGet(); assertThat(indicesStats.getTotal().getFilterCache().getMemorySizeInBytes(), equalTo(0l)); SearchResponse searchResponse = client() .prepareSearch() .setQuery( filteredQuery( matchAllQuery(), FilterBuilders.termFilter("field", "value").cacheKey("test_key"))) .execute() .actionGet(); assertThat(searchResponse.getHits().getHits().length, equalTo(1)); nodesStats = client().admin().cluster().prepareNodesStats().setIndices(true).execute().actionGet(); assertThat( nodesStats.getNodes()[0].getIndices().getFilterCache().getMemorySizeInBytes(), greaterThan(0l)); indicesStats = client() .admin() .indices() .prepareStats("test") .clear() .setFilterCache(true) .execute() .actionGet(); assertThat(indicesStats.getTotal().getFilterCache().getMemorySizeInBytes(), greaterThan(0l)); client().admin().indices().prepareClearCache().setFilterKeys("test_key").execute().actionGet(); nodesStats = client().admin().cluster().prepareNodesStats().setIndices(true).execute().actionGet(); assertThat( nodesStats.getNodes()[0].getIndices().getFilterCache().getMemorySizeInBytes(), equalTo(0l)); indicesStats = client() .admin() .indices() .prepareStats("test") .clear() .setFilterCache(true) .execute() .actionGet(); assertThat(indicesStats.getTotal().getFilterCache().getMemorySizeInBytes(), equalTo(0l)); }
@Test public void testClearAllCaches() throws Exception { client().admin().indices().prepareDelete().execute().actionGet(); client() .admin() .indices() .prepareCreate("test") .setSettings( ImmutableSettings.settingsBuilder() .put("index.number_of_replicas", 0) .put("index.number_of_shards", 1)) .execute() .actionGet(); client().admin().cluster().prepareHealth().setWaitForGreenStatus().execute().actionGet(); client().prepareIndex("test", "type", "1").setSource("field", "value1").execute().actionGet(); client().prepareIndex("test", "type", "2").setSource("field", "value2").execute().actionGet(); client().admin().indices().prepareRefresh().execute().actionGet(); NodesStatsResponse nodesStats = client().admin().cluster().prepareNodesStats().setIndices(true).execute().actionGet(); assertThat( nodesStats.getNodes()[0].getIndices().getFieldData().getMemorySizeInBytes(), equalTo(0l)); assertThat( nodesStats.getNodes()[0].getIndices().getFilterCache().getMemorySizeInBytes(), equalTo(0l)); IndicesStatsResponse indicesStats = client() .admin() .indices() .prepareStats("test") .clear() .setFieldData(true) .setFilterCache(true) .execute() .actionGet(); assertThat(indicesStats.getTotal().getFieldData().getMemorySizeInBytes(), equalTo(0l)); assertThat(indicesStats.getTotal().getFilterCache().getMemorySizeInBytes(), equalTo(0l)); // sort to load it to field data and filter to load filter cache client() .prepareSearch() .setFilter(FilterBuilders.termFilter("field", "value1")) .addSort("field", SortOrder.ASC) .execute() .actionGet(); client() .prepareSearch() .setFilter(FilterBuilders.termFilter("field", "value2")) .addSort("field", SortOrder.ASC) .execute() .actionGet(); nodesStats = client().admin().cluster().prepareNodesStats().setIndices(true).execute().actionGet(); assertThat( nodesStats.getNodes()[0].getIndices().getFieldData().getMemorySizeInBytes(), greaterThan(0l)); assertThat( nodesStats.getNodes()[0].getIndices().getFilterCache().getMemorySizeInBytes(), greaterThan(0l)); indicesStats = client() .admin() .indices() .prepareStats("test") .clear() .setFieldData(true) .setFilterCache(true) .execute() .actionGet(); assertThat(indicesStats.getTotal().getFieldData().getMemorySizeInBytes(), greaterThan(0l)); assertThat(indicesStats.getTotal().getFilterCache().getMemorySizeInBytes(), greaterThan(0l)); client().admin().indices().prepareClearCache().execute().actionGet(); Thread.sleep(100); // Make sure the filter cache entries have been removed... nodesStats = client().admin().cluster().prepareNodesStats().setIndices(true).execute().actionGet(); assertThat( nodesStats.getNodes()[0].getIndices().getFieldData().getMemorySizeInBytes(), equalTo(0l)); assertThat( nodesStats.getNodes()[0].getIndices().getFilterCache().getMemorySizeInBytes(), equalTo(0l)); indicesStats = client() .admin() .indices() .prepareStats("test") .clear() .setFieldData(true) .setFilterCache(true) .execute() .actionGet(); assertThat(indicesStats.getTotal().getFieldData().getMemorySizeInBytes(), equalTo(0l)); assertThat(indicesStats.getTotal().getFilterCache().getMemorySizeInBytes(), equalTo(0l)); }
public static void parseOutputAggregation( AdvancedQueryPojo.QueryOutputPojo.AggregationOutputPojo aggregation, AliasLookupTable aliasLookup, boolean geoLowAccuracy, String[] entTypeFilterStrings, String[] assocVerbFilterStrings, SearchRequestBuilder searchSettings, BoolFilterBuilder parentFilterObj, String[] communityIdStrs) { // 1.] Go through aggregation list // 1.1] Apply "simple specifications" if necessary // Geo if ((null != aggregation) && (null != aggregation.geoNumReturn) && (aggregation.geoNumReturn > 0)) { CrossVersionFacetBuilder.TermsFacetBuilder fb = CrossVersionFacetBuilders.termsFacet("geo") .field(DocumentPojo.locs_) .size(aggregation.geoNumReturn); // Gross raw handling for facets if (null != parentFilterObj) { fb = fb.facetFilter(parentFilterObj); } searchSettings.addFacet(fb); } // (TESTED) // Temporal if ((null != aggregation) && (null != aggregation.timesInterval)) { if (aggregation.timesInterval.contains("m")) { aggregation.timesInterval = "month"; } CrossVersionFacetBuilder.DateHistogramFacetBuilder fb = CrossVersionFacetBuilders.dateHistogramFacet("time") .field(DocumentPojo.publishedDate_) .interval(aggregation.timesInterval); // Gross raw handling for facets if (null != parentFilterObj) { fb = fb.facetFilter(parentFilterObj); } searchSettings.addFacet(fb); // TODO (INF-2688): if using certain types of moments then don't want this? } // (TESTED) // Temporal Moments if ((null != aggregation) && (null != aggregation.moments)) { if (null == aggregation.moments.timesInterval) { if (null != aggregation.timesInterval) { aggregation.moments.timesInterval = aggregation.timesInterval; } else { aggregation.moments.timesInterval = "m"; } } if (aggregation.moments.timesInterval.contains("m")) { aggregation.moments.timesInterval = "month"; } // TODO (INF-2688): Other cross filter type things if (!geoLowAccuracy && (null != aggregation.moments.geoNumReturn) && (aggregation.moments.geoNumReturn > 0)) { DateHistogramBuilder timeAgg = AggregationBuilders.dateHistogram("moments") .field(DocumentPojo.publishedDate_) .interval(new Interval(aggregation.moments.timesInterval)); TermsBuilder geoAgg = AggregationBuilders.terms("geo") .field(DocumentPojo.locs_) .size(aggregation.moments.geoNumReturn); timeAgg.subAggregation(geoAgg); searchSettings.addAggregation(timeAgg); } // TODO (CORE-89) if (null != aggregation.moments.associationsNumReturn && aggregation.moments.associationsNumReturn >= 0) { // TODO need to check if indexes mapping use doc.associations.assoc_index == docValue // fail out or don't include those communities if they don't if (validateAssociationMapping(communityIdStrs)) { DateHistogramBuilder assocTimeAgg = AggregationBuilders.dateHistogram("moments.assoc") .field(DocumentPojo.publishedDate_) .interval(new Interval(aggregation.moments.timesInterval)); TermsBuilder assocAgg = AggregationBuilders.terms("assoc") .field(AssociationPojo.assoc_index_) .size(aggregation.moments.associationsNumReturn); NestedBuilder nested = AggregationBuilders.nested("moments.assoc.nested") .path(DocumentPojo.associations_) .subAggregation(assocAgg); assocTimeAgg.subAggregation(nested); searchSettings.addAggregation(assocTimeAgg); } } if (null != aggregation.moments.entityList) { for (String entIndex : aggregation.moments.entityList) { CrossVersionFacetBuilder.DateHistogramFacetBuilder fb = CrossVersionFacetBuilders.dateHistogramFacet("moments." + entIndex) .field(DocumentPojo.publishedDate_) .interval(aggregation.moments.timesInterval); EntityFeaturePojo alias = null; if (null != aliasLookup) { alias = aliasLookup.getAliases(entIndex); } if (null == alias) { // no alias fb = fb.facetFilter( FilterBuilders.nestedFilter( DocumentPojo.entities_, FilterBuilders.termFilter(EntityPojo.index_, entIndex))); } // TESTED else { QueryFilterBuilder qfb = null; if ((null != alias.getSemanticLinks()) && !alias.getSemanticLinks().isEmpty()) { BoolQueryBuilder qb = QueryBuilders.boolQuery(); for (String textAlias : alias.getSemanticLinks()) { qb = qb.should( CrossVersionQueryBuilders.matchPhraseQuery( DocumentPojo.fullText_, textAlias)); } qfb = FilterBuilders.queryFilter(qb); } // TESTED if (!alias.getAlias().isEmpty()) { NestedFilterBuilder nfb = FilterBuilders.nestedFilter( DocumentPojo.entities_, FilterBuilders.termsFilter(EntityPojo.index_, entIndex, alias.getAlias())); if (null == qfb) { fb = fb.facetFilter(nfb); } // TESTED else { BoolFilterBuilder bfb = FilterBuilders.boolFilter().should(nfb).should(qfb); fb = fb.facetFilter(bfb); } // TESTED } else if (null != qfb) { fb = fb.facetFilter(qfb); } // TESTED } // TESTED // Gross raw handling for facets if (null != parentFilterObj) { fb = fb.facetFilter(parentFilterObj); } searchSettings.addFacet(fb); } } // (end list over entities) } // TESTED // Entities - due to problems with significance, handled on a document by document basis, see // Significance helper class // Associations (Events/Facts) // Association verb category filter StringBuilder verbCatRegex = null; StringBuilder entTypeRegex = null; if (((null != aggregation) && (null != aggregation.eventsNumReturn) && (aggregation.eventsNumReturn > 0)) || ((null != aggregation) && (null != aggregation.factsNumReturn) && (aggregation.factsNumReturn > 0))) { if (null != entTypeFilterStrings) { boolean bNegative = false; if ('-' != entTypeFilterStrings[0].charAt(0)) { // positive filtering entTypeRegex = new StringBuilder("(?:"); } else { bNegative = true; entTypeRegex = new StringBuilder("(?!"); // (this is a lookahead but will be fine because of the .*/ in front of it) } for (String entType : entTypeFilterStrings) { if (bNegative && ('-' == entType.charAt(0))) { entType = entType.substring(1); } entType = entType.replace("|", "%7C"); entTypeRegex.append(".*?/").append(Pattern.quote(entType.toLowerCase())).append('|'); // (can't match greedily because of the 2nd instance of entity type) } entTypeRegex.setLength(entTypeRegex.length() - 1); // (remove trailing |) entTypeRegex.append(")"); if (bNegative) { entTypeRegex.append("[^|]*"); // (now the actual verb, if a -ve lookahead) } } // TESTED if (null != assocVerbFilterStrings) { boolean bNegative = false; if ('-' != assocVerbFilterStrings[0].charAt(0)) { // positive filtering verbCatRegex = new StringBuilder("\\|(?:"); } else { bNegative = true; verbCatRegex = new StringBuilder("\\|(?!"); // (this is a lookahead but will be fine because of the "^[^|]*\\" in front of it) // eg say I have -VERB then subject|VERB|object will match because if the } for (String assocVerbFilterString : assocVerbFilterStrings) { if (bNegative && ('-' == assocVerbFilterString.charAt(0))) { assocVerbFilterString = assocVerbFilterString.substring(1); } assocVerbFilterString = assocVerbFilterString.replace("|", "%7C"); verbCatRegex.append(Pattern.quote(assocVerbFilterString)).append('|'); } verbCatRegex.setLength(verbCatRegex.length() - 1); // (remove trailing |) verbCatRegex.append(")"); if (bNegative) { verbCatRegex.append("[^|]*"); // (now the actual verb, if a -ve lookahead) } } // TESTED } // TESTED (all combinations of 1/2 people, 1/2 verbs) if ((null != aggregation) && (null != aggregation.eventsNumReturn) && (aggregation.eventsNumReturn > 0)) { StringBuffer regex = new StringBuffer("^Event\\|"); if (null != entTypeRegex) { regex.append(entTypeRegex); } else { regex.append("[^|]*"); } if (null != verbCatRegex) { regex.append(verbCatRegex); } else if (null != entTypeRegex) { regex.append("\\|[^|]*"); } else { regex.append(".*"); } if (null != entTypeRegex) { regex.append("\\|").append(entTypeRegex); regex.append(".*"); } else { regex.append("\\|.*"); } // DEBUG // System.out.println("REGEX==" + regex.toString()); // TESTED (all combinations of 1/2 people, 1/2 verbs) CrossVersionFacetBuilder.TermsFacetBuilder fb = CrossVersionFacetBuilders.termsFacet("events") .field(AssociationPojo.assoc_index_) .size(aggregation.eventsNumReturn) .nested(DocumentPojo.associations_); fb.regex(regex.toString()); // Gross raw handling for facets if (null != parentFilterObj) { fb = fb.facetFilter(parentFilterObj); } searchSettings.addFacet(fb); } if ((null != aggregation) && (null != aggregation.factsNumReturn) && (aggregation.factsNumReturn > 0)) { StringBuffer regex = new StringBuffer("^Fact\\|"); if (null != entTypeRegex) { regex.append(entTypeRegex); } else { regex.append("[^|]*"); } if (null != verbCatRegex) { regex.append(verbCatRegex); } else if (null != entTypeRegex) { regex.append("\\|[^|]*"); } else { regex.append(".*"); } if (null != entTypeRegex) { regex.append("\\|").append(entTypeRegex); regex.append(".*"); } else { regex.append("\\|.*"); } // DEBUG // System.out.println("REGEX==" + regex.toString()); // TESTED (all combinations of 1/2 people, 1/2 verbs) CrossVersionFacetBuilder.TermsFacetBuilder fb = CrossVersionFacetBuilders.termsFacet("facts") .field(AssociationPojo.assoc_index_) .size(aggregation.factsNumReturn) .nested(DocumentPojo.associations_); fb.regex(regex.toString()); // Gross raw handling for facets if (null != parentFilterObj) { fb = fb.facetFilter(parentFilterObj); } searchSettings.addFacet(fb); } // Source management/monitoring if ((null != aggregation) && (null != aggregation.sourceMetadata) && (aggregation.sourceMetadata > 0)) { CrossVersionFacetBuilder.TermsFacetBuilder fb = CrossVersionFacetBuilders.termsFacet("sourceTags") .field(DocumentPojo.tags_) .size(aggregation.sourceMetadata) .facetFilter(parentFilterObj); CrossVersionFacetBuilder.TermsFacetBuilder fb1 = CrossVersionFacetBuilders.termsFacet("sourceTypes") .field(DocumentPojo.mediaType_) .size(aggregation.sourceMetadata) .facetFilter(parentFilterObj); // Gross raw handling for facets if (null != parentFilterObj) { fb = fb.facetFilter(parentFilterObj); fb1 = fb1.facetFilter(parentFilterObj); } searchSettings.addFacet(fb); searchSettings.addFacet(fb1); } if ((null != aggregation) && (null != aggregation.sources) && (aggregation.sources > 0)) { CrossVersionFacetBuilder.TermsFacetBuilder fb = CrossVersionFacetBuilders.termsFacet("sourceKeys") .field(DocumentPojo.sourceKey_) .size(aggregation.sources); // Gross raw handling for facets if (null != parentFilterObj) { fb = fb.facetFilter(parentFilterObj); } searchSettings.addFacet(fb); } } // TESTED
@Test public void testExternalValues() throws Exception { prepareCreate("test-idx") .addMapping( "type", XContentFactory.jsonBuilder() .startObject() .startObject("type") .startObject(ExternalRootMapper.CONTENT_TYPE) .endObject() .startObject("properties") .startObject("field") .field("type", RegisterExternalTypes.EXTERNAL) .endObject() .endObject() .endObject() .endObject()) .execute() .get(); ensureYellow("test-idx"); index( "test-idx", "type", "1", XContentFactory.jsonBuilder().startObject().field("field", "1234").endObject()); refresh(); SearchResponse response; response = client() .prepareSearch("test-idx") .setPostFilter(FilterBuilders.termFilter("field.bool", "T")) .execute() .actionGet(); assertThat(response.getHits().totalHits(), equalTo((long) 1)); response = client() .prepareSearch("test-idx") .setPostFilter( FilterBuilders.geoDistanceRangeFilter("field.point").point(42.0, 51.0).to("1km")) .execute() .actionGet(); assertThat(response.getHits().totalHits(), equalTo((long) 1)); response = client() .prepareSearch("test-idx") .setPostFilter( FilterBuilders.geoShapeFilter( "field.shape", ShapeBuilder.newPoint(-100, 45), ShapeRelation.WITHIN)) .execute() .actionGet(); assertThat(response.getHits().totalHits(), equalTo((long) 1)); response = client() .prepareSearch("test-idx") .setPostFilter(FilterBuilders.termFilter("field.field", "foo")) .execute() .actionGet(); assertThat(response.getHits().totalHits(), equalTo((long) 1)); }