Issue searchbox-io#146 Adding aggregation support

I have create two ways to get aggregation data from a search response.

1) End user can provide a map of names to the aggregation types
expected to be returned. This takes the place of the _type metadata
returned in faceting. This map does not need to be in any particular
order, but each aggregation will search through and see if it has
any matching sub-aggregations matching the names present and populate
them as needed. It is important to note that using this method we
will ONLY return aggregations specified by the user in this map.

2) Type invariant aggregations can be requested. This method will simply return a
list of TypeInvariantAggregations. This is recommended if the user is unsure of
the Aggregations supplied, or simply wants a representation of all data returned
in the aggregation. This module introduces some danger and requires responsibility
on the user's part. The intended use is to call the getAggregationFields() method
to get a list of all AggregationFields contained. The user is only assured
that those particular methods will return non-null results.

**TODO**

* Polish off these methods-- this is meant to be a rough draft of the Aggregations module
in order to get rapid feedback

* Add testing over the Aggregation module

jest-common/src/main/java/io/searchbox/core/SearchResult.java

@@ -4,6 +4,8 @@
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import io.searchbox.client.JestResult;
+import io.searchbox.core.search.aggregation.Aggregation;
+import io.searchbox.core.search.aggregation.TypeInvariantAggregation;
 import io.searchbox.core.search.facet.Facet;
 
 import java.lang.reflect.Constructor;
@@ -176,6 +178,79 @@ public <T extends Facet> List<T> getFacets(Class<T> type) {
         return facets;
     }
 
+    /**
+     *
+     * @param nameToTypeMap A map of all the names expected to be found in the
+     *                      aggregation results to the expected return type.
+     *                      This map takes the place of the _type metadata
+     *                      previously provided in results from faceting.
+     * @return A map from the name of the aggregation expected in the return to
+     * that aggregation.
+     */
+    public <T extends Aggregation> Map<String, T> getAggregations(Map<String, Class<T>> nameToTypeMap) {
+        Map<String, T> nameToAggregationMap = new HashMap<String, T>();
+        if(jsonObject != null) {
+            Constructor<T> c;
+            try {
+                JsonObject aggregationsMap;
+                if (jsonObject.has("aggregations")) {
+                    aggregationsMap = (JsonObject) jsonObject.get("aggregations");
+                } else if (jsonObject.has("aggs")) {
+                    aggregationsMap = (JsonObject) jsonObject.get("aggs");
+                } else {
+                    return nameToAggregationMap;
+                }
+                for (Map.Entry<String, JsonElement> aggregationEntry: aggregationsMap.entrySet()) {
+                    String name = aggregationEntry.getKey();
+                    JsonObject aggregation = aggregationEntry.getValue().getAsJsonObject();
+                    Class<T> type = nameToTypeMap.get(name);
+
+                    c = type.getConstructor(String.class, JsonObject.class, Map.class);
+                    nameToAggregationMap.put(name, c.newInstance(name, aggregationEntry.getValue(), nameToTypeMap));
+                }
+                return nameToAggregationMap;
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return nameToAggregationMap;
+    }
+
+    /**
+     * Because aggregations no longer return the _type metadata,
+     * it is impossible to determine the type of an aggregation
+     * based on the json alone.
+     *
+     * The intended use is for the user to call Aggregation.getFields() to
+     * determine the non-null fields before calling the get method for these values.
+     * Sub aggregations can be iterated recursively in the same manner
+     *
+     * @return A list of non-typed aggregation objects.
+     */
+    public List<TypeInvariantAggregation> getAggregations() {
+        List<TypeInvariantAggregation> aggregations = new ArrayList<TypeInvariantAggregation>();
+        if (jsonObject != null) {
+            try {
+                JsonObject aggregationsMap;
+                if (jsonObject.has("aggregations")) {
+                    aggregationsMap = (JsonObject) jsonObject.get("aggregations");
+                } else if (jsonObject.has("aggs")) {
+                    aggregationsMap = (JsonObject) jsonObject.get("aggs");
+                } else {
+                    return aggregations;
+                }
+                for (Map.Entry<String, JsonElement> aggregationEntry : aggregationsMap.entrySet()) {
+                    TypeInvariantAggregation aggregation = new TypeInvariantAggregation(aggregationEntry.getKey(), aggregationEntry.getValue().getAsJsonObject());
+                    aggregations.add(aggregation);
+                }
+                return aggregations;
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return aggregations;
+    }
+
     /**
      * Immutable class representing a search hit.
      *

jest-common/src/main/java/io/searchbox/core/search/aggregation/Aggregation.java

@@ -0,0 +1,44 @@
+package io.searchbox.core.search.aggregation;
+
+import com.google.gson.JsonObject;
+
+import java.lang.reflect.Constructor;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author cfstout
+ */
+
+public abstract class Aggregation {
+
+    protected String name;
+    protected List<Aggregation> subAggregations;
+
+    public String getName() {
+        return name;
+    }
+
+    public List<Aggregation> getSubAggregations() {
+        return subAggregations;
+    }
+
+    public boolean hasSubAggregations() {
+        return !(subAggregations == null || subAggregations.isEmpty());
+    }
+
+    public <T extends Aggregation> void addSubAggregations(JsonObject rootAggregation, Map<String, Class<T>> nameToTypeMap) {
+        for (String nameCandidate : nameToTypeMap.keySet()) {
+            if (rootAggregation.has(nameCandidate)) {
+                try {
+                    Class<T> type = nameToTypeMap.get(name);
+                    Constructor<T> c = type.getConstructor(String.class, JsonObject.class, Map.class);
+                    this.subAggregations.add(c.newInstance(nameCandidate, rootAggregation.get(nameCandidate).getAsJsonObject(), nameToTypeMap));
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+}

jest-common/src/main/java/io/searchbox/core/search/aggregation/AggregationField.java

@@ -0,0 +1,48 @@
+package io.searchbox.core.search.aggregation;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author cfstout
+ */
+public enum AggregationField {
+    VALUE("value"),
+    BUCKETS("buckets"),
+    KEY("key"), //Can be String or Long
+    KEY_AS_STRING("key_as_string"),
+    DOC_COUNT("doc_count"),
+    FROM("from"),
+    TO("to"),
+    FROM_AS_STRING("from_as_string"),
+    TO_AS_STRING("to_as_string"),
+    SUM_OF_SQUARES("sum_of_squares"),
+    VARIANCE("variance"),
+    STD_DEVIATION("std_deviation"),
+    STD_DEVIATION_BOUNDS("std_deviation_bounds"),
+    BOUNDS("bounds"),
+    UNIT("unit"),
+    VALUES("values"),
+    SCORE("score"),
+    BG_COUNT("bg_count"), //Background Count
+    COUNT("count"),
+    MIN("min"),
+    MAX("max"),
+    AVG("avg"),
+    SUM("sum");
+
+    private final String field;
+
+    private AggregationField(String s) {
+        field = s;
+    }
+
+    public String toString() {
+        return field;
+    }
+
+    public boolean equals(String s) {
+        return s.equals(toString());
+    }
+}
+

jest-common/src/main/java/io/searchbox/core/search/aggregation/AvgAggregation.java

@@ -0,0 +1,26 @@
+package io.searchbox.core.search.aggregation;
+
+import com.google.gson.JsonObject;
+
+import java.lang.reflect.Constructor;
+import java.util.Map;
+
+/**
+ * @author cfstout
+ */
+public class AvgAggregation extends Aggregation {
+
+    public static final String TYPE = "avg";
+
+    private Double avg;
+
+    public <T extends Aggregation> AvgAggregation(String name, JsonObject avgAggregation, Map<String, Class<T>> nameToTypeMap) {
+        this.name = name;
+        avg = avgAggregation.get("value").getAsDouble();
+        addSubAggregations(avgAggregation, nameToTypeMap);
+    }
+
+    public Double getAvg() {
+        return avg;
+    }
+}

jest-common/src/main/java/io/searchbox/core/search/aggregation/CardinalityAggregation.java

@@ -0,0 +1,26 @@
+package io.searchbox.core.search.aggregation;
+
+import com.google.gson.JsonObject;
+
+import java.util.Map;
+
+/**
+ * @author cfstout
+ */
+public class CardinalityAggregation extends Aggregation{
+
+    public static final String TYPE = "cardinality";
+
+    private Long cardinality;
+
+    public <T extends Aggregation> CardinalityAggregation(String name, JsonObject cardinalityAggregation, Map<String, Class<T>> nameToTypeMap) {
+        this.name = name;
+        cardinality = cardinalityAggregation.get("value").getAsLong();
+        addSubAggregations(cardinalityAggregation, nameToTypeMap);
+    }
+
+    public Long getCardinality() {
+        return cardinality;
+    }
+}
+

jest-common/src/main/java/io/searchbox/core/search/aggregation/DateHistogramAggregation.java

@@ -0,0 +1,53 @@
+package io.searchbox.core.search.aggregation;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author cfstout
+ */
+public class DateHistogramAggregation extends Aggregation{
+
+    public static final String TYPE = "date_histogram";
+
+    private List<DateHistogram> dateHistograms;
+
+    public <T extends Aggregation> DateHistogramAggregation(String name, JsonObject dateHistogramAggregation, Map<String, Class<T>> nameToTypeMap) {
+        this.name = name;
+        dateHistograms = new ArrayList<DateHistogram>();
+        for (JsonElement bucket : dateHistogramAggregation.get("buckets").getAsJsonArray()) {
+            JsonElement time = bucket.getAsJsonObject().get("key");
+            JsonElement timeAsString = bucket.getAsJsonObject().get("key_as_string");
+            JsonElement count = bucket.getAsJsonObject().get("doc_count");
+            DateHistogram histogram = new DateHistogram(time.getAsLong(), timeAsString.getAsString(), count.getAsLong());
+            dateHistograms.add(histogram);
+        }
+        addSubAggregations(dateHistogramAggregation, nameToTypeMap);
+    }
+
+    public List<DateHistogram> getDateHistograms() {
+        return dateHistograms;
+    }
+
+    public class DateHistogram extends HistogramAggregation.Histogram {
+
+        private String timeAsString;
+
+        DateHistogram(Long time, String timeAsString, Long count) {
+            super(time, count);
+            this.timeAsString = timeAsString;
+        }
+
+        public Long getTime() {
+            return getKey();
+        }
+
+        public String getTimeAsString() {
+            return timeAsString;
+        }
+    }
+}

jest-common/src/main/java/io/searchbox/core/search/aggregation/DateRangeAggregation.java

@@ -0,0 +1,58 @@
+package io.searchbox.core.search.aggregation;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author cfstout
+ */
+public class DateRangeAggregation extends Aggregation {
+
+    public static final String TYPE = "date_range";
+
+    private List<DateRange> ranges;
+
+    public <T extends Aggregation> DateRangeAggregation(String name, JsonObject dateRangeAggregation, Map<String, Class<T>> nameToTypeMap) {
+        this.name = name;
+        ranges = new ArrayList<DateRange>();
+        //todo support keyed:true as well
+        for (JsonElement bucketv : dateRangeAggregation.get("buckets").getAsJsonArray()) {
+            JsonObject bucket = bucketv.getAsJsonObject();
+            DateRange range = new DateRange(
+                    bucket.has("from") ? bucket.get("from").getAsDouble() : null,
+                    bucket.has("to") ? bucket.get("to").getAsDouble() : null,
+                    bucket.has("doc_count") ? bucket.get("doc_count").getAsLong() : null,
+                    bucket.has("from_as_string") ? bucket.get("from_as_string").getAsString() : null,
+                    bucket.has("to_as_string") ? bucket.get("to_as_string").getAsString() : null);
+            ranges.add(range);
+        }
+        addSubAggregations(dateRangeAggregation, nameToTypeMap);
+    }
+
+    public List<DateRange> getRanges() {
+        return ranges;
+    }
+
+    public class DateRange extends RangeAggregation.Range {
+        private String fromAsString;
+        private String toAsString;
+
+        public DateRange(Double from, Double to, Long count, String fromString, String toString){
+            super(from, to, count);
+            this.fromAsString = fromString;
+            this.toAsString = toString;
+        }
+
+        public String getFromAsString() {
+            return fromAsString;
+        }
+
+        public String getToAsString() {
+            return toAsString;
+        }
+    }
+}

jest-common/src/main/java/io/searchbox/core/search/aggregation/DeviationBound.java

@@ -0,0 +1,22 @@
+package io.searchbox.core.search.aggregation;
+
+/**
+ * @author cfstout
+ */
+public class DeviationBound {
+    private Double upper;
+    private Double lower;
+
+    public DeviationBound(Double upper, Double lower) {
+        this.upper = upper;
+        this.lower = lower;
+    }
+
+    public Double getUpper() {
+        return upper;
+    }
+
+    public Double getLower() {
+        return lower;
+    }
+}