Manage filters for multi string

Add back the es types based on classes on the query helper.

Author: Luc Boutier

elasticsearch-mapping/src/main/java/org/elasticsearch/mapping/FieldsMappingBuilder.java

@@ -223,18 +223,10 @@ private void processFilterAnnotation(List<IFilterBuilderHelper> classFilters, St
             }
             for (String path : paths) {
                 path = path.trim();
-                boolean isAnalyzed = isAnalyzed(indexable);
-                String nestedPath = indexable.getAnnotation(NestedObject.class) == null ? null : esFieldName;
-                if (nestedPath == null) {
-                    int nestedIndicator = esFieldName.lastIndexOf(".");
-                    if (nestedIndicator > 0) {
-                        nestedPath = esFieldName.substring(0, nestedIndicator);
-                        esFieldName = esFieldName.substring(nestedIndicator + 1, esFieldName.length());
-                    }
+                addFilter(classFilters, esFieldName, indexable, path, isAnalyzed(indexable, null));
+                for (String alternateFieldName : alternateFieldNames(indexable)) {
+                    addFilter(classFilters, alternateFieldName, indexable, path, isAnalyzed(indexable, alternateFieldName));
                 }
-                String filterPath = getFilterPath(path, esFieldName);
-
-                classFilters.add(new TermsFilterBuilderHelper(isAnalyzed, nestedPath, filterPath));
             }
             return;
         }
@@ -245,6 +237,20 @@ private void processFilterAnnotation(List<IFilterBuilderHelper> classFilters, St
         }
     }
 
+    private void addFilter(List<IFilterBuilderHelper> classFilters, String esFieldName, Indexable indexable, String path, boolean isAnalyzed) {
+        String nestedPath = indexable.getAnnotation(NestedObject.class) == null ? null : esFieldName;
+        if (nestedPath == null) {
+            int nestedIndicator = esFieldName.lastIndexOf(".");
+            if (nestedIndicator > 0) {
+                nestedPath = esFieldName.substring(0, nestedIndicator);
+                esFieldName = esFieldName.substring(nestedIndicator + 1, esFieldName.length());
+            }
+        }
+        String filterPath = getFilterPath(path, esFieldName);
+
+        classFilters.add(new TermsFilterBuilderHelper(isAnalyzed, nestedPath, filterPath));
+    }
+
     private void processFacetAnnotation(List<IFacetBuilderHelper> classFacets, List<IFilterBuilderHelper> classFilters, String esFieldName,
             Indexable indexable) {
         TermsFacet termsFacet = indexable.getAnnotation(TermsFacet.class);
@@ -263,17 +269,11 @@ private void processFacetAnnotation(List<IFacetBuilderHelper> classFacets, List<
             }
             for (String path : paths) {
                 path = path.trim();
-                boolean isAnalyzed = isAnalyzed(indexable);
-                String nestedPath = indexable.getAnnotation(NestedObject.class) == null ? null : esFieldName;
-                String filterPath = getFilterPath(path, esFieldName);
-
-                IFacetBuilderHelper facetBuilderHelper = new TermsAggregationBuilderHelper(isAnalyzed, nestedPath, filterPath, termsFacet);
-                classFacets.add(facetBuilderHelper);
-                if (classFilters.contains(facetBuilderHelper)) {
-                    classFilters.remove(facetBuilderHelper);
-                    LOGGER.warn("Field <" + esFieldName + "> already had a filter that will be replaced by the defined facet. Only a single one is allowed.");
+
+                addAggregation(termsFacet, indexable, esFieldName, path, isAnalyzed(indexable, null), classFacets, classFilters);
+                for (String alternateFieldName : alternateFieldNames(indexable)) {
+                    addAggregation(termsFacet, indexable, alternateFieldName, path, isAnalyzed(indexable, alternateFieldName), classFacets, classFilters);
                 }
-                classFilters.add(facetBuilderHelper);
             }
             return;
         }
@@ -293,15 +293,50 @@ private String getFilterPath(String path, String esFieldName) {
         return path.isEmpty() ? esFieldName : esFieldName + "." + path;
     }
 
-    private boolean isAnalyzed(Indexable indexable) {
+    private boolean isAnalyzed(Indexable indexable, String name) {
         boolean isAnalysed = true;
+        StringFieldMulti multiAnnotation = indexable.getAnnotation(StringFieldMulti.class);
+        if (multiAnnotation != null) {
+            if (name == null) {
+                return IndexType.analyzed.equals(multiAnnotation.main().indexType());
+            } else {
+                for (int i = 0; i < multiAnnotation.multiNames().length; i++) {
+                    if (multiAnnotation.multiNames()[i].equals(name)) {
+                        return IndexType.analyzed.equals(multiAnnotation.multi()[i].indexType());
+                    }
+                }
+            }
+        }
+
         StringField stringFieldAnnotation = indexable.getAnnotation(StringField.class);
-        if (stringFieldAnnotation != null && !IndexType.analyzed.equals(stringFieldAnnotation.indexType())) {
-            isAnalysed = false;
+        if (stringFieldAnnotation != null) {
+            return IndexType.analyzed.equals(stringFieldAnnotation.indexType());
         }
         return isAnalysed;
     }
 
+    private void addAggregation(TermsFacet termsFacet, Indexable indexable, String esFieldName, String path, boolean isAnalyzed,
+            List<IFacetBuilderHelper> classFacets, List<IFilterBuilderHelper> classFilters) {
+        String nestedPath = indexable.getAnnotation(NestedObject.class) == null ? null : esFieldName;
+        String filterPath = getFilterPath(path, esFieldName);
+
+        IFacetBuilderHelper facetBuilderHelper = new TermsAggregationBuilderHelper(isAnalyzed, nestedPath, filterPath, termsFacet);
+        classFacets.add(facetBuilderHelper);
+        if (classFilters.contains(facetBuilderHelper)) {
+            classFilters.remove(facetBuilderHelper);
+            LOGGER.warn("Field <" + esFieldName + "> already had a filter that will be replaced by the defined facet. Only a single one is allowed.");
+        }
+        classFilters.add(facetBuilderHelper);
+    }
+
+    private String[] alternateFieldNames(Indexable indexable) {
+        StringFieldMulti multi = indexable.getAnnotation(StringFieldMulti.class);
+        if (multi == null) {
+            return new String[0];
+        }
+        return multi.multiNames();
+    }
+
     private void processStringOrPrimitive(Class<?> clazz, Map<String, Object> propertiesDefinitionMap, String pathPrefix, Indexable indexable) {
         processFieldAnnotation(IndexName.class, new IndexNameAnnotationParser(), propertiesDefinitionMap, pathPrefix, indexable);
         processFieldAnnotation(NullValue.class, new NullValueAnnotationParser(), propertiesDefinitionMap, pathPrefix, indexable);

elasticsearch-mapping/src/main/java/org/elasticsearch/mapping/QueryHelper.java

@@ -412,6 +412,7 @@ private FilterBuilder getAndFilter(List<FilterBuilder> filters) {
 
         @Override
         public SearchResponse execute(int from, int size) {
+            searchRequestBuilder.setTypes(getTypes());
             if (prefixField == null) {
                 if (!fieldSort) {
                     searchRequestBuilder.addSort(SortBuilders.scoreSort());
@@ -422,6 +423,22 @@ public SearchResponse execute(int from, int size) {
             return searchRequestBuilder.setFrom(from).setSize(size).execute().actionGet();
         }
 
+        protected String[] getTypes() {
+            if (this.classes == null) {
+                return null;
+            }
+            List<String> types = new ArrayList<String>(this.classes.length);
+            for (Class<?> clazz : classes) {
+                if (clazz != null) {
+                    types.add(MappingBuilder.indexTypeFromClass(clazz));
+                }
+            }
+            if (types.isEmpty()) {
+                return null;
+            }
+            return types.toArray(new String[types.size()]);
+        }
+
         @Override
         public SearchRequestBuilder getSearchRequestBuilder() {
             return searchRequestBuilder;
@@ -445,7 +462,7 @@ public QueryBuilderHelper fieldSort(String fieldName, boolean desc) {
             } else {
                 sortBuilder.order(SortOrder.ASC);
             }
-            // TODO: chenged to use sortBuilder.unmappedType
+            // TODO: change to use sortBuilder.unmappedType
             sortBuilder.ignoreUnmapped(true);
             searchRequestBuilder.addSort(sortBuilder);
             return this;