public int lastCounted() {
// If we have a slice limit set, columnCounter.live() can overcount by one because we have to
// call
// columnCounter.count() before we can tell if we've exceeded the slice limit (and accordingly,
// should not
// add the cells to returned container). To deal with this overcounting, we take the min of the
// slice
// limit and the counter's count.
return columnCounter == null ? 0 : Math.min(columnCounter.live(), count);
}
public void trim(ColumnFamily cf, int trimTo, long now) {
// each cell can increment the count by at most one, so if we have fewer cells than trimTo, we
// can skip trimming
if (cf.getColumnCount() < trimTo) return;
ColumnCounter counter = columnCounter(cf.getComparator(), now);
Collection<Cell> cells = reversed ? cf.getReverseSortedColumns() : cf.getSortedColumns();
DeletionInfo.InOrderTester tester = cf.deletionInfo().inOrderTester(reversed);
for (Iterator<Cell> iter = cells.iterator(); iter.hasNext(); ) {
Cell cell = iter.next();
counter.count(cell, tester);
if (counter.live() > trimTo) {
iter.remove();
while (iter.hasNext()) {
iter.next();
iter.remove();
}
}
}
}
public int lastLive() {
return columnCounter == null ? 0 : columnCounter.live();
}
public void collectReducedColumns(
ColumnFamily container,
Iterator<Cell> reducedColumns,
DecoratedKey key,
int gcBefore,
long now) {
columnCounter = columnCounter(container.getComparator(), now);
DeletionInfo.InOrderTester tester = container.deletionInfo().inOrderTester(reversed);
while (reducedColumns.hasNext()) {
Cell cell = reducedColumns.next();
if (logger.isTraceEnabled())
logger.trace(
"collecting {} of {}: {}",
columnCounter.live(),
count,
cell.getString(container.getComparator()));
// An expired tombstone will be immediately discarded in memory, and needn't be counted.
// Neither should be any cell shadowed by a range- or a partition tombstone.
if (cell.getLocalDeletionTime() < gcBefore || !columnCounter.count(cell, tester)) continue;
if (columnCounter.live() > count) break;
if (respectTombstoneThresholds()
&& columnCounter.tombstones() > DatabaseDescriptor.getTombstoneFailureThreshold()) {
Tracing.trace(
"Scanned over {} tombstones; query aborted (see tombstone_failure_threshold); slices={}",
DatabaseDescriptor.getTombstoneFailureThreshold(),
getSlicesInfo(container));
throw new TombstoneOverwhelmingException(
columnCounter.tombstones(),
count,
container.metadata().ksName,
container.metadata().cfName,
container.getComparator().getString(cell.name()),
getSlicesInfo(container));
}
container.appendColumn(cell);
}
boolean warnTombstones =
logger.isWarnEnabled()
&& respectTombstoneThresholds()
&& columnCounter.tombstones() > DatabaseDescriptor.getTombstoneWarnThreshold();
if (warnTombstones) {
String msg =
String.format(
"Read %d live and %d tombstone cells in %s.%s for key: %1.512s (see tombstone_warn_threshold). %d columns were requested, slices=%1.512s",
columnCounter.live(),
columnCounter.tombstones(),
container.metadata().ksName,
container.metadata().cfName,
container.metadata().getKeyValidator().getString(key.getKey()),
count,
getSlicesInfo(container));
ClientWarn.warn(msg);
logger.warn(msg);
}
Tracing.trace(
"Read {} live and {} tombstone cells{}",
columnCounter.live(),
columnCounter.tombstones(),
warnTombstones ? " (see tombstone_warn_threshold)" : "");
}