How to use org.datacleaner.job.runner

@Override
public void execute() {
  _consumeRowHandler.consumeRow(_row).getRows();
  _analysisListener.rowProcessingProgress(_rowProcessingMetrics.getAnalysisJobMetrics().getAnalysisJob(),
      _rowProcessingMetrics, _row, _rowNumber);
}

@Override
public void errorInComponent(final AnalysisJob job, final ComponentJob componentJob, final InputRow row,
    final Throwable throwable) {
  for (final AnalysisListener delegate : _delegates) {
    try {
      delegate.errorInComponent(job, componentJob, row, throwable);
    } catch (final Exception e) {
      logFailure(delegate, e);
    }
  }
}

@Override
public RowProcessingMetrics getRowProcessingMetrics(final Table table) {
  final RowProcessingStream stream = _publishers.getStream(table);
  final RowProcessingPublisher publisher = _publishers.getRowProcessingPublisher(stream);
  if (publisher == null) {
    return null;
  }
  return publisher.getRowProcessingMetrics();
}

protected final Task createCollectResultTask(final RowProcessingConsumer consumer,
    final Queue<JobAndResult> resultQueue) {
  final Object component = consumer.getComponent();
  if (component instanceof HasAnalyzerResult) {
    final HasAnalyzerResult<?> hasAnalyzerResult = (HasAnalyzerResult<?>) component;
    final AnalysisListener analysisListener = _publishers.getAnalysisListener();
    return new CollectResultsTask(hasAnalyzerResult, _stream.getAnalysisJob(), consumer.getComponentJob(),
        resultQueue, analysisListener);
  }
  return null;
}

private void registerRowProcessingPublishers(final SourceColumnFinder sourceColumnFinder, final AnalysisJob job,
    final ComponentJob componentJob) {
  final Column[] physicalColumns = getPhysicalColumns(sourceColumnFinder, componentJob);
  final Table[] tables = getTables(sourceColumnFinder, componentJob, physicalColumns);
  for (final Table table : tables) {
    final RowProcessingStream dataStream = RowProcessingStream.ofSourceTable(job, table);
    registerRowProcessingPublishers(sourceColumnFinder, job, dataStream, componentJob, null);
  }
}

@Override
public void componentSuccess(final AnalysisJob job, final ComponentJob componentJob, final AnalyzerResult result) {
  for (final AnalysisListener delegate : _delegates) {
    try {
      delegate.componentSuccess(job, componentJob, result);
    } catch (final Exception e) {
      logFailure(delegate, e);
    }
  }
}

@Override
public ComponentMetrics getComponentMetrics(final ComponentJob componentJob) {
  final Table table = getRowProcessingTable(componentJob);
  final RowProcessingMetrics rowProcessingMetrics = getRowProcessingMetrics(table);
  return new ComponentMetricsImpl(rowProcessingMetrics, componentJob);
}

  @Override
  public void errorUnknown(final AnalysisJob job, final Throwable throwable) {
    for (final AnalysisListener delegate : _delegates) {
      try {
        delegate.errorUnknown(job, throwable);
      } catch (final Exception e) {
        logFailure(delegate, e);
      }
    }
  }
}

/**
 * Consumes a {@link InputRow} by applying all transformations etc. to it,
 * returning a result of transformed rows and their {@link FilterOutcomes}s.
 *
 * @param row
 * @return
 */
public ConsumeRowResult consumeRow(final InputRow row) {
  final FilterOutcomes outcomes = new FilterOutcomesImpl(_alwaysSatisfiedOutcomes);
  final ConsumeRowHandlerDelegate delegate = new ConsumeRowHandlerDelegate(_consumers, row, 0, outcomes);
  return delegate.consume();
}

protected final List<RowProcessingConsumer> getConsumersSorted() {
  final List<RowProcessingConsumer> consumers = getConsumers();
  final RowProcessingConsumerSorter sorter = new RowProcessingConsumerSorter(consumers);
  return sorter.createProcessOrderedConsumerList();
}

@Override
public void onComponentMessage(final AnalysisJob job, final ComponentJob componentJob,
    final ComponentMessage message) {
  for (final AnalysisListener delegate : _delegates) {
    try {
      delegate.onComponentMessage(job, componentJob, message);
    } catch (final Exception e) {
      logFailure(delegate, e);
    }
  }
}

@Override
public void rowProcessingSuccess(final AnalysisJob job, final RowProcessingMetrics metrics) {
  for (final AnalysisListener delegate : _delegates) {
    try {
      delegate.rowProcessingSuccess(job, metrics);
    } catch (final Exception e) {
      logFailure(delegate, e);
    }
  }
}

@Override
public void jobBegin(final AnalysisJob job, final AnalysisJobMetrics metrics) {
  for (final AnalysisListener delegate : _delegates) {
    try {
      delegate.jobBegin(job, metrics);
    } catch (final Exception e) {
      logFailure(delegate, e);
    }
  }
}

@Override
public void componentBegin(final AnalysisJob job, final ComponentJob componentJob, final ComponentMetrics metrics) {
  for (final AnalysisListener delegate : _delegates) {
    try {
      delegate.componentBegin(job, componentJob, metrics);
    } catch (final Exception e) {
      logFailure(delegate, e);
    }
  }
}

@Override
public void rowProcessingBegin(final AnalysisJob job, final RowProcessingMetrics metrics) {
  for (final AnalysisListener delegate : _delegates) {
    try {
      delegate.rowProcessingBegin(job, metrics);
    } catch (final Exception e) {
      logFailure(delegate, e);
    }
  }
}

@Override
public boolean isSuccessful() {
  await();
  return !_errorAware.isErrornous();
}

@Override
public void jobSuccess(final AnalysisJob job, final AnalysisJobMetrics metrics) {
  for (final AnalysisListener delegate : _delegates) {
    try {
      delegate.jobSuccess(job, metrics);
    } catch (final Exception e) {
      logFailure(delegate, e);
    }
  }
}

@Override
public void rowProcessingProgress(final AnalysisJob job, final RowProcessingMetrics metrics, final InputRow row,
    final int currentRow) {
  for (final AnalysisListener delegate : _delegates) {
    try {
      delegate.rowProcessingProgress(job, metrics, row, currentRow);
    } catch (final Exception e) {
      logFailure(delegate, e);
    }
  }
}

@Override
public Table getTable() {
  return _publisher.getStream().getTable();
}

@Override
public final Query getQuery() {
  return getQueryOptimizer().getOptimizedQuery();
}