public LongColumnPreIndexStatsCollector(String column, StatsCollectorConfig statsCollectorConfig) { super(column, statsCollectorConfig); rawLongSet = new LongOpenHashSet(INITIAL_HASH_SET_SIZE); aggregatedLongSet = new LongOpenHashSet(INITIAL_HASH_SET_SIZE); }
public UnboundedPolicy() { this.policyStats = new PolicyStats("opt.Unbounded"); this.data = new LongOpenHashSet(); }
private LongOpenHashSet calcMissing(LongOpenHashSet found, LongOpenHashSet expected) { LongOpenHashSet missing = new LongOpenHashSet(expected); missing.removeAll(found); return missing; }
LongRawValueBasedNotInPredicateEvaluator(NotInPredicate notInPredicate) { String[] values = notInPredicate.getValues(); _nonMatchingValues = new LongOpenHashSet(values.length); for (String value : values) { _nonMatchingValues.add(Long.parseLong(value)); } }
LongRawValueBasedInPredicateEvaluator(InPredicate predicate) { String[] values = predicate.getValues(); _matchingValues = new LongOpenHashSet(HashUtil.getMinHashSetSize(values.length)); for (String value : values) { _matchingValues.add(Long.parseLong(value)); } }
private void initDoubleValues() { if (predicate != null) { return; } synchronized (initLock) { if (predicate != null) { return; } LongArrayList doubleBits = new LongArrayList(values.size()); for (String value : values) { Double doubleValue = Doubles.tryParse(value); if (doubleValue != null) { doubleBits.add(Double.doubleToLongBits((doubleValue))); } } if (doubleBits.size() > NUMERIC_HASHING_THRESHOLD) { final LongOpenHashSet doubleBitsHashSet = new LongOpenHashSet(doubleBits); predicate = input -> doubleBitsHashSet.contains(Double.doubleToLongBits(input)); } else { final long[] doubleBitsArray = doubleBits.toLongArray(); Arrays.sort(doubleBitsArray); predicate = input -> Arrays.binarySearch(doubleBitsArray, Double.doubleToLongBits(input)) >= 0; } } } @Override
@Override public int countUnique() { LongSet ints = new LongOpenHashSet(data.size()); for (long i : data) { ints.add(i); } return ints.size(); }
private void initLongValues() { if (predicate != null) { return; } synchronized (initLock) { if (predicate != null) { return; } LongArrayList longs = new LongArrayList(values.size()); for (String value : values) { final Long longValue = DimensionHandlerUtils.getExactLongFromDecimalString(value); if (longValue != null) { longs.add(longValue); } } if (longs.size() > NUMERIC_HASHING_THRESHOLD) { final LongOpenHashSet longHashSet = new LongOpenHashSet(longs); predicate = input -> longHashSet.contains(input); } else { final long[] longArray = longs.toLongArray(); Arrays.sort(longArray); predicate = input -> Arrays.binarySearch(longArray, input) >= 0; } } }
@SqlType("array(bigint)") public static Block bigintUnion(@SqlType("array(bigint)") Block leftArray, @SqlType("array(bigint)") Block rightArray) { int leftArrayCount = leftArray.getPositionCount(); int rightArrayCount = rightArray.getPositionCount(); LongSet set = new LongOpenHashSet(leftArrayCount + rightArrayCount); BlockBuilder distinctElementBlockBuilder = BIGINT.createBlockBuilder(null, leftArrayCount + rightArrayCount); AtomicBoolean containsNull = new AtomicBoolean(false); appendBigintArray(leftArray, containsNull, set, distinctElementBlockBuilder); appendBigintArray(rightArray, containsNull, set, distinctElementBlockBuilder); return distinctElementBlockBuilder.build(); }
public void createOplogs(boolean needsOplogs, Map<File, DirectoryHolder> backupFiles) { LongOpenHashSet foundCrfs = new LongOpenHashSet(); LongOpenHashSet foundDrfs = new LongOpenHashSet();
@Override public long[][] transformToLongValuesMV(@Nonnull ProjectionBlock projectionBlock) { if (getResultMetadata().getDataType() != FieldSpec.DataType.LONG) { return super.transformToLongValuesMV(projectionBlock); } if (_longValueSet == null) { _longValueSet = new LongOpenHashSet(); for (String inValue : _stringValueSet) { _longValueSet.add(Long.parseLong(inValue)); } _longValues = new long[DocIdSetPlanNode.MAX_DOC_PER_CALL][]; } long[][] unFilteredLongValues = _mainTransformFunction.transformToLongValuesMV(projectionBlock); int length = projectionBlock.getNumDocs(); for (int i = 0; i < length; i++) { _longValues[i] = filterLongs(_longValueSet, unFilteredLongValues[i]); } return _longValues; }
@Override public int countUnique() { LongSet uniqueElements = new LongOpenHashSet(); for (int i = 0; i < size(); i++) { if (!isMissingValue(getLong(i))) { uniqueElements.add(getLong(i)); } } return uniqueElements.size(); }
@Override public LongColumn unique() { final LongSet values = new LongOpenHashSet(); for (int i = 0; i < size(); i++) { if (!isMissing(i)) { values.add(getLong(i)); } } final LongColumn column = LongColumn.create(name() + " Unique values"); for (long value : values) { column.append(value); } return column; }
this.dsIds = new IntOpenHashSet(); this.instIds = new IntOpenHashSet(); this.crfIds = new LongOpenHashSet(); this.drfIds = new LongOpenHashSet(); this.krfIds = new ConcurrentHashSet<>(); recover();
@Override public DateTimeColumn unique() { LongSet ints = new LongOpenHashSet(data.size()); for (long i : data) { ints.add(i); } DateTimeColumn column = emptyCopy(ints.size()); column.setName(name() + " Unique values"); column.data = LongArrayList.wrap(ints.toLongArray()); return column; }
@Test public void testLongPredicateEvaluators() { List<String> stringValues = new ArrayList<>(NUM_PREDICATE_VALUES); LongSet valueSet = new LongOpenHashSet();
Arrays.sort(_intValues); LongOpenHashSet longSet = new LongOpenHashSet(); while (longSet.size() < NUM_VALUES) { longSet.add(RANDOM.nextLong());
LongSet set = new LongOpenHashSet(array.getPositionCount()); int distinctCount = 0;
@Override public LongSet finishSet() { if (entries == null) { return LongSets.EMPTY_SET; } LongSet set = new LongOpenHashSet(entries.keySet()); entries = null; return set; }
@Override public LongSet finishSet() { assert size == heap.size(); LongSet longs = new LongOpenHashSet(size); while (!heap.isEmpty()) { longs.add(items.getLong(heap.dequeueInt())); } clear(); return longs; }