/** * I/O SSTableScanner * @return A Scanner for seeking over the rows of the SSTable. */ public ISSTableScanner getScanner() { return getScanner((RateLimiter) null); }
@Override public ISSTableScanner getScanner(SSTableReader sstable, RateLimiter limiter) { return sstable.getScanner(ranges, limiter); }
@Override public ISSTableScanner getScanner(SSTableReader sstable, RateLimiter limiter) { return sstable.getScanner(limiter); }
/** * Direct I/O SSTableScanner over a defined range of tokens. * * @param range the range of keys to cover * @return A Scanner for seeking over the rows of the SSTable. */ public ISSTableScanner getScanner(Range<Token> range, RateLimiter limiter) { if (range == null) return getScanner(limiter); return getScanner(Collections.singletonList(range), limiter); }
public LeveledScanner(Collection<SSTableReader> sstables, Range<Token> range) { this.range = range; // add only sstables that intersect our range, and estimate how much data that involves this.sstables = new ArrayList<SSTableReader>(sstables.size()); long length = 0; for (SSTableReader sstable : sstables) { this.sstables.add(sstable); long estimatedKeys = sstable.estimatedKeys(); double estKeysInRangeRatio = 1.0; if (estimatedKeys > 0 && range != null) estKeysInRangeRatio = ((double) sstable.estimatedKeysForRanges(Collections.singleton(range))) / estimatedKeys; length += sstable.uncompressedLength() * estKeysInRangeRatio; } totalLength = length; Collections.sort(this.sstables, SSTableReader.sstableComparator); sstableIterator = this.sstables.iterator(); assert sstableIterator.hasNext(); // caller should check intersecting first currentScanner = sstableIterator.next().getScanner(range, CompactionManager.instance.getRateLimiter()); }
/** * Returns a list of KeyScanners given sstables and a range on which to scan. * The default implementation simply grab one SSTableScanner per-sstable, but overriding this method * allow for a more memory efficient solution if we know the sstable don't overlap (see * LeveledCompactionStrategy for instance). */ public ScannerList getScanners(Collection<SSTableReader> sstables, Range<Token> range) { RateLimiter limiter = CompactionManager.instance.getRateLimiter(); ArrayList<ISSTableScanner> scanners = new ArrayList<ISSTableScanner>(); try { for (SSTableReader sstable : sstables) scanners.add(sstable.getScanner(range, limiter)); } catch (Throwable t) { try { new ScannerList(scanners).close(); } catch (Throwable t2) { t.addSuppressed(t2); } throw t; } return new ScannerList(scanners); }
protected OnDiskAtomIterator computeNext() { if (currentScanner == null) return endOfData(); try { while (true) { if (currentScanner.hasNext()) return currentScanner.next(); positionOffset += currentScanner.getLengthInBytes(); currentScanner.close(); if (!sstableIterator.hasNext()) { // reset to null so getCurrentPosition does not return wrong value currentScanner = null; return endOfData(); } currentScanner = sstableIterator.next().getScanner(range, CompactionManager.instance.getRateLimiter()); } } catch (IOException e) { throw new RuntimeException(e); } }
ISSTableScanner scanner = reader.getScanner(); try
iterators.add(sstable.getScanner(range));
SSTableScanner scanner = reader.getScanner();
scanners.add(sstable.getScanner(range, CompactionManager.instance.getRateLimiter()));