private static boolean isExact(Range range) { return !range.isInfiniteStartKey() && !range.isInfiniteStopKey() && range.getStartKey().followingKey(PartialKey.ROW).equals(range.getEndKey()); }
public static long getRangeLength(Range range) { Text startRow = range.isInfiniteStartKey() ? new Text(new byte[] {Byte.MIN_VALUE}) : range.getStartKey().getRow(); Text stopRow = range.isInfiniteStopKey() ? new Text(new byte[] {Byte.MAX_VALUE}) : range.getEndKey().getRow(); int maxCommon = Math.min(7, Math.min(startRow.getLength(), stopRow.getLength())); long diff = 0; byte[] start = startRow.getBytes(); byte[] stop = stopRow.getBytes(); for (int i = 0; i < maxCommon; ++i) { diff |= 0xff & (start[i] ^ stop[i]); diff <<= Byte.SIZE; } if (startRow.getLength() != stopRow.getLength()) diff |= 0xff; return diff + 1; }
/** * Converts the given {@code Range} into the correct {@code Range} for this TermSource (per this * expected table structure) and then seeks this TermSource's SKVI. */ public void seek(Range originalRange) throws IOException { // the infinite start key is equivalent to a null startKey on the Range. if (!originalRange.isInfiniteStartKey()) { Key originalStartKey = originalRange.getStartKey(); // Pivot the provided range into the range for this term Key newKey = new Key(originalStartKey.getRow(), term, originalStartKey.getColumnQualifier(), originalStartKey.getTimestamp()); // Construct the new range, preserving the other attributes on the provided range. currentRange = new Range(newKey, originalRange.isStartKeyInclusive(), originalRange.getEndKey(), originalRange.isEndKeyInclusive()); } else { currentRange = originalRange; } LOG.trace("Seeking {} to {}", this, currentRange); iter.seek(currentRange, seekColfams, true); }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { source.seek(range, columnFamilies, inclusive); lastKey = range.isInfiniteStartKey() ? EMPTY_KEY : range.getStartKey(); afterLastKey = !range.isInfiniteStartKey() && !range.isStartKeyInclusive(); tri = 0; findTop(); }
public static long getRangeLength(Range range) throws IOException { Text startRow = range.isInfiniteStartKey() ? new Text(new byte[] {Byte.MIN_VALUE}) : range.getStartKey().getRow(); Text stopRow = range.isInfiniteStopKey() ? new Text(new byte[] {Byte.MAX_VALUE}) : range.getEndKey().getRow(); int maxCommon = Math.min(7, Math.min(startRow.getLength(), stopRow.getLength())); long diff = 0; byte[] start = startRow.getBytes(); byte[] stop = stopRow.getBytes(); for (int i = 0; i < maxCommon; ++i) { diff |= 0xff & (start[i] ^ stop[i]); diff <<= Byte.SIZE; } if (startRow.getLength() != stopRow.getLength()) diff |= 0xff; return diff + 1; }
public static long getRangeLength(Range range) throws IOException { Text startRow = range.isInfiniteStartKey() ? new Text(new byte[] {Byte.MIN_VALUE}) : range.getStartKey().getRow(); Text stopRow = range.isInfiniteStopKey() ? new Text(new byte[] {Byte.MAX_VALUE}) : range.getEndKey().getRow(); int maxCommon = Math.min(7, Math.min(startRow.getLength(), stopRow.getLength())); long diff = 0; byte[] start = startRow.getBytes(); byte[] stop = stopRow.getBytes(); for (int i = 0; i < maxCommon; ++i) { diff |= 0xff & (start[i] ^ stop[i]); diff <<= Byte.SIZE; } if (startRow.getLength() != stopRow.getLength()) diff |= 0xff; return diff + 1; }
public static long getRangeLength(Range range) { Text startRow = range.isInfiniteStartKey() ? new Text(new byte[] {Byte.MIN_VALUE}) : range.getStartKey().getRow(); Text stopRow = range.isInfiniteStopKey() ? new Text(new byte[] {Byte.MAX_VALUE}) : range.getEndKey().getRow(); int maxCommon = Math.min(7, Math.min(startRow.getLength(), stopRow.getLength())); long diff = 0; byte[] start = startRow.getBytes(); byte[] stop = stopRow.getBytes(); for (int i = 0; i < maxCommon; ++i) { diff |= 0xff & (start[i] ^ stop[i]); diff <<= Byte.SIZE; } if (startRow.getLength() != stopRow.getLength()) diff |= 0xff; return diff + 1; }
/** Iterate over target ranges in order, masked by seekRange. * Only iterates over target ranges that intersect the seekRange. */ public PeekingIterator1<Range> iteratorWithRangeMask(Range seekRange) { if (seekRange.isInfiniteStartKey() && seekRange.isInfiniteStopKey()) return new PeekingIterator1<>(targetRanges.iterator()); else if (seekRange.isInfiniteStartKey()) return new RangeSetIter(targetRanges.iterator(), seekRange); else { // find first range whose end key >= the start key of seekRange PeekingIterator1<Range> pi = getFirstRangeStarting(seekRange, targetRanges); return new RangeSetIter(pi, seekRange); } }
public static Text getRow(Range range) { return range.isInfiniteStartKey() ? EMPTY : range.getStartKey().getRow(); }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { seekRng = range; // seek to first entry inside range if (range.isInfiniteStartKey()) inner = new PeekingIterator1<>(allEntriesToInject.entrySet().iterator()); else if (range.isStartKeyInclusive()) inner = new PeekingIterator1<>(allEntriesToInject.tailMap(range.getStartKey()).entrySet().iterator()); else inner = new PeekingIterator1<>(allEntriesToInject.tailMap(range.getStartKey().followingKey(PartialKey.ROW_COLFAM_COLQUAL_COLVIS_TIME)).entrySet().iterator()); }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { // seek to first entry inside range if (range.isInfiniteStartKey()) inner = new PeekingIterator1<>(allEntriesToInject.entrySet().iterator()); else if (range.isStartKeyInclusive()) inner = new PeekingIterator1<>(allEntriesToInject.tailMap(range.getStartKey()).entrySet().iterator()); else inner = new PeekingIterator1<>(allEntriesToInject.tailMap(range.getStartKey().followingKey(PartialKey.ROW_COLFAM_COLQUAL_COLVIS_TIME)).entrySet().iterator()); }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { seekRng = range; // seek to first entry inside range if (range.isInfiniteStartKey()) inner = new PeekingIterator<>(allEntriesToInject.entrySet().iterator()); else if (range.isStartKeyInclusive()) inner = new PeekingIterator<>( allEntriesToInject.tailMap(range.getStartKey()).entrySet().iterator()); else inner = new PeekingIterator<>(allEntriesToInject .tailMap(range.getStartKey().followingKey(PartialKey.ROW_COLFAM_COLQUAL_COLVIS_TIME)) .entrySet().iterator()); }
protected void setExceedtime() { exceededTime = true; Key topKey = myRange.getStartKey(); if (!myRange.isStartKeyInclusive()) { topKey = topKey.followingKey(PartialKey.ROW_COLFAM_COLQUAL_COLVIS_TIME); } if (myRange.isInfiniteStartKey()) topKey = new Key(); myKey = topKey; }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { if (!range.isInfiniteStartKey() && !range.isStartKeyInclusive()) { Key startKey = range.getStartKey(); Key newStartKey = startKey.followingKey(PartialKey.ROW_COLFAM); if (log.isTraceEnabled()) { log.trace("Permuting start key to attempt to avoid duplicative returned key. Was:" + startKey + ", Now:" + newStartKey); } range = new Range(newStartKey, false, range.getEndKey(), range.isEndKeyInclusive()); } this.totalRange = range; this.source.seek(range, columnFamilies, inclusive); }
public static boolean allDocSpecific(Collection<Range> ranges) { for (Range range : ranges) { if (range.isInfiniteStartKey() || range.isInfiniteStopKey()) return false; Key startKey = range.getStartKey(); // 1) it's not a shard, meaning that we don't have a shard specific range or doc specific range // 2) cf is empty meaning we have a day range or shard specific range if (!isShard(startKey.getRow().toString()) || startKey.getColumnFamilyData().length() == 0) { return false; } } return true; }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { source.seek(range, columnFamilies, inclusive); long cnt = countRows(); if (cnt != 0) { emitKey = range.isInfiniteStartKey() ? new Key() : (range.isStartKeyInclusive() ? range.getStartKey() : range.getStartKey().followingKey(PartialKey.ROW_COLFAM_COLQUAL)); emitValue = new Value(Long.toString(cnt).getBytes(StandardCharsets.UTF_8)); } else { emitValue = null; emitKey = null; } // System.out.println("range "+range+" cnt "+Long.valueOf(new String(emitValue.get())) + " lastKey "+emitKey); }
@Override public void seekApplyOp(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { if (range.isInfiniteStartKey()) seekStartKey = new Key(); else seekStartKey = range.isStartKeyInclusive() ? range.getStartKey() : range.getStartKey().followingKey(PartialKey.ROW_COLFAM_COLQUAL); // problem } }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { if (!range.isInfiniteStartKey() || !range.isInfiniteStopKey()) log.warn("Range is not infinite: "+range); source.seek(range, columnFamilies, inclusive); IteratorAdapter ia = new IteratorAdapter(source); SortedMap<Key, Value> map = MemMatrixUtil.matrixToMap(new TreeMap<Key, Value>(), MemMatrixUtil.doInverse(MemMatrixUtil.buildMatrix(ia, matrixSize), numIterations)); // DebugUtil.printMapFull(map.entrySet().iterator()); mapIterator = new MapIterator(map); mapIterator.init(null, null, null); mapIterator.seek(range, columnFamilies, inclusive); }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { this.totalRange = range; this.columnFamilies = columnFamilies; this.inclusive = inclusive; // determine if we have been torn down and rebuilt if (!range.isInfiniteStartKey() && !range.isStartKeyInclusive()) { move(nextStartKey(range.getStartKey())); } else { source.seek(range, columnFamilies, inclusive); findNextDocument(); } }
/** * Advance to the first subset range whose end key >= the seek start key. */ public static Iterator<Range> getFirstRangeStarting(PeekingIterator1<Range> iter, Range seekRange) { if (!seekRange.isInfiniteStartKey()) while (iter.hasNext() && !iter.peek().isInfiniteStopKey() && ((iter.peek().getEndKey().equals(seekRange.getStartKey()) && !seekRange.isEndKeyInclusive()) || iter.peek().getEndKey().compareTo(seekRange.getStartKey()) < 0)) { iter.next(); } return iter; }