Pyspark se joint à la paire RDD

Dans Python, Pyspark est un module Spark utilisé pour fournir un type de traitement similaire comme Spark.

RDD signifie ensemble de données distribuées résilientes. Nous pouvons appeler RDD comme une structure de données fondamentale dans Apache Spark. La paire RDD stocke les éléments / valeurs sous la forme de paires de valeurs clés. Il stockera la paire de valeurs de clé dans le format (clé, valeur).

Nous devons importer RDD à partir du pyspark.module RDD.

Dans Pyspark pour créer un RDD, nous pouvons utiliser la méthode parallelize ().

Syntaxe:

Spark_App.étincelle.paralléliser (données)

Où:

Les données peuvent être une dimension (données linéaires) ou des données bidimensionnelles (données en row-colonne).

Dans ce tutoriel, nous verrons différentes jointures effectuées sur Pyspark Pair Rdd. Tous les jointures fonctionnent en fonction des clés de la paire RDD.

Pyspark paire rdd - join ()

join () est utilisé pour effectuer une jointure intérieure sur la paire RDD.

Résultats de la jonction intérieure dans le RDD en sélectionnant uniquement les lignes correspondantes à partir de deux RDD.

Syntaxe:

paire_rdd1.join (pair_rdd2)

Où:

1. pair_rdd1 est le premier RDD
2. pair_rdd2 ​​est le deuxième RDD.

Exemple:

Dans cet exemple, nous utiliserons join () pour effectuer une jointure intérieure sur deux RDD.

# importer le module Pyspark
Importer Pyspark
#mport Sparkcession pour la création d'une session
de Pyspark.SQL IMPORT SPARKSESSE
# Importer RDD de Pyspark.RDD
de Pyspark.RDD IMPORT RDD
#create une application nommée Linuxhint
Spark_App = Sparkcession.constructeur.appname ('Linuxhint').getorCreate ()
# Créer 4 paires de notation des sujets
sujets_rating1 = spark_app.étincelle.Parallélize ([('Linux', 1), ('C #', 2), ('Javascript', 4), ('Python', 5)])
# Créer 2 paires de notation des sujets
sujets_rating2 = spark_app.étincelle.parallélize ([('Linux', 4), ('Java', 2)])
#Perform Inner Join
imprimer (sujets_rating1.join (sujets_rating2).collecter())

Sortir:

[('Linux', (1, 4))]

Ici, sujets_rating1 est le premier RDD qui a les paires suivantes: ('Linux', 1), ('C #', 2), ('javascrip qui a les paires suivantes: ('Linux', 4), ('Java', 2).

Donc, la clé - Linux existe dans les deux paires RDD. Par conséquent, les valeurs sont renvoyées par rapport à la clé.

Pyspark paire rdd - leftouterjoin ()

LeftouterJoin () est utilisé pour effectuer la jointure de gauche sur la paire RDD.

Les résultats de la jointure de gauche dans le RDD en sélectionnant toutes les lignes dans le premier RDD et que les lignes ne correspondaient que du deuxième RDD par rapport aux lignes du premier RDD.

Syntaxe:

paire_rdd1.Leftouterjoin (pair_rdd2)

Où:

1. pair_rdd1 est le premier RDD
2. pair_rdd2 ​​est le deuxième RDD.

Exemple:

Dans cet exemple, nous utiliserons LeftouterJoin () pour effectuer une jointure de gauche sur deux RDD.

# importer le module Pyspark
Importer Pyspark
#mport Sparkcession pour la création d'une session
de Pyspark.SQL IMPORT SPARKSESSE
# Importer RDD de Pyspark.RDD
de Pyspark.RDD IMPORT RDD
#create une application nommée Linuxhint
Spark_App = Sparkcession.constructeur.appname ('Linuxhint').getorCreate ()
# Créer 4 paires de notation des sujets
sujets_rating1 = spark_app.étincelle.Parallélize ([('Linux', 1), ('C #', 2), ('Javascript', 4), ('Python', 5)])
# Créer 2 paires de notation des sujets
sujets_rating2 = spark_app.étincelle.parallélize ([('Linux', 4), ('Java', 2)])
#Perform gauche gauche jointure
imprimer (sujets_rating1.LeftouterJoin (SubjectS_Rating2).collecter())

Sortir:

[('Python', (5, aucun)), ('Linux', (1, 4)), ('C #', (2, aucun)), ('javascript', (4, aucun))]]

Ici, sujets_rating1 est le premier RDD qui a les paires suivantes: ('Linux', 1), ('C #', 2), ('javascrip qui a les paires suivantes: ('Linux', 4), ('Java', 2).

Il n'y a pas de touches Python, C # et JavaScript dans le deuxième RDD, donc les valeurs ne sont pas dans les deuxièmes valeurs RDD. Mais Key-Linux existe dans les deux RDD. Ainsi, les valeurs 1,4 ont été retournées.

Pyspark paire rdd - rightouterjoin ()

RightouterJoin () est utilisé pour effectuer une jointure à droite sur la paire RDD.

Les résultats de la jointure à droite dans le RDD en sélectionnant toutes les lignes dans le deuxième RDD et que les lignes ne correspondaient que du premier RDD par rapport aux lignes du deuxième RDD.

Syntaxe:

paire_rdd1.rightouterjoin (pair_rdd2)

Où:

1. pair_rdd1 est le premier RDD
2. pair_rdd2 ​​est le deuxième RDD.

Exemple:

Dans cet exemple, nous utiliserons RightouterJoin () pour effectuer une jointure droite sur deux RDD.

# importer le module Pyspark
Importer Pyspark
#mport Sparkcession pour la création d'une session
de Pyspark.SQL IMPORT SPARKSESSE
# Importer RDD de Pyspark.RDD
de Pyspark.RDD IMPORT RDD
#create une application nommée Linuxhint
Spark_App = Sparkcession.constructeur.appname ('Linuxhint').getorCreate ()
# Créer 4 paires de notation des sujets
sujets_rating1 = spark_app.étincelle.Parallélize ([('Linux', 1), ('C #', 2), ('Javascript', 4), ('Python', 5)])
# Créer 2 paires de notation des sujets
sujets_rating2 = spark_app.étincelle.parallélize ([('Linux', 4), ('Java', 2)])
#Perform droit extérieur
imprimer (sujets_rating1.rightouterjoin (sujets_rating2).collecter())

Sortir:

[('Java', (aucun, 2)), ('Linux', (1, 4))]

Ici, sujets_rating1 est le premier RDD qui a les paires suivantes: ('Linux', 1), ('C #', 2), ('javascrip qui a les paires suivantes: ('Linux', 4), ('Java', 2).

Il n'y a pas de clé Java dans le premier RDD, donc la valeur n'est pas dans les premières valeurs RDD. Mais Key-Linux existe dans les deux RDD. Ainsi, les valeurs 1,4 ont été retournées.

Pyspark paire rdd - fullouterjoin ()

FullouterJoin () est utilisé pour effectuer une jointure extérieure sur la paire RDD.

Résultats de la jointure extérieure complète dans le RDD en sélectionnant toutes les lignes dans les deux RDD. Il ne place aucune valeur pour les lignes inégalées dans les deux RDD à travers les lignes.

Syntaxe:

paire_rdd1.fullouterjoin (pair_rdd2)

Où:

1. pair_rdd1 est le premier RDD
2. pair_rdd2 ​​est le deuxième RDD.

Exemple:

Dans cet exemple, nous utiliserons FullouterJoin () pour effectuer une jointure extérieure sur deux RDD.

# importer le module Pyspark
Importer Pyspark
#mport Sparkcession pour la création d'une session
de Pyspark.SQL IMPORT SPARKSESSE
# Importer RDD de Pyspark.RDD
de Pyspark.RDD IMPORT RDD
#create une application nommée Linuxhint
Spark_App = Sparkcession.constructeur.appname ('Linuxhint').getorCreate ()
# Créer 4 paires de notation des sujets
sujets_rating1 = spark_app.étincelle.Parallélize ([('Linux', 1), ('C #', 2), ('Javascript', 4), ('Python', 5)])
# Créer 2 paires de notation des sujets
sujets_rating2 = spark_app.étincelle.parallélize ([('Linux', 4), ('Java', 2)])
#Perform extérieure jointure
imprimer (sujets_rating1.fullouterjoin (sujets_rating2).collecter())

Sortir:

[('Python', (5, aucun)), ('Java', (aucun, 2)), ('Linux', (1, 4)), ('C #', (2, aucun)), ( 'javascript', (4, aucun))]

Conclusion

Avec ce tutoriel, nous avons appris que Pyspark RDD prend en charge 4 types de jointures. Pour effectuer une jointure intérieure, nous pouvons simplement utiliser join (), leftouterjoin () est utilisé pour effectuer la gauche join. Pour effectuer une jointure extérieure, FullouterJoin () est utilisé.