private Collection<Range> splitByTabletBoundaries(String tableName, Collection<Range> ranges) throws org.apache.accumulo.core.client.TableNotFoundException, AccumuloException, AccumuloSecurityException { ImmutableSet.Builder<Range> rangeBuilder = ImmutableSet.builder(); for (Range range : ranges) { // if start and end key are equivalent, no need to split the range if (range.getStartKey() != null && range.getEndKey() != null && range.getStartKey().equals(range.getEndKey())) { rangeBuilder.add(range); } else { // Call out to Accumulo to split the range on tablets rangeBuilder.addAll(connector.tableOperations().splitRangeByTablets(tableName, range, Integer.MAX_VALUE)); } } return rangeBuilder.build(); }
private static boolean isExact(Range range) { return !range.isInfiniteStartKey() && !range.isInfiniteStopKey() && range.getStartKey().followingKey(PartialKey.ROW).equals(range.getEndKey()); }
private void addUnfinishedRange(LookupResult lookupResult, Range range, Key key, boolean inclusiveStartKey) { if (range.getEndKey() == null || key.compareTo(range.getEndKey()) < 0) { Range nlur = new Range(new Key(key), inclusiveStartKey, range.getEndKey(), range.isEndKeyInclusive()); lookupResult.unfinishedRanges.add(nlur); } }
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; }
private void reseek(Key key) throws IOException { if (range.afterEndKey(key)) { range = new Range(range.getEndKey(), true, range.getEndKey(), range.isEndKeyInclusive()); source.seek(range, columnFamilies, inclusive); } else { range = new Range(key, true, range.getEndKey(), range.isEndKeyInclusive()); source.seek(range, columnFamilies, inclusive); } }
static boolean isRangeInBloomFilter(Range range, PartialKey keyDepth) { if (range.getStartKey() == null || range.getEndKey() == null) { return false; } if (range.getStartKey().equals(range.getEndKey(), keyDepth)) return true; // include everything but the deleted flag in the comparison... return range.getStartKey().followingKey(keyDepth).equals(range.getEndKey(), PartialKey.ROW_COLFAM_COLQUAL_COLVIS_TIME) && !range.isEndKeyInclusive(); } }
private void reseek(Key key) throws IOException { if (range.afterEndKey(key)) { range = new Range(range.getEndKey(), true, range.getEndKey(), range.isEndKeyInclusive()); source.seek(range, colFamSet, inclusive); } else { range = new Range(key, true, range.getEndKey(), range.isEndKeyInclusive()); source.seek(range, colFamSet, inclusive); } }
public static Range minimizeEndKeyTimeStamp(Range range) { Range seekRange = range; if (range.getEndKey() != null) { Key seekKey = seekRange.getEndKey(); if (range.getEndKey().getTimestamp() != Long.MIN_VALUE) { seekKey = new Key(seekRange.getEndKey()); seekKey.setTimestamp(Long.MIN_VALUE); seekRange = new Range(range.getStartKey(), range.isStartKeyInclusive(), seekKey, true); } else if (!range.isEndKeyInclusive()) { seekRange = new Range(range.getStartKey(), range.isStartKeyInclusive(), seekKey, true); } } return seekRange; }
protected void reseek(Key key) throws IOException { if (key == null) return; if (range.afterEndKey(key)) { range = new Range(range.getEndKey(), true, range.getEndKey(), range.isEndKeyInclusive()); getSource().seek(range, columnFamilies, inclusive); } else { range = new Range(key, true, range.getEndKey(), range.isEndKeyInclusive()); getSource().seek(range, columnFamilies, inclusive); } }
private void _switchNow() throws IOException { if (onlySwitchAfterRow) throw new IllegalStateException("Can only switch on row boundries"); if (switchSource()) { if (key != null) { iter.seek(new Range(key, true, range.getEndKey(), range.isEndKeyInclusive()), columnFamilies, inclusive); } } }
public float getProgress(Key currentKey) { if (currentKey == null) return 0f; if (range.contains(currentKey)) { if (range.getStartKey() != null && range.getEndKey() != null) { if (range.getStartKey().compareTo(range.getEndKey(), PartialKey.ROW) != 0) { // just look at the row progress return getProgress(range.getStartKey().getRowData(), range.getEndKey().getRowData(), currentKey.getRowData()); } else if (range.getStartKey().compareTo(range.getEndKey(), PartialKey.ROW_COLFAM) != 0) { // just look at the column family progress return getProgress(range.getStartKey().getColumnFamilyData(), range.getEndKey().getColumnFamilyData(), currentKey.getColumnFamilyData()); } else if (range.getStartKey().compareTo(range.getEndKey(), PartialKey.ROW_COLFAM_COLQUAL) != 0) { // just look at the column qualifier progress return getProgress(range.getStartKey().getColumnQualifierData(), range.getEndKey().getColumnQualifierData(), currentKey.getColumnQualifierData()); } } } // if we can't figure it out, then claim no progress return 0f; }
private RowRange toClippedExtent(Range r) { r = clipRange.clip(r); Text startRow = removeTrailingZeroFromRow(r.getStartKey()); Text endRow = removeTrailingZeroFromRow(r.getEndKey()); return new RowRange(startRow, endRow); }
private void resetSource() { if (prevTablet == null) { source = iteratorFactory.apply(range); } else { // get the metadata table row for the previous tablet Text prevMetaRow = TabletsSection.getRow(prevTablet.getTableId(), prevTablet.getEndRow()); // ensure the previous tablet still exists in the metadata table if (Iterators.size(iteratorFactory.apply(new Range(prevMetaRow))) == 0) { throw new TabletDeletedException("Tablet " + prevMetaRow + " was deleted while iterating"); } // start scanning at next possible row in metadata table Range seekRange = new Range(new Key(prevMetaRow).followingKey(PartialKey.ROW), true, range.getEndKey(), range.isEndKeyInclusive()); log.info("Resetting scanner to {}", seekRange); source = iteratorFactory.apply(seekRange); } }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { topKey = null; topValue = null; Key sk = range.getStartKey(); if (sk != null && sk.getColumnQualifierData().length() == 0 && sk.getColumnVisibilityData().length() == 0 && sk.getTimestamp() == Long.MAX_VALUE && !range.isStartKeyInclusive()) { // assuming that we are seeking using a key previously returned by // this iterator // therefore go to the next row/cf Key followingRowKey = sk.followingKey(PartialKey.ROW_COLFAM); if (range.getEndKey() != null && followingRowKey.compareTo(range.getEndKey()) > 0) return; range = new Range(sk.followingKey(PartialKey.ROW_COLFAM), true, range.getEndKey(), range.isEndKeyInclusive()); } sourceIter.seek(range, columnFamilies, inclusive); prepKeys(); }
public static Range maximizeStartKeyTimeStamp(Range range) { Range seekRange = range; if (range.getStartKey() != null) { Key seekKey = range.getStartKey(); if (range.getStartKey().getTimestamp() != Long.MAX_VALUE) { seekKey = new Key(seekRange.getStartKey()); seekKey.setTimestamp(Long.MAX_VALUE); seekRange = new Range(seekKey, true, range.getEndKey(), range.isEndKeyInclusive()); } else if (!range.isStartKeyInclusive()) { seekRange = new Range(seekKey, true, range.getEndKey(), range.isEndKeyInclusive()); } } return seekRange; }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { topKey = null; topValue = null; Key sk = range.getStartKey(); if (sk != null && sk.getColumnFamilyData().length() == 0 && sk.getColumnQualifierData().length() == 0 && sk.getColumnVisibilityData().length() == 0 && sk.getTimestamp() == Long.MAX_VALUE && !range.isStartKeyInclusive()) { // assuming that we are seeking using a key previously returned by this iterator // therefore go to the next row Key followingRowKey = sk.followingKey(PartialKey.ROW); if (range.getEndKey() != null && followingRowKey.compareTo(range.getEndKey()) > 0) return; range = new Range(sk.followingKey(PartialKey.ROW), true, range.getEndKey(), range.isEndKeyInclusive()); } sourceIter.seek(range, columnFamilies, inclusive); prepKeys(); }
@Override public int execute(final String fullCommand, final CommandLine cl, final Shell shellState) throws Exception { final String tableName = OptUtil.getTableOpt(cl, shellState); final ScanInterpreter interpeter = getInterpreter(cl, tableName, shellState); final Range range = getRange(cl, interpeter); final Authorizations auths = getAuths(cl, shellState); final Text startRow = range.getStartKey() == null ? null : range.getStartKey().getRow(); final Text endRow = range.getEndKey() == null ? null : range.getEndKey().getRow(); try { final Text max = shellState.getAccumuloClient().tableOperations().getMaxRow(tableName, auths, startRow, range.isStartKeyInclusive(), endRow, range.isEndKeyInclusive()); if (max != null) { shellState.getReader().println(max.toString()); } } catch (Exception e) { log.debug("Could not get shell state.", e); } return 0; }
/** * 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); }
/** * Possibly expand {@code range} to include everything for the key prefix we are working with. * That is, if our prefix is ROW_COLFAM, then we need to expand the range so we're sure to include * all entries having the same row and column family as the start/end of the range. * * @param range * the range to expand * @return the modified range */ protected Range computeReseekRange(Range range) { Key startKey = range.getStartKey(); boolean startKeyInclusive = range.isStartKeyInclusive(); // If anything after the prefix is set, then clip the key so we include // everything for the prefix. if (isSetAfterPart(startKey, getKeyPrefix())) { startKey = copyPartialKey(startKey, getKeyPrefix()); startKeyInclusive = true; } Key endKey = range.getEndKey(); boolean endKeyInclusive = range.isEndKeyInclusive(); if (isSetAfterPart(endKey, getKeyPrefix())) { endKey = endKey.followingKey(getKeyPrefix()); endKeyInclusive = true; } return new Range(startKey, startKeyInclusive, endKey, endKeyInclusive); }
@Override public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException { // save parameters for future internal seeks latestRange = range; latestColumnFamilies = columnFamilies; latestInclusive = inclusive; lastRowFound = null; Key startKey = range.getStartKey(); Range seekRange = new Range(startKey == null ? null : new Key(startKey.getRow()), true, range.getEndKey(), range.isEndKeyInclusive()); super.seek(seekRange, columnFamilies, inclusive); finished = false; if (getSource().hasTop()) { lastRowFound = getSource().getTopKey().getRow(); if (range.beforeStartKey(getSource().getTopKey())) consume(); } }