Initialiser un RDD pour vider

J'ai un RDD appelé

JavaPairRDD<String, List<String>> existingRDD;

Maintenant, j'ai besoin d'initialiser cette existingRDD à vide de sorte que lorsque je reçois le réel rdd est que je peux faire une union avec ce existingRDD.
Comment initialiser existingRDD à un vide RDD à l'exception de l'initialiser à null?
Voici mon code:

JavaPairRDD<String, List<String>> existingRDD;
if(ai.get()%10==0)
{
    existingRDD.saveAsNewAPIHadoopFile("s3://manthan-impala-test/kinesis-dump/" + startTime + "/" + k + "/" + System.currentTimeMillis() + "/",
    NullWritable.class, Text.class, TextOutputFormat.class); //on worker failure this will get overwritten                                  
}
else
{
    existingRDD.union(rdd);
}

source d'informationauteur Chaitra Bannihatti

Je ne suis toujours pas sûr de ce que vous essayez de faire, mais vous pouvez créer un vide RDD comme suit :

//Get an RDD that has no partitions or elements.
JavaRDD<T> emptyRDD = sc.emptyRDD()

J'ai confiance que vous savez comment utiliser les génériques, sinon, elle est ici :

JavaRDD<Tuple2<String,List<String>>> emptyRDD = sc.emptyRDD();
JavaPairRDD<String,List<String>> emptyPairRDD = JavaPairRDD.fromJavaRDD(
  existingRDD
);

Vous pouvez également utiliser le mapToPair méthode pour convertir votre JavaRDD à un JavaPairRDD.

La solution dans scala :

scala> val emptyRDD = sc.emptyRDD
//emptyRDD: org.apache.spark.rdd.EmptyRDD[Nothing] = EmptyRDD[1] at ...

0

En scala, j'ai utilisé "paralléliser" de commande.
```
val emptyRDD = sc.parallelize(Seq(""))
```
0

@eliasah réponse est très utile, je suis en fournissant le code pour créer des vides paire de RDD. Imaginez un scénario dans lequel il est nécessaire de créer des vides paire de RDD (clé,valeur). Suite à la scala de code illustre comment créer des vides paire de RDD avec clé comme une Chaîne de caractères et la valeur comme de type Int.
```
type pairRDD = (String,Int)
var resultRDD = sparkContext.emptyRDD[pairRDD]
```
CA serait créé comme suit :
```
resultRDD: org.apache.spark.rdd.EmptyRDD[(String, Int)] = EmptyRDD[0] at emptyRDD at <console>:29
```

En Java, créer le vide CA a été un peu complexe. J'ai essayé à l'aide de la scala.de réfléchir.classTag mais il ne fonctionne pas non plus. Après de nombreux tests, le code qui a travaillé était encore plus simple.

private JavaRDD<Foo> getEmptyJavaRdd() {

/* this code does not compile because require <T> as parameter into emptyRDD */
//       JavaRDD<Foo> emptyRDD = sparkContext.emptyRDD();
//       return emptyRDD;

/* this should be the solution that try to emulate the scala <T> */
/* but i could not make it work too */
//       ClassTag<Foo> tag = scala.reflect.ClassTag$.MODULE$.apply(Foo.class);
//       return sparkContext.emptyRDD(tag);

/* this alternative worked into java 8 */
    return SparkContext.parallelize(
            java.util.Arrays.asList()
    );

}

0
```
val emptyRdd=sc.emptyRDD[String]
```
Déclaration ci-dessus va créer de vide RDD avec String Type

De SparkContext classe:

Obtenir un CA qui n'a pas de cloisons ou éléments
```
def emptyRDD[T: ClassTag]: EmptyRDD[T] = new EmptyRDD[T] (this)
```

En Java, de créer des vides paire de RDD comme suit:

JavaPairRDD<T, T> emptyPairRDD = JavaPairRDD.fromJavaRDD(SparkContext.emptyRDD());

Vous devez vous connecter pour publier un commentaire.