/** * Methods that allow optimizations to directly set the group by visitor result instead of * computing it visiting all the features. Aggregate visitor results are wrapped with the * appropriate feature calculation type. * * @param value the group by visitor result */ public void setValue(List<GroupByRawResult> value) { Map<List<Object>, CalcResult> results = new HashMap<>(); for (GroupByRawResult groupByRawResult : value) { // wrap the aggregate visitor result with the appropriate feature calculation type results.put( groupByRawResult.groupByValues, aggregate.wrap(expression, groupByRawResult.visitorValue)); } // create a new group by result using the raw values returned by the optimization GroupByResult newResult = new GroupByResult(results, aggregate, groupByAttributes); if (optimizationResult == CalcResult.NULL_RESULT) { // if no current result we simply return the new one optimizationResult = newResult; } else { // if a result already exists we merge it with the new one optimizationResult = optimizationResult.merge(newResult); } }
if (existingResult != null) { mergedResults.put(entry.getKey(), existingResult.merge(entry.getValue())); } else {
public CalcResult merge(CalcResult resultsToAdd) { if (!isCompatible(resultsToAdd)) { throw new IllegalArgumentException("Parameter is not a compatible type"); } if (resultsToAdd == CalcResult.NULL_RESULT) { return this; } if (resultsToAdd instanceof CountResult) { // add the two counts int toAdd = resultsToAdd.toInt(); return new CountResult(count + toAdd); } else if (resultsToAdd instanceof SumResult) { // we don't want to implement this twice, so we'll call the // SumResult version of this function return resultsToAdd.merge(this); } else { throw new IllegalArgumentException( "The CalcResults claim to be compatible, but the appropriate merge method has not been implemented."); } } }
/** * This method computes and returns the group by visitor result. If the computation was * optimized the optimization result is returned otherwise the result is computed in memory. If * for some reason an optimization result exists and there are visited features, an in memory * computation is performed and is merged with the existing optimization results. * * @return group by visitor result */ @Override public CalcResult getResult() { // do a in memory computation for any visited feature Map<List<Object>, CalcResult> results = inMemoryGroupBy.visit(); // create the result, if no feature was visited this will be an empty result that can be // safely merged GroupByResult result = new GroupByResult(results, aggregate, groupByAttributes); if (optimizationResult == CalcResult.NULL_RESULT) { // there is no optimization result so we just return the created one return result; } // an optimization result exists, we merge both return optimizationResult.merge(result); }
/** * Counts granule usages in all coverages managed by the reader, as the same file can act as a * source for multiple coverages * * @param locations * @return */ private Map<String, Integer> countGranulesMatchingLocations(Set<String> locations) throws IOException { ImageMosaicReader reader = manager.getParentReader(); CalcResult calc = null; for (String coverageName : reader.getGridCoverageNames()) { RasterManager coverageManager = reader.getRasterManager(coverageName); Filter filter = buildLocationsFilter(coverageManager, locations); CalcResult coverageCalc = countGranulesMatchingCalc(filter, coverageManager); if (calc == null) { calc = coverageCalc; } else { calc = calc.merge(coverageCalc); } } return calcToCountMap(calc); }
public void testBadMerge() throws IllegalFilterException, IOException { // count + max = boom! CountVisitor countVisitor = new CountVisitor(); countVisitor.setValue(8); CalcResult countResult = countVisitor.getResult(); MaxVisitor maxVisitor = new MaxVisitor((Expression) null); maxVisitor.setValue(new Double(99)); CalcResult maxResult = maxVisitor.getResult(); try { CalcResult boomResult = maxResult.merge(countResult); fail(); // merge should throw an exception } catch (Exception e) { assertEquals("Parameter is not a compatible type", e.getMessage()); } }
assertEquals(1.5, medianResult2.toDouble(), 0); CalcResult medianResult3 = medianResult1.merge(medianResult2); assertEquals(2, medianResult3.toDouble(), 0); vals.add(new Double(4.5)); CalcResult medianResult4 = new MedianResult(vals); CalcResult medianResult5 = medianResult4.merge(medianResult1); assertEquals(2.75, medianResult5.toDouble(), 0); assertEquals(3.5, medianResult4.toDouble(), 0); medianResult1 = medianVisitor1.getResult(); try { medianResult3 = medianResult5.merge(medianResult1); assertEquals(CalcResult.NULL_RESULT, medianVisitor1.getResult()); assertSame(medianResult2, medianVisitor1.getResult().merge(medianResult2)); assertSame(medianResult2, medianResult2.merge(medianVisitor1.getResult()));
CalcResult uniqueResult3 = uniqueResult1.merge(uniqueResult2); assertEquals( 5, anotherSet.add(Integer.valueOf(4)); CalcResult uniqueResult4 = new UniqueResult(anotherSet); CalcResult uniqueResult5 = uniqueResult1.merge(uniqueResult4); // 1,2,3 + 2,4 assertEquals(4, uniqueResult5.toSet().size()); assertEquals(anotherSet, uniqueResult1.toSet()); uniqueResult3 = uniqueResult2.merge(uniqueResult1); Set<Object> set = uniqueResult3.toSet(); assertTrue(set.size() == 4); assertEquals(CalcResult.NULL_RESULT, uniqueVisitor.getResult()); assertSame(uniqueResult2, uniqueVisitor.getResult().merge(uniqueResult2)); assertSame(uniqueResult2, uniqueResult2.merge(uniqueVisitor.getResult()));
CalcResult maxResult3 = (MaxResult) maxResult1.merge(maxResult2); assertEquals((double) 4.5, maxResult3.toDouble(), 0); CalcResult maxResult5 = (MaxResult) maxResult4.merge(maxResult1); assertEquals(3, maxResult5.toDouble(), 0); assertEquals(2, maxResult4.toDouble(), 0); CalcResult maxResult7 = (MaxResult) maxResult1.merge(maxResult6); assertEquals(3, maxResult7.toDouble(), 0); assertEquals(-5, maxResult6.toDouble(), 0); maxResult7 = maxResult7.merge(maxResult1); assertEquals(544, maxResult7.toDouble(), 0); maxResult7 = maxResult7.merge(maxResult1); assertEquals(6453, maxResult7.toDouble(), 0); assertEquals(6453, maxResult7.toInt()); assertEquals(CalcResult.NULL_RESULT, maxVisitor.getResult()); assertSame(maxResult2, maxVisitor.getResult().merge(maxResult2)); assertSame(maxResult2, maxResult2.merge(maxVisitor.getResult()));
public void testCountSumMerge() throws IllegalFilterException, IOException { CountVisitor countVisitor = new CountVisitor(); fc2.accepts(countVisitor, null); // count = 2 SumVisitor sumVisitor = new SumVisitor(3, ft2); fc2.accepts(sumVisitor, null); // sum = 7.5 CalcResult countResult = countVisitor.getResult(); CalcResult sumResult = sumVisitor.getResult(); CalcResult averageResult1 = countResult.merge(sumResult); CalcResult averageResult2 = sumResult.merge(countResult); // both average results were correct? assertEquals((double) 3.75, averageResult1.toDouble(), 0); assertEquals((double) 3.75, averageResult2.toDouble(), 0); // neither sum nor count was destroyed? assertEquals(2, countResult.toInt()); assertEquals((double) 7.5, sumResult.toDouble(), 0); }
public void testQuantileList() throws Exception { FilterFactory factory = CommonFactoryFinder.getFilterFactory(null); Expression expr = factory.property(ft.getDescriptor(0).getLocalName()); QuantileListVisitor visitor = new QuantileListVisitor(expr, 2); fc.accepts(visitor, null); CalcResult result = visitor.getResult(); List[] qResult = (List[]) result.getValue(); assertEquals(2, qResult.length); assertEquals(2, qResult[0].size()); assertEquals(1, qResult[1].size()); // test empty collection QuantileListVisitor emptyVisitor = new QuantileListVisitor(expr, 2); empty.accepts(emptyVisitor, null); assertEquals(CalcResult.NULL_RESULT, emptyVisitor.getResult()); // test merge assertSame(result, emptyVisitor.getResult().merge(result)); assertSame(result, result.merge(emptyVisitor.getResult())); }
CalcResult minResult3 = minResult1.merge(minResult2); assertEquals(1, minResult3.toInt()); CalcResult minResult5 = minResult4.merge(minResult1); assertEquals(1, minResult5.toInt()); assertEquals(10, minResult4.toInt()); CalcResult minResult7 = (MinResult) minResult1.merge(minResult6); assertEquals(-5, minResult7.toInt()); assertEquals(-5, minResult6.toInt()); minResult7 = minResult7.merge(minResult1); assertEquals(-50, minResult7.toInt()); minResult7 = minResult7.merge(minResult1); assertEquals(-100.0, minResult7.toDouble(), 0); assertEquals(-100, minResult7.toInt()); assertEquals(CalcResult.NULL_RESULT, minVisitor.getResult()); assertSame(minResult2, minVisitor.getResult().merge(minResult2)); assertSame(minResult2, minResult2.merge(minVisitor.getResult()));
CalcResult averageResult3 = averageResult1.merge(averageResult2); assertEquals((double) 2.7, averageResult3.toDouble(), 0); averageResult2 = averageVisitor2.getResult(); assertEquals(20, averageResult2.toInt()); averageResult3 = averageResult1.merge(averageResult2); assertEquals((double) 13.25, averageResult3.toDouble(), 0); averageVisitor2.setValue(new Double(15.4)); // un-mergeable optimization assertEquals((double) 15.4, averageResult2.toDouble(), 0); try { averageResult3 = averageResult1.merge(averageResult2); averageVisitor2.setValue(5, new Double(33.3)); averageResult2 = averageVisitor2.getResult(); averageResult3 = averageResult1.merge(averageResult2); // int + double --> double? assertEquals((double) 4.33, averageResult3.toDouble(), 0); assertEquals(CalcResult.NULL_RESULT, averageVisitor.getResult()); assertSame(averageResult2, averageVisitor.getResult().merge(averageResult2)); assertSame(averageResult2, averageResult2.merge(averageVisitor.getResult()));
public void testBounds() throws IOException { BoundsVisitor boundsVisitor1 = new BoundsVisitor(); fc.accepts(boundsVisitor1, null); BoundsVisitor boundsVisitor2 = new BoundsVisitor(); fc2.accepts(boundsVisitor2, null); Envelope env1 = new Envelope(1, 5, 0, 4); CalcResult boundsResult1 = boundsVisitor1.getResult(); assertEquals(env1, boundsResult1.toEnvelope()); Envelope env2 = new Envelope(4, 13, 3, 10); CalcResult boundsResult2 = boundsVisitor2.getResult(); assertEquals(env2, boundsResult2.toEnvelope()); CalcResult boundsResult3 = boundsResult2.merge(boundsResult1); Envelope env3 = new Envelope(1, 13, 0, 10); assertEquals(env3, boundsResult3.toEnvelope()); // test empty collection boundsVisitor1.reset(null); empty.accepts(boundsVisitor1, null); assertEquals(CalcResult.NULL_RESULT, boundsVisitor1.getResult()); // test merge assertSame(boundsResult2, boundsVisitor1.getResult().merge(boundsResult2)); assertSame(boundsResult2, boundsResult2.merge(boundsVisitor1.getResult())); }
CalcResult sumResult3 = sumResult1.merge(sumResult2); assertEquals((double) 13.5, sumResult3.toDouble(), 0); CalcResult sumResult5 = sumResult3.merge(sumResult4); assertEquals(-28.5, sumResult5.toDouble(), 0); assertEquals(CalcResult.NULL_RESULT, sumVisitor.getResult()); assertSame(sumResult2, sumVisitor.getResult().merge(sumResult2)); assertSame(sumResult2, sumResult2.merge(sumVisitor.getResult()));
CalcResult countResult3 = countResult1.merge(countResult2); assertEquals(5, countResult3.toInt()); assertEquals(20, countResult4.toInt()); CalcResult countResult5 = countResult4.merge(countResult3); assertEquals(5, countResult3.toInt()); assertEquals(20, countResult4.toInt()); assertEquals(CalcResult.NULL_RESULT, countVisitor.getResult()); assertSame(countResult2, countVisitor.getResult().merge(countResult2)); assertSame(countResult2, countResult2.merge(countVisitor.getResult()));
public void testArea() throws IllegalFilterException, IOException { SumAreaVisitor areaVisitor = new SumAreaVisitor(1, ft4); fc4.accepts(areaVisitor, null); SumAreaVisitor areaVisitor2 = new SumAreaVisitor(1, ft5); fc5.accepts(areaVisitor2, null); double value1 = areaVisitor.getResult().toDouble(); assertEquals(10.0, value1); double value2 = areaVisitor2.getResult().toDouble(); assertEquals(12.0, value2); CalcResult areaResult1 = areaVisitor.getResult(); CalcResult areaResult2 = areaVisitor2.getResult(); CalcResult areaResult3 = areaResult1.merge(areaResult2); assertEquals((double) 22.0, areaResult3.toDouble(), 0); }
public void testStandardDeviation() throws Exception { FilterFactory factory = CommonFactoryFinder.getFilterFactory(null); Expression expr = factory.property(ft3.getDescriptor(0).getLocalName()); // first do it the old fashioned way to ensure backwards compatibility AverageVisitor visit1 = new AverageVisitor(expr); fc3.accepts(visit1, null); CalcResult result = visit1.getResult(); double average = result.toDouble(); StandardDeviationVisitor visit2 = new StandardDeviationVisitor(expr, average); fc3.accepts(visit2, null); assertEquals(28.86, visit2.getResult().toDouble(), 0.01); // then do it single pass StandardDeviationVisitor visit3 = new StandardDeviationVisitor(expr); fc3.accepts(visit3, null); assertEquals(28.86, visit3.getResult().toDouble(), 0.01); // test empty collection StandardDeviationVisitor emptyVisitor = new StandardDeviationVisitor(expr, average); empty.accepts(emptyVisitor, null); assertEquals(CalcResult.NULL_RESULT, emptyVisitor.getResult()); // test merge assertSame(result, emptyVisitor.getResult().merge(result)); assertSame(result, result.merge(emptyVisitor.getResult())); }
visitorA.getResult().merge(visitorB.getResult()), new Object[][] { new Object[] {"SCHOOL", 36.875},
visitorA.getResult().merge(visitorB.getResult()), new Object[][] { new Object[] {"SCHOOL", 36.875},