Query DSL: nested filter support, closes #1102.

modules/elasticsearch/src/main/java/org/elasticsearch/index/query/FilterBuilders.java

@@ -42,6 +42,14 @@ public abstract class FilterBuilders {
         return new LimitFilterBuilder(limit);
     }
 
+    public static NestedFilterBuilder nestedFilter(String path, QueryBuilder query) {
+        return new NestedFilterBuilder(path, query);
+    }
+
+    public static NestedFilterBuilder nestedFilter(String path, FilterBuilder filter) {
+        return new NestedFilterBuilder(path, filter);
+    }
+
     /**
      * Creates a new ids filter with the provided doc/mapping types.
      *

modules/elasticsearch/src/main/java/org/elasticsearch/index/query/NestedFilterBuilder.java

@@ -0,0 +1,93 @@
+/*
+ * Licensed to Elastic Search and Shay Banon under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. Elastic Search licenses this
+ * file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.index.query;
+
+import org.elasticsearch.common.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+public class NestedFilterBuilder extends BaseFilterBuilder {
+
+    private final QueryBuilder queryBuilder;
+    private final FilterBuilder filterBuilder;
+
+    private final String path;
+
+    private String scope;
+
+    private Boolean cache;
+    private String filterName;
+
+    public NestedFilterBuilder(String path, QueryBuilder queryBuilder) {
+        this.path = path;
+        this.queryBuilder = queryBuilder;
+        this.filterBuilder = null;
+    }
+
+    public NestedFilterBuilder(String path, FilterBuilder filterBuilder) {
+        this.path = path;
+        this.queryBuilder = null;
+        this.filterBuilder = filterBuilder;
+    }
+
+
+    public NestedFilterBuilder scope(String scope) {
+        this.scope = scope;
+        return this;
+    }
+
+    /**
+     * Should the filter be cached or not. Defaults to <tt>false</tt>.
+     */
+    public NestedFilterBuilder cache(boolean cache) {
+        this.cache = cache;
+        return this;
+    }
+
+    /**
+     * Sets the filter name for the filter that can be used when searching for matched_filters per hit.
+     */
+    public NestedFilterBuilder filterName(String filterName) {
+        this.filterName = filterName;
+        return this;
+    }
+
+    @Override protected void doXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(NestedFilterParser.NAME);
+        if (queryBuilder != null) {
+            builder.field("query");
+            queryBuilder.toXContent(builder, params);
+        } else {
+            builder.field("filter");
+            filterBuilder.toXContent(builder, params);
+        }
+        builder.field("path", path);
+        if (scope != null) {
+            builder.field("_scope", scope);
+        }
+        if (filterName != null) {
+            builder.field("_name", filterName);
+        }
+        if (cache != null) {
+            builder.field("_cache", cache);
+        }
+        builder.endObject();
+    }
+}

modules/elasticsearch/src/main/java/org/elasticsearch/index/query/NestedFilterParser.java

@@ -0,0 +1,174 @@
+/*
+ * Licensed to Elastic Search and Shay Banon under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. Elastic Search licenses this
+ * file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.index.query;
+
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.search.DeletionAwareConstantScoreQuery;
+import org.apache.lucene.search.DocIdSet;
+import org.apache.lucene.search.Filter;
+import org.apache.lucene.search.FilteredQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.QueryWrapperFilter;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.inject.Inject;
+import org.elasticsearch.common.xcontent.XContentParser;
+import org.elasticsearch.index.mapper.MapperService;
+import org.elasticsearch.index.mapper.object.ObjectMapper;
+import org.elasticsearch.index.search.nested.BlockJoinQuery;
+import org.elasticsearch.index.search.nested.NonNestedDocsFilter;
+import org.elasticsearch.search.internal.SearchContext;
+
+import java.io.IOException;
+
+public class NestedFilterParser implements FilterParser {
+
+    public static final String NAME = "nested";
+
+    @Inject public NestedFilterParser() {
+    }
+
+    @Override public String[] names() {
+        return new String[]{NAME, Strings.toCamelCase(NAME)};
+    }
+
+    @Override public Filter parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
+        XContentParser parser = parseContext.parser();
+
+        Query query = null;
+        Filter filter = null;
+        float boost = 1.0f;
+        String scope = null;
+        String path = null;
+        boolean cache = false;
+        String filterName = null;
+
+        // we need a late binding filter so we can inject a parent nested filter inner nested queries
+        LateBindingParentFilter currentParentFilterContext = parentFilterContext.get();
+
+        LateBindingParentFilter usAsParentFilter = new LateBindingParentFilter();
+        parentFilterContext.set(usAsParentFilter);
+
+        String currentFieldName = null;
+        XContentParser.Token token;
+        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+            if (token == XContentParser.Token.FIELD_NAME) {
+                currentFieldName = parser.currentName();
+            } else if (token == XContentParser.Token.START_OBJECT) {
+                if ("query".equals(currentFieldName)) {
+                    query = parseContext.parseInnerQuery();
+                } else if ("filter".equals(currentFieldName)) {
+                    filter = parseContext.parseInnerFilter();
+                }
+            } else if (token.isValue()) {
+                if ("path".equals(currentFieldName)) {
+                    path = parser.text();
+                } else if ("boost".equals(currentFieldName)) {
+                    boost = parser.floatValue();
+                } else if ("_scope".equals(currentFieldName)) {
+                    scope = parser.text();
+                } else if ("_name".equals(currentFieldName)) {
+                    filterName = parser.text();
+                } else if ("_cache".equals(currentFieldName)) {
+                    cache = parser.booleanValue();
+                }
+            }
+        }
+        if (query == null && filter == null) {
+            throw new QueryParsingException(parseContext.index(), "[nested] requires either 'query' or 'filter' field");
+        }
+        if (path == null) {
+            throw new QueryParsingException(parseContext.index(), "[nested] requires 'path' field");
+        }
+
+        if (filter != null) {
+            query = new DeletionAwareConstantScoreQuery(filter);
+        }
+
+        query.setBoost(boost);
+
+        MapperService.SmartNameObjectMapper mapper = parseContext.mapperService().smartNameObjectMapper(path);
+        if (mapper == null) {
+            throw new QueryParsingException(parseContext.index(), "[nested] failed to find nested object under path [" + path + "]");
+        }
+        ObjectMapper objectMapper = mapper.mapper();
+        if (objectMapper == null) {
+            throw new QueryParsingException(parseContext.index(), "[nested] failed to find nested object under path [" + path + "]");
+        }
+        if (!objectMapper.nested().isNested()) {
+            throw new QueryParsingException(parseContext.index(), "[nested] nested object under path [" + path + "] is not of nested type");
+        }
+
+        Filter childFilter = parseContext.cacheFilter(objectMapper.nestedTypeFilter());
+        usAsParentFilter.filter = childFilter;
+        // wrap the child query to only work on the nested path type
+        query = new FilteredQuery(query, childFilter);
+
+        Filter parentFilter = currentParentFilterContext;
+        if (parentFilter == null) {
+            parentFilter = NonNestedDocsFilter.INSTANCE;
+            if (mapper.hasDocMapper()) {
+                // filter based on the type...
+                parentFilter = mapper.docMapper().typeFilter();
+            }
+            parentFilter = parseContext.cacheFilter(parentFilter);
+        }
+
+        // restore the thread local one...
+        parentFilterContext.set(currentParentFilterContext);
+
+        BlockJoinQuery joinQuery = new BlockJoinQuery(query, parentFilter, BlockJoinQuery.ScoreMode.None);
+
+        if (scope != null) {
+            SearchContext.current().addNestedQuery(scope, joinQuery);
+        }
+
+        Filter joinFilter = new QueryWrapperFilter(joinQuery);
+        if (cache) {
+            joinFilter = parseContext.cacheFilter(joinFilter);
+        }
+        if (filterName != null) {
+            parseContext.addNamedFilter(filterName, joinFilter);
+        }
+        return joinFilter;
+    }
+
+    static ThreadLocal<LateBindingParentFilter> parentFilterContext = new ThreadLocal<LateBindingParentFilter>();
+
+    static class LateBindingParentFilter extends Filter {
+
+        Filter filter;
+
+        @Override public int hashCode() {
+            return filter.hashCode();
+        }
+
+        @Override public boolean equals(Object obj) {
+            return filter.equals(obj);
+        }
+
+        @Override public String toString() {
+            return filter.toString();
+        }
+
+        @Override public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
+            return filter.getDocIdSet(reader);
+        }
+    }
+}

modules/elasticsearch/src/main/java/org/elasticsearch/index/query/NestedQueryBuilder.java

@@ -26,8 +26,9 @@ import java.io.IOException;
 public class NestedQueryBuilder extends BaseQueryBuilder {
 
     private final QueryBuilder queryBuilder;
+    private final FilterBuilder filterBuilder;
 
-    private String path;
+    private final String path;
 
     private String scoreMode;
 
@@ -38,6 +39,13 @@ public class NestedQueryBuilder extends BaseQueryBuilder {
     public NestedQueryBuilder(String path, QueryBuilder queryBuilder) {
         this.path = path;
         this.queryBuilder = queryBuilder;
+        this.filterBuilder = null;
+    }
+
+    public NestedQueryBuilder(String path, FilterBuilder filterBuilder) {
+        this.path = path;
+        this.queryBuilder = null;
+        this.filterBuilder = filterBuilder;
     }
 
     /**
@@ -64,8 +72,13 @@ public class NestedQueryBuilder extends BaseQueryBuilder {
 
     @Override protected void doXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject(NestedQueryParser.NAME);
-        builder.field("query");
-        queryBuilder.toXContent(builder, params);
+        if (queryBuilder != null) {
+            builder.field("query");
+            queryBuilder.toXContent(builder, params);
+        } else {
+            builder.field("filter");
+            filterBuilder.toXContent(builder, params);
+        }
         builder.field("path", path);
         if (scoreMode != null) {
             builder.field("score_mode", scoreMode);

modules/elasticsearch/src/main/java/org/elasticsearch/index/query/QueryBuilders.java

@@ -476,6 +476,10 @@ public abstract class QueryBuilders {
         return new NestedQueryBuilder(path, query);
     }
 
+    public static NestedQueryBuilder nestedQuery(String path, FilterBuilder filter) {
+        return new NestedQueryBuilder(path, filter);
+    }
+
     /**
      * A filer for a field based on several terms matching on any of them.
      *

modules/elasticsearch/src/main/java/org/elasticsearch/indices/query/IndicesQueriesRegistry.java

@@ -71,6 +71,7 @@ public class IndicesQueriesRegistry {
 
         Map<String, FilterParser> filterParsers = Maps.newHashMap();
         addFilterParser(filterParsers, new HasChildFilterParser());
+        addFilterParser(filterParsers, new NestedFilterParser());
         addFilterParser(filterParsers, new TypeFilterParser());
         addFilterParser(filterParsers, new IdsFilterParser());
         addFilterParser(filterParsers, new LimitFilterParser());

modules/test/integration/src/test/java/org/elasticsearch/test/integration/nested/SimpleNestedTests.java

@@ -35,6 +35,7 @@ import org.testng.annotations.Test;
 import java.util.Arrays;
 
 import static org.elasticsearch.common.xcontent.XContentFactory.*;
+import static org.elasticsearch.index.query.FilterBuilders.*;
 import static org.elasticsearch.index.query.QueryBuilders.*;
 import static org.hamcrest.MatcherAssert.*;
 import static org.hamcrest.Matchers.*;
@@ -135,6 +136,12 @@ public class SimpleNestedTests extends AbstractNodesTests {
         assertThat(Arrays.toString(searchResponse.shardFailures()), searchResponse.failedShards(), equalTo(0));
         assertThat(searchResponse.hits().totalHits(), equalTo(1l));
 
+        // filter
+        searchResponse = client.prepareSearch("test").setQuery(filteredQuery(matchAllQuery(), nestedFilter("nested1",
+                boolQuery().must(termQuery("nested1.n_field1", "n_value1_1")).must(termQuery("nested1.n_field2", "n_value2_1"))))).execute().actionGet();
+        assertThat(Arrays.toString(searchResponse.shardFailures()), searchResponse.failedShards(), equalTo(0));
+        assertThat(searchResponse.hits().totalHits(), equalTo(1l));
+
         // check with type prefix
         searchResponse = client.prepareSearch("test").setQuery(nestedQuery("type1.nested1",
                 boolQuery().must(termQuery("nested1.n_field1", "n_value1_1")).must(termQuery("nested1.n_field2", "n_value2_1")))).execute().actionGet();