docs: public long run(String partitionValue, long maxTotalRows, long targetMaxRowsToDelete) {
          if (targetMaxRowsToDelete <= 0) {
              throw new VoltAbortException("maxRowsToDeletePerProc must be > 0.");
          }
          if (maxTotalRows < 0) {
              throw new VoltAbortException("maxTotalRows must be >= 0.");
          }
  
          // Count the rows in the current partition.
          voltQueueSQL(countRows, EXPECT_SCALAR_LONG);
          long count = voltExecuteSQL()[0].asScalarLong();
  
          // If partition is smaller than desired, return without deleting rows.
          if (count < maxTotalRows) {
              // Return 0 deleted rows.
              return 0;
          }
  
          // If asked to remove all rows, go ahead
          if ((maxTotalRows == 0) && (count < targetMaxRowsToDelete)) {
              voltQueueSQL(deleteAll, EXPECT_SCALAR_MATCH(count));
              voltExecuteSQL(true);
              // Total deleted rows = table size.
              return count;
          }
  
          // Figure out how many rows to try to delete.
          long agedOutCount = count - maxTotalRows;
          long rowsToConsider = Math.min(agedOutCount, targetMaxRowsToDelete);
  
          // Find the timestamp of the row at position N in the sorted order, where N is the chunk size
          voltQueueSQL(getNthOldestTimestamp, EXPECT_SCALAR, rowsToConsider);
          TimestampType newestToDiscard = voltExecuteSQL()[0].fetchRow(0).getTimestampAsTimestamp(0);
  
          // Delete all rows >= the timestamp found in the previous statement.
          // This will delete AT LEAST N rows, but since timestamps may be non-unique,
          //  it might delete more than N. In the worst case, it could delete all rows
          //  if every row has an identical timestamp value. It is guaranteed to make
          //  progress. If we used strictly less than, it might not make progress.
          // This is why the max rows to delete number is a target, not always a perfect max.
          voltQueueSQL(deleteOlderThanDate, EXPECT_SCALAR_LONG, newestToDiscard);
          long deletedCount = voltExecuteSQL(true)[0].asScalarLong();
  
          return deletedCount;
      }