/**
* @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));
}
