Page History

/**
 * This class represents a kind of partitioned data stream. For this stream, Each key group is a
 * partition, and the partition to which the data belongs is determined.
 */
public interface KeyedPartitionStream<K, T> {
    /**
     * Apply an operation to this {@link KeyedPartitionStream}.
     *
     * <p>This method is used to avoid shuffle after applying the process function. It is required
     * that for the same record, the new {@link KeySelector} must extract the same key as the
     * original {@link KeySelector} on this {@link KeyedPartitionStream}.
     *
     * @param processFunction to perform operation.
     * @param newKeySelector to select the key after process.
     * @return new {@link KeyedPartitionStream} with this operation.
     */
    <OUT> KeyedPartitionStream<K, OUT> process(
            OneInputStreamProcessFunction<T, OUT> processFunction,
            KeySelector<OUT, K> newKeySelector);

    /**
     * Apply an operation to this {@link KeyedPartitionStream};
     *
     * @param processFunction to perform operation.
     * @return new {@link NonKeyedPartitionStream} with this operation.
     */
    <OUT> NonKeyedPartitionStream<OUT> process(
            OneInputStreamProcessFunction<T, OUT> processFunction);

    /**
     * Apply a two output operation to this {@link KeyedPartitionStream}.
     *
     * <p>This method is used to avoid shuffle after applying the process function. It is required
     * that for the same record, these new two {@link KeySelector}s must extract the same key as the
     * original {@link KeySelector}s on this {@link KeyedPartitionStream}.
     *
     * @param processFunction to perform two output operation.
     * @param keySelector1 to select the key of first output.
     * @param keySelector2 to select the key of second output.
     * @return new {@link TwoKeyedPartitionStream} with this operation.
     */
    <OUT1, OUT2> TwoKeyedPartitionStreams<K, OUT1, OUT2> process(
            TwoOutputStreamProcessFunction<T, OUT1, OUT2> processFunction,
            KeySelector<OUT1, K> keySelector1,
            KeySelector<OUT2, K> keySelector2);

    /**
     * Apply a two output operation to this {@link KeyedPartitionStream}.
     *
     * @param processFunction to perform two output operation.
     * @return new {@link TwoNonKeyedPartitionStream} with this operation.
     */
    <OUT1, OUT2> TwoNonKeyedPartitionStreams<OUT1, OUT2> process(
            TwoOutputStreamProcessFunction<T, OUT1, OUT2> processFunction);

    /**
     * Apply a two input operation to this and other {@link KeyedPartitionStream}. The two keyed
     * streams must have the same partitions, otherwise it makes no sense to connect them.
     *
     * @param other {@link KeyedPartitionStream} to perform operation with two input.
     * @param processFunction to perform operation.
     * @return new {@link NonKeyedPartitionStream} with this operation.
     */
    <T_OTHER, OUT> NonKeyedPartitionStream<OUT> connectAndProcess(
            KeyedPartitionStream<K, T_OTHER> other,
            TwoInputStreamProcessFunction<T, T_OTHER, OUT> processFunction);

     /**
     * Apply a two input operation to this and other {@link KeyedPartitionStream}.The two keyed
     * streams must have the same partitions, otherwise it makes no sense to connect them.
     *
     * <p>This method is used to avoid shuffle after applying the process function. It is required
     * that for the same record, the new {@link KeySelector} must extract the same key as the
     * original {@link KeySelector}s on these two {@link KeyedPartitionStream}s.
     *
     * @param other {@link KeyedPartitionStream} to perform operation with two input.
     * @param processFunction to perform operation.
     * @param newKeySelector to select the key after process.
     * @return new {@link KeyedPartitionStream} with this operation.
     */
    <T_OTHER, OUT> KeyedPartitionStream<K, OUT> connectAndProcess(
            KeyedPartitionStream<K, T_OTHER> other,
            TwoInputStreamProcessFunction<T, T_OTHER, OUT> processFunction,
            KeySelector<OUT, K> newKeySelector);

    /**
     * Apply a two input operation to this and other {@link BroadcastStream}.
     *
     * @param processFunction to perform operation.
     * @return new stream with this operation.
     */
    <T_OTHER, OUT> NonKeyedPartitionStream<OUT> connectAndProcess(
            BroadcastStream<T_OTHER> other,
            TwoInputStreamProcessFunction<TBroadcastTwoInputStreamProcessFunction<T, T_OTHER, OUT> processFunction);

    /**
     * Apply Coalescea two thisinput streamoperation to athis and other {@link GlobalStreamBroadcastStream}.
     *
     * @return<p>This themethod coalescedis globalused stream.
to avoid shuffle after applying */
the process function. It GlobalStream<T> global();

is required
     /**
 that for the record *from Transform this stream to anon-broadcast input, the new {@link KeyedPartitionStreamKeySelector}.
 must extract   *the
     * @paramsame keySelectorkey toas decidethe howoriginal to map data to partition.{@link KeySelector}s on the {@link KeyedPartitionStream}. For the
     * @returnrecord from broadcast input, the transformedoutput streamkey partitionedfrom bykeyed key.
partition itself instead of new */key
     <NEW_KEY> KeyedPartitionStream<NEW_KEY, T> keyBy(KeySelector<T, NEW_KEY> keySelector);

* selector, so it is safe already.
     /**
     * Transform this stream to a new@param other {@link NonKeyedPartitionStreamBroadcastStream}, to dataperform willoperation bewith shuffledtwo betweeninput.
     * these@param processFunction twoto streamsperform operation.
     * @param newKeySelector to select the key after process.
     * @return the transformed stream after shufflenew {@link KeyedPartitionStream} with this operation.
     */
    NonKeyedPartitionStream<T> shuffle();
<T_OTHER, OUT> ProcessConfigurableAndKeyedPartitionStream<K, OUT> connectAndProcess(
    /**
     * Transform this stream to a new {@link BroadcastStream}.
BroadcastStream<T_OTHER> other,
         *
   BroadcastTwoInputStreamProcessFunction<T, T_OTHER, *OUT> @returnprocessFunction,
 the transformed {@link BroadcastStream}.
     */
   KeySelector<OUT, BroadcastStream<T>K> broadcast(newKeySelector);

      /**
     * Coalesce Sinkthis stream datato froma this{@link streamGlobalStream}.
     *
     * @param@return sinkthe to receive data from this coalesced global stream.
     */
    voidGlobalStream<T> toSinkglobal(Sink<T> sink);

    /**
     * ThisTransform this classstream representsto a combination of twonew {@link KeyedPartitionStream}.
 It will be used as*
     * @param keySelector theto returndecide valuehow ofto operationmap withdata twoto outputpartition.
     */
 @return the transformed interfacestream TwoKeyedPartitionStreams<K,partitioned T1, T2> {by key.
     */
   /** Get the first stream. */
        KeyedPartitionStream<K, T1> getFirst();
 <NEW_KEY> KeyedPartitionStream<NEW_KEY, T> keyBy(KeySelector<T, NEW_KEY> keySelector);

    /**
     * Transform this stream to a new {@link NonKeyedPartitionStream}, data will be shuffled between
     * these two streams.
     *
   /*  * Get@return the secondtransformed stream. */ after shuffle.
     */
   KeyedPartitionStream<K, T2>NonKeyedPartitionStream<T> getSecondshuffle();

    }
}

/**
     * Transform this stream to a new {@link BroadcastStream}.
     *
     * @return the transformed {@link BroadcastStream}.
     */
    BroadcastStream<T> broadcast();

    /**
     * Sink data from this stream.
     *
     * @param sink to receive data from this stream.
     */
    void toSink(Sink<T> sink);

    /**
     * This class represents a combination of two {@link KeyedPartitionStream}. It will be used as
     * the return value of operation with two output.
     */
    interface TwoKeyedPartitionStreams<K, T1, T2> {
        /** Get the first stream. */
        KeyedPartitionStream<K, T1> getFirst();

        /** Get the second stream. */
        KeyedPartitionStream<K, T2> getSecond();
    }
}