web-dev-qa-db-fra.com

Apache Spark rejoint l'exemple avec Java

Je suis très nouveau pour Apache Spark. En fait, j'aimerais me concentrer sur la spécification de base des API Spark et comprendre et écrire des programmes utilisant Spark API . J'ai écrit un programme Java utilisant Apache Spark pour implémenter le concept Joins.

Lorsque j'utilise Left Outer Join - leftOuterJoin () ou Right Outer Join - rightOuterJoin (), les deux méthodes renvoient un JavaPairRDD contenant un type spécial Google Options. Mais je ne sais pas comment extraire les valeurs d'origine de type facultatif.

Quoi qu'il en soit, j'aimerais savoir si je peux utiliser les mêmes méthodes de jointure qui renvoient les données dans mon propre format. Je n'ai trouvé aucun moyen de le faire. La signification est lorsque j'utilise Apache Spark, je ne suis pas en mesure de personnaliser le code dans mon propre style car ils ont déjà donné toutes les choses prédéfinies.

S'il vous plaît trouver le code ci-dessous

my 2 sample input datasets

customers_data.txt:
4000001,Kristina,Chung,55,Pilot
4000002,Paige,Chen,74,Teacher
4000003,Sherri,Melton,34,Firefighter

and

trasaction_data.txt
00000551,12-30-2011,4000001,092.88,Games,Dice & Dice Sets,Buffalo,New York,credit
00004811,11-10-2011,4000001,180.35,Outdoor Play Equipment,Water Tables,Brownsville,Texas,credit
00034388,09-11-2011,4000002,020.55,Team Sports,Beach Volleyball,Orange,California,cash
00008996,11-21-2011,4000003,121.04,Outdoor Recreation,Fishing,Colorado Springs,Colorado,credit
00009167,05-24-2011,4000003,194.94,Exercise & Fitness,Foam Rollers,El Paso,Texas,credit

Voici mon code Java

**SparkJoins.Java:**

public class SparkJoins {

    @SuppressWarnings("serial")
    public static void main(String[] args) throws FileNotFoundException {
        JavaSparkContext sc = new JavaSparkContext(new SparkConf().setAppName("Spark Count").setMaster("local"));
        JavaRDD<String> customerInputFile = sc.textFile("C:/path/customers_data.txt");
        JavaPairRDD<String, String> customerPairs = customerInputFile.mapToPair(new PairFunction<String, String, String>() {
            public Tuple2<String, String> call(String s) {
                String[] customerSplit = s.split(",");
                return new Tuple2<String, String>(customerSplit[0], customerSplit[1]);
            }
        }).distinct();

        JavaRDD<String> transactionInputFile = sc.textFile("C:/path/transactions_data.txt");
        JavaPairRDD<String, String> transactionPairs = transactionInputFile.mapToPair(new PairFunction<String, String, String>() {
            public Tuple2<String, String> call(String s) {
                String[] transactionSplit = s.split(",");
                return new Tuple2<String, String>(transactionSplit[2], transactionSplit[3]+","+transactionSplit[1]);
            }
        });

        //Default Join operation (Inner join)
        JavaPairRDD<String, Tuple2<String, String>> joinsOutput = customerPairs.join(transactionPairs);
        System.out.println("Joins function Output: "+joinsOutput.collect());

        //Left Outer join operation
        JavaPairRDD<String, Iterable<Tuple2<String, Optional<String>>>> leftJoinOutput = customerPairs.leftOuterJoin(transactionPairs).groupByKey().sortByKey();
        System.out.println("LeftOuterJoins function Output: "+leftJoinOutput.collect());

        //Right Outer join operation
        JavaPairRDD<String, Iterable<Tuple2<Optional<String>, String>>> rightJoinOutput = customerPairs.rightOuterJoin(transactionPairs).groupByKey().sortByKey();
        System.out.println("RightOuterJoins function Output: "+rightJoinOutput.collect());

        sc.close();
    }
}

Et voici la sortie que je reçois

Joins function Output: [(4000001,(Kristina,092.88,12-30-2011)), (4000001,(Kristina,180.35,11-10-2011)), (4000003,(Sherri,121.04,11-21-2011)), (4000003,(Sherri,194.94,05-24-2011)), (4000002,(Paige,020.55,09-11-2011))]

LeftOuterJoins function Output: [(4000001,[(Kristina,Optional.of(092.88,12-30-2011)), (Kristina,Optional.of(180.35,11-10-2011))]), (4000002,[(Paige,Optional.of(020.55,09-11-2011))]), (4000003,[(Sherri,Optional.of(121.04,11-21-2011)), (Sherri,Optional.of(194.94,05-24-2011))])]

RightOuterJoins function Output: [(4000001,[(Optional.of(Kristina),092.88,12-30-2011), (Optional.of(Kristina),180.35,11-10-2011)]), (4000002,[(Optional.of(Paige),020.55,09-11-2011)]), (4000003,[(Optional.of(Sherri),121.04,11-21-2011), (Optional.of(Sherri),194.94,05-24-2011)])]

J'exécute ce programme sur la plate-forme Windows

Veuillez observer le résultat ci-dessus et aidez-moi à extraire les valeurs du type facultatif

Merci d'avance

javajoinapache-sparkoptional
11
Shekar Patel

Lorsque vous faites une jointure externe gauche et une jointure externe droite, vous pouvez avoir des valeurs null. droite!

Donc, spark renvoie un objet facultatif. Après avoir obtenu ce résultat, vous pouvez mapper ce résultat sur votre propre format. 

vous pouvez utiliser la méthode isPresent () de Optional pour mapper vos données.

Voici l'exemple: 

 JavaPairRDD<String,String> firstRDD = ....
 JavaPairRDD<String,String> secondRDD =....
 // join both rdd using left outerjoin
 JavaPairRDD<String, Tuple2<String, Optional<Boolean>>> rddWithJoin = firstRDD.leftOuterJoin(secondRDD);


// mapping of join result
JavaPairRDD<String, String> mappedRDD = rddWithJoin
            .mapToPair(Tuple -> {
                if (Tuple._2()._2().isPresent()) {
                    //do your operation and return
                    return new Tuple2<String, String>(Tuple._1(), Tuple._2()._1());
                } else {
                    return new Tuple2<String, String>(Tuple._1(), "not present");
                }
            });
11
sms_1190

En Java, nous pouvons également implémenter des JOIN en utilisant DataFrames comme suit:

1) créer une session d'allumage en tant que:

SparkSession spark = SparkSession.builder().appName("JoinsInSpark").master("local").getOrCreate();

2) J'ai pris l'entrée Employé comme:

101, Alan, rue Franklyn, Melbourne, QLD

104, Stuart, rue Lonsdale, Sydney, Nouvelle-Galles du Sud

créer DataFrame en tant que:

Dataset<Employee> e_data = spark
                        .read()
                        .textFile("C:/XX/XX/test.txt")
                        .map(line -> {
                            Employee e = new Employee();
                            String[] parts = line.split(",");
                            e.setE_id(Integer.valueOf(parts[0].trim()));
                            e.setE_name(parts[1].trim());
                            e.setAddress(parts[2].trim());
                            e.setCity(parts[3].trim());
                            e.setState(parts[4].trim());
                            return e;
                        }, Encoders.bean(Employee.class));

où Employee est la classe POJO contenant le setter, le getter avec le constructeur.

3) de même créer un autre DF pour la deuxième table (par exemple salaire)

4) Appliquer la jointure INNER sur des éléments distincts des deux vues:

Dataset<Row> d1 = e_data.distinct().join(s_data.distinct(), "e_id").orderBy("salary");

d1.show();

5) similaire, jointure externe gauche en tant que:

spark.sql("select * from global_temp.employee e LEFT OUTER JOIN global_temp.salary s on e.e_id = s.e_id").show();
0
RPaul