Flink DataStream 中 rejoindre

Fenêtre Join (fenêtre Rejoindre)

window joinIls partageront les mêmes keyet les mêmes éléments de fenêtre couplés entre eux deux courants. Distributeur de fenêtre peut être utilisée pour définir ces fenêtres, et évaluée selon les deux éléments d'écoulement.

L'élément est ensuite transféré à la fois défini par l' utilisateur JoinFunctionou FlatJoinFunctionlorsque l'utilisateur peut émettre les résultats satisfont à la condition de jointure.

usage général peut se résumer comme suit:

stream.join(otherStream)
    .where(<KeySelector>)
    .equalTo(<KeySelector>)
    .window(<WindowAssigner>)
    .apply(<JoinFunction>)

Quelques instructions sur la sémantique:

• Création d' éléments des deux flux paire se comporte comme une combinaison d' inner-joinéléments qui signifie que si un flux d'éléments qui ne veulent pas se connecter avec un autre courant de l'élément correspondant, l'élément ne sera pas émis.
• Ces éléments ne rejoignent seront le plus grand horodatage (toujours dans la fenêtre correspondante) comme un horodatage. Par exemple, [5, 10) se traduira par une frontière de fenêtre comporte un élément de liaison 9 en tant que son horodatage.

Dans la section suivante, nous allons décrire l'utilisation de différents types de scénarios lorsque certains exemplaires window joincomportement.

Tumbling Fenêtre Rejoindre

En exécution Tumbling Window Join, ont tous une commune keyet publiques Tumbling Window Joinéléments sont combinés en paires par le couplage, et est transmis à JoinFunctionou FlatJoinFunction. Parce qu'il se comporte comme un inner join, il ne sera pas délivré tumbling windowaucun élément dans un courant d'éléments d'un autre cours d' eau!

Comme on le voit, on définit une taille de 2 ms Tumbling Window, la fenêtre est sous la forme de [0,1], [2,3], .... La figure montre des combinaisons de tous les deux à deux éléments dans chaque fenêtre, la fenêtre sera transmis au JoinFunction. Notez que, dans la fenêtre bascule [6,7], étant donné que les éléments à relier et jointes à l' orange élément ⑥ n'existe pas dans le flux de vert, et donc ne délivre pas de contenu.

import org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

...

val orangeStream: DataStream[Integer] = ...
val greenStream: DataStream[Integer] = ...

orangeStream.join(greenStream)
    .where(elem => /* select key */)
    .equalTo(elem => /* select key */)
    .window(TumblingEventTimeWindows.of(Time.milliseconds(2)))
    .apply { (e1, e2) => e1 + "," + e2 }

Fenêtre coulissante Inscrivez-vous

Effectuées Sliding Window Join, le tout avec une commune keyet publiques Sliding Windowéléments sont groupées par paires reliées par, et transmis à JoinFunctionou FlatJoinFunction. Dans le courant Sliding Windowdans un flux de flux sans éléments d'autres éléments ne seront pas émis!

S'il vous plaît noter que certains éléments peuvent être connectés dans une fenêtre glissante, mais ne peuvent pas être connectés dans une autre fenêtre coulissante!

Dans cet exemple, on utilise la taille de la fenêtre glissante de 2 ms 1 ms temps de glissement, de manière à arriver fenêtre glissante [1,0], [0,1], [1,2], [2,3], ... . des éléments de liaison en dessous de l'axe x sont transmises à chacun des éléments JoinFunction fenêtre glissante. Ici vous pouvez voir, par exemple, comment une orange et vert ② ③ combiné dans la fenêtre [2,3], mais ne sont pas liées au vert ③ dans la fenêtre [1,2].

import org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

...

val orangeStream: DataStream[Integer] = ...
val greenStream: DataStream[Integer] = ...

orangeStream.join(greenStream)
    .where(elem => /* select key */)
    .equalTo(elem => /* select key */)
    .window(SlidingEventTimeWindows.of(Time.milliseconds(2) /* size */, Time.milliseconds(1) /* slide */))
    .apply { (e1, e2) => e1 + "," + e2 }

Session Fenêtre Rejoindre

Effectuer en Session Window Joinmême temps, avoir une session « combinaison » satisfait aux conditions keyde tous les éléments seront reliés entre eux par paires en combinaison, et est transmis à JoinFunctionou FlatJoinFunction. Exécuté à nouveau inner join, donc s'il y a un Session Window Joinne contient que les éléments d'un cours d' eau, il ne délivre aucune sortie!

Ici, nous définissons un Session Window Joinconnecteur, dans lequel l'intervalle entre chaque session d'au moins 1ms. Il y a trois sessions, deux session précédente, deux flux sont transmis à l'élément de couplage JoinFunction. Dans une troisième session, aucun élément de flux vert, ⑧ et ⑨ ne sont pas connectés!

import org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

...

val orangeStream: DataStream[Integer] = ...
val greenStream: DataStream[Integer] = ...

orangeStream.join(greenStream)
    .where(elem => /* select key */)
    .equalTo(elem => /* select key */)
    .window(EventTimeSessionWindows.withGap(Time.milliseconds(1)))
    .apply { (e1, e2) => e1 + "," + e2 }

Intervalle d'inscription (Intervalle d'inscription)

Interval JoinLe public keyélément reliant les deux courants (qui sont maintenant appelés A et B), l'élément B et le débit du flux élémentaire ayant un horodatage Un horodatage est un intervalle de temps relatif .

Cela peut aussi être exprimée sous la forme plus formelle b.timestamp ∈ [a.timestamp + lowerBound; a.timestamp + upperBound]oua.timestamp + lowerBound <= b.timestamp <= a.timestamp + upperBound

Où a et b sont des éléments de A et B, ils partagent une commune key. Tant que la limite inférieure est toujours inférieure ou égale à la limite supérieure, les limites inférieures et supérieures qui peuvent être positifs ou négatifs. Interval JoinL'exécution en cours seulement inner joins. Elle est transmise à la paire d'éléments ProcessJoinFunction, plus ils seront affectés TimeStamps deux éléments (par ProcessJoinFunction.Contextaccès).

Remarque: ne Interval Joinsupporte actuellement que le temps de l' événement.

Dans l'exemple ci - dessus, les deux courants seront « orange » et « vert » sont reliés entre eux, la limite inférieure -2 ms, la limite supérieure est de +1 millisecondes. Par défaut, ces limites sont comprises, mais .lowerBoundExclusive(), et .upperBoundExclusivepeuvent être appliqués pour modifier le comportement.

Plus notation formelle utilisée à nouveau, cela se traduira orangeElem.ts + lowerBound <= greenElem.ts <= orangeElem.ts + upperBoundcomme indiqué dans un triangle.

import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction;
import org.apache.flink.streaming.api.windowing.time.Time;

...

val orangeStream: DataStream[Integer] = ...
val greenStream: DataStream[Integer] = ...

orangeStream
    .keyBy(elem => /* select key */)
    .intervalJoin(greenStream.keyBy(elem => /* select key */))
    .between(Time.milliseconds(-2), Time.milliseconds(1))
    .process(new ProcessJoinFunction[Integer, Integer, String] {
        override def processElement(left: Integer, right: Integer, ctx: ProcessJoinFunction[Integer, Integer, String]#Context, out: Collector[String]): Unit = {
         out.collect(left + "," + right); 
        }
      });
    });

Suggestions de lecture:

https://ci.apache.org/projects/flink/flink-docs-release-1.9/dev/stream/operators/joining.html

https://github.com/perkinls/flink-local-train

https://yq.aliyun.com/users/ohyfzrwxmb3me?spm=a2c4e.11153940.0.0.763648d5EoX4bX