@Override public Comparator getComparator() { return Comparators.naturalNullsFirst(); }
static <T extends Comparable<? super T>> ArrayList<T> mergeIndexed(List<Iterable<T>> indexedLists) { Set<T> retVal = new TreeSet<>(Comparators.naturalNullsFirst()); for (Iterable<T> indexedList : indexedLists) { for (T val : indexedList) { retVal.add(val); } } return Lists.newArrayList(retVal); }
@Override public int compare(String o1, String o2) { return Comparators.<String>naturalNullsFirst().compare(o1, o2); } };
@Override protected ExprEval evalString(@Nullable String left, @Nullable String right) { return ExprEval.of(Comparators.<String>naturalNullsFirst().compare(left, right) > 0, ExprType.LONG); }
@Override protected ExprEval evalString(@Nullable String left, @Nullable String right) { return ExprEval.of(Comparators.<String>naturalNullsFirst().compare(left, right) < 0, ExprType.LONG); }
@Override protected ExprEval evalString(@Nullable String left, @Nullable String right) { return ExprEval.of(Comparators.<String>naturalNullsFirst().compare(left, right) <= 0, ExprType.LONG); }
@Override protected ExprEval evalString(@Nullable String left, @Nullable String right) { return ExprEval.of(Comparators.<String>naturalNullsFirst().compare(left, right) >= 0, ExprType.LONG); }
private void initializeRankOfDictionaryIds() { final int dictionarySize = dictionary.size(); rankOfDictionaryIds = IntStream.range(0, dictionarySize).toArray(); IntArrays.quickSort( rankOfDictionaryIds, (i1, i2) -> Comparators.<String>naturalNullsFirst().compare(dictionary.get(i1), dictionary.get(i2)) ); IntArrayUtils.inverse(rankOfDictionaryIds); }
public static int compareObjectsAsType( @Nullable final Object lhs, @Nullable final Object rhs, final ValueType type ) { //noinspection unchecked return Comparators.<Comparable>naturalNullsFirst().compare( convertObjectToType(lhs, type), convertObjectToType(rhs, type) ); }
@Override public FinalizingFieldAccessPostAggregator decorate(final Map<String, AggregatorFactory> aggregators) { final Comparator<Object> theComparator; final Function<Object, Object> theFinalizer; if (aggregators != null && aggregators.containsKey(fieldName)) { //noinspection unchecked theComparator = aggregators.get(fieldName).getComparator(); } else { //noinspection unchecked theComparator = (Comparator) Comparators.naturalNullsFirst(); } if (aggregators != null && aggregators.containsKey(fieldName)) { theFinalizer = aggregators.get(fieldName)::finalizeComputation; } else { theFinalizer = Function.identity(); } return new FinalizingFieldAccessPostAggregator( name, fieldName, theComparator, theFinalizer ); }
@JsonCreator public InDimFilter( @JsonProperty("dimension") String dimension, @JsonProperty("values") Collection<String> values, @JsonProperty("extractionFn") ExtractionFn extractionFn ) { Preconditions.checkNotNull(dimension, "dimension can not be null"); Preconditions.checkArgument(values != null, "values can not be null"); this.values = new TreeSet<>(Comparators.naturalNullsFirst()); for (String value : values) { this.values.add(NullHandling.emptyToNullIfNeeded(value)); } this.dimension = dimension; this.extractionFn = extractionFn; this.longPredicateSupplier = getLongPredicateSupplier(); this.floatPredicateSupplier = getFloatPredicateSupplier(); this.doublePredicateSupplier = getDoublePredicateSupplier(); }
@Override public int compare(Comparable lhs, Comparable rhs) { if (lhs instanceof Long && rhs instanceof Long) { return Long.compare(((Number) lhs).longValue(), ((Number) rhs).longValue()); } else if (lhs instanceof Number && rhs instanceof Number) { double d1 = ((Number) lhs).doubleValue(); double d2 = ((Number) rhs).doubleValue(); if (Double.isFinite(d1) && !Double.isFinite(d2)) { return 1; } if (!Double.isFinite(d1) && Double.isFinite(d2)) { return -1; } return Double.compare(d1, d2); } else { return Comparators.<Comparable>naturalNullsFirst().compare(lhs, rhs); } } }
@Override public Ordering getResultOrdering() { final Ordering<Row> rowOrdering = getRowOrdering(false); return Ordering.from( (lhs, rhs) -> { if (lhs instanceof Row) { return rowOrdering.compare((Row) lhs, (Row) rhs); } else { // Probably bySegment queries return ((Ordering) Comparators.naturalNullsFirst()).compare(lhs, rhs); } } ); }
public boolean replaces(LookupExtractorFactoryMapContainer other) { if (version == null && other.getVersion() == null) { return false; } return Comparators.<String>naturalNullsFirst().compare(version, other.getVersion()) > 0; }
private static int compareDimsInRows(RowBasedKey key1, RowBasedKey key2, int dimStart) { for (int i = dimStart; i < key1.getKey().length; i++) { final int cmp = Comparators.<Comparable>naturalNullsFirst().compare( (Comparable) key1.getKey()[i], (Comparable) key2.getKey()[i] ); if (cmp != 0) { return cmp; } } return 0; }
public boolean replaces(LookupExtractorFactoryContainer other) { if (version == null && other.getVersion() == null) { return this.lookupExtractorFactory.replaces(other.getLookupExtractorFactory()); } return Comparators.<String>naturalNullsFirst().compare(version, other.getVersion()) > 0; }
public SortedDimensionDictionary(List<String> idToValue, int length) { Object2IntSortedMap<String> sortedMap = new Object2IntRBTreeMap<>(Comparators.naturalNullsFirst()); for (int id = 0; id < length; id++) { String value = idToValue.get(id); sortedMap.put(value, id); } this.sortedVals = Lists.newArrayList(sortedMap.keySet()); this.idToIndex = new int[length]; this.indexToId = new int[length]; int index = 0; for (IntIterator iterator = sortedMap.values().iterator(); iterator.hasNext(); ) { int id = iterator.nextInt(); idToIndex[id] = index; indexToId[index] = id; index++; } }
@Test public void testComputedWithFinalizing() { String aggName = "biily"; AggregatorFactory aggFactory = EasyMock.createMock(AggregatorFactory.class); EasyMock.expect(aggFactory.getComparator()).andReturn(Comparators.naturalNullsFirst()).once(); EasyMock.expect(aggFactory.finalizeComputation("test")).andReturn(3L).once(); EasyMock.replay(aggFactory); FinalizingFieldAccessPostAggregator postAgg = buildDecorated( "final_billy", aggName, ImmutableMap.of(aggName, aggFactory) ); // Check that the class matches exactly; see https://github.com/apache/incubator-druid/issues/6063 Assert.assertEquals(FinalizingFieldAccessPostAggregator.class, postAgg.getClass()); Map<String, Object> metricValues = new HashMap<>(); metricValues.put(aggName, "test"); Assert.assertEquals(new Long(3L), postAgg.compute(metricValues)); EasyMock.verify(aggFactory); }
@Test public void testComputedInArithmeticPostAggregator() { String aggName = "billy"; AggregatorFactory aggFactory = EasyMock.createMock(AggregatorFactory.class); EasyMock.expect(aggFactory.getComparator()).andReturn(Comparators.naturalNullsFirst()).once(); EasyMock.expect(aggFactory.finalizeComputation("test")).andReturn(3L).once(); EasyMock.replay(aggFactory); FinalizingFieldAccessPostAggregator postAgg = buildDecorated( "final_billy", aggName, ImmutableMap.of(aggName, aggFactory) ); Map<String, Object> metricValues = new HashMap<>(); metricValues.put(aggName, "test"); List<PostAggregator> postAggsList = Lists.newArrayList( new ConstantPostAggregator("roku", 6), postAgg); ArithmeticPostAggregator arithmeticPostAggregator = new ArithmeticPostAggregator("add", "+", postAggsList); Assert.assertEquals(new Double(9.0f), arithmeticPostAggregator.compute(metricValues)); EasyMock.verify(); }
TestHelper.assertExpectedResults( new MergeIterable<>( Comparators.naturalNullsFirst(), FunctionalIterable .create(new RangeIterable(expectedResultsRangeStart, expectedResultsRangeEnd))