@Nullable @Override public Watermark getCurrentWatermark() { return new Watermark(currentTimestamp == Long.MIN_VALUE ? Long.MIN_VALUE : currentTimestamp - 1); } }
@Override public Watermark getCurrentWatermark() { // make sure timestamps are monotonously increasing, even when the system clock re-syncs final long now = Math.max(System.currentTimeMillis(), maxTimestamp); maxTimestamp = now; return new Watermark(now - 1); } }
@Override public Watermark checkAndGetNextWatermark(Tuple2<String, Integer> lastElement, long extractedTimestamp) { return new Watermark(lastElement.f1 - 1); } }
@Override public Watermark checkAndGetNextWatermark(Integer element, long extractedTimestamp) { return new Watermark(extractedTimestamp - 1); } })
@Override public Watermark getCurrentWatermark() { return new Watermark(currentTimestamp == Long.MIN_VALUE ? Long.MIN_VALUE : currentTimestamp - 1); } }
@Override public Watermark checkAndGetNextWatermark(Integer element, long extractedTimestamp) { return new Watermark(extractedTimestamp - 1); } })
@Override public Watermark checkAndGetNextWatermark(Tuple2<String, Integer> element, long extractedTimestamp) { return new Watermark(extractedTimestamp - 1); } }
@Override public Watermark checkAndGetNextWatermark(Tuple3<String, String, Integer> lastElement, long extractedTimestamp) { return new Watermark(lastElement.f2 - 1); } }
@Nullable @Override public Watermark checkAndGetNextWatermark(T lastElement, long extractedTimestamp) { return new Watermark(extractedTimestamp); } }
public void processWatermark1(Watermark mark) throws Exception { input1Watermark = mark.getTimestamp(); long newMin = Math.min(input1Watermark, input2Watermark); if (newMin > combinedWatermark) { combinedWatermark = newMin; processWatermark(new Watermark(combinedWatermark)); } }
@Nullable @Override public Watermark checkAndGetNextWatermark(T lastElement, long extractedTimestamp) { return new Watermark(extractedTimestamp); } }
@Nullable @Override public Watermark getCurrentWatermark() { return new Watermark(maxTimestamp); } }
@Nullable @Override public Watermark checkAndGetNextWatermark(Integer lastElement, long extractedTimestamp) { return new Watermark(extractedTimestamp); }
@Nullable @Override public Watermark checkAndGetNextWatermark(Long lastElement, long extractedTimestamp) { return extractedTimestamp % 3 == 0 ? new Watermark(extractedTimestamp) : null; }
@Override protected void handleElement(StreamRecord<String> element) { long timestamp = Long.valueOf(element.getValue()); if (timestamp > lastWatermark) { output.emitWatermark(new Watermark(timestamp)); lastWatermark = timestamp; } }
@Override public void run(SourceContext<Integer> ctx) throws Exception { for (int i = 0; i < numWatermarks; i++) { ctx.collectWithTimestamp(i, initialTime + i); ctx.emitWatermark(new Watermark(initialTime + i)); } }
@Override public void onProcessingTime(long timestamp) throws Exception { // register next timer long newWatermark = userFunction.getCurrentWatermark(); if (newWatermark > currentWatermark) { currentWatermark = newWatermark; // emit watermark output.emitWatermark(new Watermark(currentWatermark)); } long now = getProcessingTimeService().getCurrentProcessingTime(); getProcessingTimeService().registerTimer(now + watermarkInterval, this); }
@Override public void run(SourceContext<Integer> ctx) throws Exception { ctx.collectWithTimestamp(1, 0); ctx.emitWatermark(new Watermark(0)); ctx.collectWithTimestamp(2, 1); ctx.collectWithTimestamp(5, 2); ctx.emitWatermark(new Watermark(2)); ctx.collectWithTimestamp(3, 3); ctx.collectWithTimestamp(4, 4); }
@Override public void processElement(StreamRecord<T> element) throws Exception { long newTimestamp = userFunction.extractTimestamp(element.getValue(), element.getTimestamp()); output.collect(element.replace(element.getValue(), newTimestamp)); long watermark = userFunction.extractWatermark(element.getValue(), newTimestamp); if (watermark > currentWatermark) { currentWatermark = watermark; output.emitWatermark(new Watermark(currentWatermark)); } }