la Première chose est DataFrame a évolué de SchemaRDD .

Oui.. la conversion entre Dataframe et RDD est absolument possible.

voici quelques exemples de codes.

• df.rdd est RDD[Row]

ci-dessous sont quelques options pour créer dataframe.

• 1) yourrddOffrow.toDF convertit en DataFrame .

• 2) utilisant createDataFrame de contexte sql

  val df = spark.createDataFrame(rddOfRow, schema)

où le schéma peut être de certaines des options ci-dessous comme décrit par nice so post..

Scala cas de la classe et de la scala api reflection

import org.apache.spark.sql.catalyst.ScalaReflection
val schema = ScalaReflection.schemaFor[YourScalacaseClass].dataType.asInstanceOf[StructType]

ou en utilisant Encoders

import org.apache.spark.sql.Encoders
val mySchema = Encoders.product[MyCaseClass].schema

comme décrit par le schéma peut également être créé en utilisant StructType et StructField

val schema = new StructType()
  .add(StructField("id", StringType, true))
  .add(StructField("col1", DoubleType, true))
  .add(StructField("col2", DoubleType, true)) etc...

en fait, Il ya maintenant 3 APIs Apache Spark..

1. RDD API:

L'API RDD (Resilient Distributed Dataset) est en étincelle depuis la version 1.0.

L'API RDD fournit de nombreuses méthodes de transformation, telles que map (), filter (), et reduce () pour effectuer des calculs sur les données. Chacun de ces méthodes résulte un nouveau RDD représentant le données. Cependant, ces méthodes sont simplement définir les opérations à effectuée et les transformations ne sont pas effectuées jusqu'à ce qu'une action la méthode est appelée. Des exemples de méthodes d'action sont collect () et saveAsObjectFile ().

exemple RDD:

rdd.filter(_.age > 21) // transformation
   .map(_.last)// transformation
.saveAsObjectFile("under21.bin") // action

exemple: filtre par attribut avec RDD

rdd.filter(_.age > 21)

2. DataFrame API

Spark 1.3 introduit une nouvelle API DataFrame dans le cadre du projet Initiative de tungstène qui vise à améliorer la performance et l'évolutivité de la Spark. L'API DataFrame introduit le concept de schéma pour décrire les données, permettant une Étincelle pour gérer le schéma et les ne transmettre les données qu'entre les noeuds, d'une manière beaucoup plus efficace qu'en utilisant La sérialisation Java.

L'API DataFrame est radicalement différente de l'API RDD parce qu'elle est une API pour construire un plan de requête relationnelle que le catalyseur de Spark optimiseur peut ensuite exécuter. L'API est naturelle pour les développeurs qui sont familier avec les plans de requête de bâtiment

exemple de style SQL :

df.filter("age > 21");

Limitations: Comme le code renvoie à des attributs de données par leur nom, il n'est pas possible pour le compilateur de détecter des erreurs. Si les noms d'attribut sont incorrects, l'erreur ne sera détectée qu'à l'exécution, lorsque le plan de requête est créé.

un autre inconvénient de l'API DataFrame est qu'il est très scala-centric et bien qu'il supporte Java, le support est limité.

par exemple, lors de la création d'un DataFrame à partir d'un RDD existant D'objets Java, Spark's Catalyst optimizer ne peut pas inférer le schéma et suppose que n'importe quels objets dans le DataFrame implémentent l'interface scala.Product . Scala case class travaille sur la boîte parce qu'ils mettent en œuvre cette interface.

3. Dataset API

L'API Dataset , publiée en tant qu'aperçu de L'API dans Spark 1.6, vise à fournir le meilleur des deux mondes; le familier orienté objet style de programmation et type de compilation-sécurité de l'API RDD mais avec les avantages de performance de L'optimiseur de requêtes Catalyst. Ensembles de données utilisez également le même mécanisme de stockage hors tas efficace que le DataFrame API.

quand il s'agit de sérialiser data, L'API Dataset a le concept de codeurs traduisant entre les représentations (objets) et Format binaire interne de Spark. Spark a des encodeurs intégrés qui sont très avancé en ce qu'ils génèrent du code octet pour interagir avec données hors tas et accès sur demande à des attributs individuels sans devoir dé-sérialiser un objet entier. Spark n'est pas encore fournir une API pour implémenter des encodeurs personnalisés, mais cela est prévu pour une version future.

de plus, L'API Dataset est conçue pour fonctionner aussi bien avec Java et Scala. Lorsque vous travaillez avec des objets Java, c'est important qu'ils sont entièrement conformes aux haricots.

exemple Dataset API SQL style:

dataset.filter(_.age < 21);

Évaluations diff. entre DataFrame & DataSet :

autres lectures... databricks article

RDD

la principale étincelle d'abstraction fournit est un ensemble de données réparties résilientes (RDD), qui est une collection d'éléments répartis à travers les noeuds de la grappe qui peuvent être exploités en parallèle.

RDD Features: -

• Collection distribuée:
  
  RDD utilise les opérations MapReduce qui est largement adopté pour le traitement et la génération de grands ensembles de données avec un algorithme distribué parallèle sur un cluster. Il permet aux utilisateurs d'écrire des calculs en parallèle, en utilisant un ensemble d'opérateurs de haut niveau, sans avoir à se soucier de la répartition du travail et de la tolérance aux pannes.

• Immuable: RDDs composé d'un ensemble d'enregistrements qui sont partitionnés. Une partition est une unité de base du parallélisme dans un RDD, et chaque partition est une la division logique des données qui est immuable et créé par quelques transformations sur les partitions existantes.L'immutabilité aide à obtenir de la cohérence dans les calculs.

• tolérance à la faille: Dans un cas où nous perdons une partition de RDD , nous pouvons rejouer la transformation sur cette partition dans la lignée pour obtenir le même calcul, plutôt que de faire la réplication de données à travers plusieurs noeuds.Cette caractéristique est la plus avantage de RDD parce qu'il économise beaucoup d'efforts dans la gestion des données et la réplication et permet ainsi des calculs plus rapides.

• Lazy evaluations: toutes les transformations dans Spark sont paresseuses, en ce qu'elles ne calculent pas leurs résultats tout de suite. Au lieu de cela, ils se souviennent juste des transformations appliquées à un ensemble de données de base . Les transformations sont calculé uniquement lorsqu'une action requiert un être remis au chauffeur programme.

• transformations fonctionnelles: Les RDDs prennent en charge deux types d'opérations: les transformations, qui créent un nouvel ensemble de données à partir d'un ensemble existant, et les actions, qui renvoient une valeur au programme pilote après avoir exécuté un calcul sur l'ensemble de données.

• formats de traitement de données:

il peut traiter facilement et efficacement des données structurées et non structurées.

• langages de programmation pris en charge:
  
  L'API RDD est disponible en Java, Scala, Python et R.

Limitations RDD: -

• pas de moteur d'optimisation intégré: Lorsqu'ils travaillent avec des données structurées, les DGR ne peuvent pas prendre les avantages des optimiseurs avancés de Spark, y compris l'optimiseur de catalyseur et le moteur D'exécution de tungstène. Les développeurs doivent optimiser chaque RDD en fonction de ses attributs.

• traitement de données structurées: Contrairement au Dataframe et aux ensembles de données, le RDDs n'infère pas le schéma des données ingérées et demande à l'utilisateur de le spécifier.

Dataframes

Spark introduit Dataframes en version Spark 1.3. Dataframe surmonte les principaux défis que les DGR avaient à relever.

une base de données est une collection distribuée de données organisées en colonnes nommées. Il est conceptuellement équivalent à une table dans une base de données relationnelle ou une base de données R/Python. Avec Dataframe, Spark a également introduit catalyst optimizer, qui utilise des fonctionnalités de programmation avancées pour construire un optimiseur de requête extensible.

Caractéristiques De Dataframe: -

• Collection distribuée D'objets de rang: Une DataFrame est une collection distribuée de données organisées en colonnes nommées. Elle est conceptuellement équivalente à une table dans une base de données relationnelle, mais avec des optimisations plus riches sous le capot.

• Traitement Des Données: Traitement de formats de données structurés et non structurés (Avro, CSV, elastic search, et Cassandra) et des systèmes de stockage (HDFS, HIVE tables, MySQL, etc). Il peut lire et écrire à partir de ces différentes sources de données.

• optimisation à l'aide d'un optimiseur de catalyseur: Il alimente à la fois les requêtes SQL et l'API DataFrame. Dataframe l'utilisation du catalyseur de l'arbre de transformation de cadre en quatre phases,

  1.Analyzing a logical plan to resolve references
  2.Logical plan optimization
  3.Physical planning
  4.Code generation to compile parts of the query to Java bytecode.
  

• Compatibilité Ruche: En utilisant Spark SQL, vous pouvez exécuter des requêtes non modifiées sur vos entrepôts de ruches existants. Il réutilise Hive frontend et MetaStore et vous offre une compatibilité totale avec les données Hive, requêtes et UDFs existants.

• tungstène: Le tungstène fournit un backend d'exécution physique qui gère explicitement la mémoire et génère dynamiquement un bytecode pour l'évaluation de l'expression.

• langages de programmation pris en charge:
  
  L'API Dataframe est disponible en Java, Scala, Python et R.

Limitations Du Dataframe: -

• compiler-time Type safety: Comme indiqué précédemment, L'API Dataframe ne supporte pas la sécurité de compilation, ce qui vous empêche de manipuler les données lorsque la structure n'est pas connue. L'exemple suivant fonctionne pendant moment de la compilation. Cependant, vous obtiendrez une exception d'Exécution lors de l'exécution de ce code.

exemple:

case class Person(name : String , age : Int) 
val dataframe = sqlContect.read.json("people.json") 
dataframe.filter("salary > 10000").show 
=> throws Exception : cannot resolve 'salary' given input age , name

c'est particulièrement difficile lorsque vous travaillez avec plusieurs étapes de transformation et d'agrégation.

• ne peut opérer sur un objet de domaine (objet de domaine perdu): Une fois que vous avez transformé un objet domain en dataframe, vous ne pouvez pas le régénérer à partir de celui-ci. Dans le en suivant l'exemple, une fois que nous aurons créé personDF à partir de personRDD, nous ne pourrons pas récupérer le RDD original de la classe Person (RDD[Person]).

exemple:

case class Person(name : String , age : Int)
val personRDD = sc.makeRDD(Seq(Person("A",10),Person("B",20)))
val personDF = sqlContect.createDataframe(personRDD)
personDF.rdd // returns RDD[Row] , does not returns RDD[Person]

API des ensembles de données

L'API D'ensemble de données est une extension aux images de données qui fournit une interface de programmation type-sûr, orientée objet. Il est fortement typé, immuable collection d'objets qui sont associés à un schéma relationnel.

au cœur de L'ensemble de données, API est un nouveau concept appelé encoder, qui est responsable de la conversion entre les objets JVM et la représentation tabulaire. La représentation tabulaire est stockée en utilisant le format binaire interne de tungstène Spark, permettant des opérations sur les données sérialisées et l'utilisation améliorée de la mémoire. Spark 1.6 est livré avec le soutien pour la génération automatique d'encodeurs pour une grande variété de types, y compris les types primitifs (par exemple String, Integer, Long), Les classes de cas Scala, et Java Beans.

Caractéristiques De L'Ensemble De Données: -

• fournit le meilleur de RDD et Dataframe: RDD(programmation fonctionnelle, type de coffre-fort), DataFrame (modèle relationnel, Requête optimazation , de Tungstène d'exécution, de tri et de brassage)

• codeurs: Avec L'utilisation d'encodeurs, il est facile de convertir n'importe quel objet JVM en Ensemble de données, permettant aux utilisateurs de travailler avec des données structurées et non structurées contrairement à Dataframe.

• langages de programmation pris en charge: L'API d'ensembles de données n'est actuellement disponible qu'en Scala et Java. Python et R ne sont actuellement pas pris en charge dans la version 1.6. Le support Python est prévu pour la version 2.0.

• Sécurité Du Type: L'API d'ensembles de données fournit la compilation sécurité temporelle qui n'était pas disponible sur les ordinateurs. Dans l'exemple ci-dessous, nous pouvons voir comment Dataset peut fonctionner sur des objets de domaine avec des fonctions de compilation lambda.

exemple:

case class Person(name : String , age : Int)
val personRDD = sc.makeRDD(Seq(Person("A",10),Person("B",20)))
val personDF = sqlContect.createDataframe(personRDD)
val ds:Dataset[Person] = personDF.as[Person]
ds.filter(p => p.age > 25)
ds.filter(p => p.salary > 25)
 // error : value salary is not a member of person
ds.rdd // returns RDD[Person]

• interopérable: les ensembles de données vous permettent de convertir facilement vos RDDs et Dataframes existants en ensembles de données sans code boilerplate.

ensembles de données limitation API:-

• nécessite un moulage par type à la chaîne: Interroger les données des ensembles de données nous oblige actuellement à spécifier les champs dans la classe comme une chaîne de caractères. Une fois que nous avons questionné les données, nous sommes forcés de lancer colonne au type de données requis. D'un autre côté, si nous utilisons le fonctionnement map sur les ensembles de données, il n'utilisera pas Catalyst optimizer.

exemple:

ds.select(col("name").as[String], $"age".as[Int]).collect()

aucun soutien pour Python et R: depuis la version 1.6, Les ensembles de données ne prennent en charge que Scala et Java. Le support Python sera introduit dans Spark 2.0.

L'API D'ensembles de données apporte plusieurs avantages par rapport à L'API RDD et Dataframe existante avec une meilleure sécurité de type et une programmation fonctionnelle.Avec le défi des exigences de moulage de type dans L'API, vous ne seriez toujours pas le type de sécurité requis et rendre votre code fragile.

tous (RDD, DataFrame et ensemble de données) dans une image

crédits d'image

RDD

RDD est une collection d'éléments tolérants aux défauts pouvant être exploités en parallèle.

DataFrame

DataFrame est un ensemble de données organisé en colonnes nommées. Il est conceptuellement équivalents à une table dans une base de données relationnelle ou de données cadre en R / Python, mais avec des optimisations plus riches sous le capot .

Dataset

Dataset est une collection distribuée de données. Dataset est une nouvelle interface ajoutée dans Spark 1.6 qui fournit les avantages des RDDs (forte Dactylographie, capacité d'utilisation puissantes fonctions lambda) avec le les avantages de la Spark SQL optimisé moteur d'exécution .

---

Note:

ensemble de données des lignes ( Dataset[Row] ) en Scala/Java se réfère souvent comme DataFrames .

Nice comparaison de tous avec un extrait de code

source

Q: Pouvez-vous convertir l'un à l'autre comme RDD en DataFrame ou vice-versa?

Oui, les deux sont possibles

1. RDD à DataFrame avec .toDF()

val rowsRdd: RDD[Row] = sc.parallelize(
  Seq(
    Row("first", 2.0, 7.0),
    Row("second", 3.5, 2.5),
    Row("third", 7.0, 5.9)
  )
)

val df = spark.createDataFrame(rowsRdd).toDF("id", "val1", "val2")

df.show()
+------+----+----+
|    id|val1|val2|
+------+----+----+
| first| 2.0| 7.0|
|second| 3.5| 2.5|
| third| 7.0| 5.9|
+------+----+----+

plus de façons: convertissez un objet RDD en Dataframe en étincelle

2. DataFrame / DataSet à RDD avec .rdd() méthode

val rowsRdd: RDD[Row] = df.rdd() // DataFrame to RDD

simplement RDD est un composant de base, mais DataFrame est une API introduite dans spark 1.30.

RDD

Collecte de données partitions, RDD . Ces RDD doit suivre peu de propriétés telles est:

• immuable,
• Tolérant Les Défauts,
• distribué,
• plus.

Ici RDD est soit structuré ou non structuré.

DataFrame

DataFrame est une API disponible en Scala, Java, Python et R. elle permet de traiter tout type de données structurées et semi-structurées. Pour définir DataFrame , une collection de données distribuées organisées en colonnes nommées appelées DataFrame . Vous pouvez facilement optimiser le RDDs dans le DataFrame . Vous pouvez traiter des données JSON, des données de parquet, des données HiveQL à la fois en en utilisant DataFrame .

val sampleRDD = sqlContext.jsonFile("hdfs://localhost:9000/jsondata.json")

val sample_DF = sampleRDD.toDF()

ici Sample_DF considérer comme DataFrame . sampleRDD est (données brutes) appelé RDD .

la plupart des réponses sont correctes je veux seulement ajouter un point ici

dans Spark 2.0, les deux API (DataFrame +DataSet) seront unifiées en une seule API.

"Unificateur DataFrame et l'ensemble de données: En Scala et Java, DataFrame et l'ensemble de données ont été unifiés, c'est à dire DataFrame est juste un alias de type pour l'ensemble de données de la Ligne. En Python et R, étant donné le manque de sécurité de type, DataFrame est l'interface de programmation principale."

ensembles de données sont similaires aux RDDs, cependant, au lieu d'utiliser la sérialisation Java ou Kryo ils utilisent un encodeur spécialisé pour sérialiser les objets pour le traitement ou la transmission sur le réseau.

Spark SQL prend en charge deux méthodes différentes pour convertir RDDs existants en ensembles de données. La première méthode utilise la réflexion pour inférer le schéma d'un RDD qui contient des types spécifiques d'objets. Cette approche basée sur la réflexion conduit à un code plus concis et fonctionne bien lorsque vous connaissez déjà le schema lors de la rédaction de votre application Spark.

la deuxième méthode pour créer des ensembles de données est par l'intermédiaire d'une interface programmatique qui vous permet de construire un schéma puis de l'appliquer à un RDD existant. Bien que cette méthode soit plus verbeuse, elle vous permet de construire des ensembles de données lorsque les colonnes et leurs types ne sont pas connus avant l'exécution.

ici, vous pouvez trouver la réponse de conversation RDD tof data frame

comment convertir rdd objet de dataframe spark

une base de données est équivalente à une table dans les RDBMS et peut également être manipulée de la même manière que les collections distribuées" natives " dans les RDDs. Contrairement aux RDDs, les Dataframes suivent le schéma et prennent en charge diverses opérations relationnelles qui conduisent à une exécution plus optimisée. Chaque objet DataFrame représente un plan logique mais en raison de leur nature "paresseuse" aucune exécution ne se produit jusqu'à ce que l'utilisateur appelle une "opération de sortie"spécifique.

une Dataframe est un RDD d'objets de rang, chacun représentant un enregistrement. Un Dataframe connaît également le schéma (c'est-à-dire les champs de données) de ses lignes. Tandis Que Dataframes ressemblant à des RDDs réguliers, en interne ils stockent les données de manière plus efficace, en profitant de leur schéma. En outre, ils fournissent de nouvelles opérations non disponibles sur RDDs, comme la possibilité d'exécuter des requêtes SQL. Les Dataframes peuvent être créées à partir de sources de données externes, à partir des résultats de requêtes, ou à partir de RDDs réguliers.

référence: Zaharia M., et al. Étincelle D'Apprentissage (O'Reilly, 2015)

Quelques idées à partir de l'utilisation de la perspective, CA vs DataFrame:

1. Rdd sont incroyables! comme ils nous donnent toute la flexibilité pour faire face à presque n'importe quel type de données non structurées, semi-structurées et structurées. Comme, souvent, les données ne sont pas prêtes à être insérées dans une base de données (même JSON), les RDDs peuvent être utilisés pour effectuer le prétraitement des données afin qu'elles puissent être insérées dans une base de données. Les RDDs sont une abstraction de données de base dans Spark.
2. pas tous les transformations possibles sur RDD sont possibles sur les DataFrames, par exemple soustract() est pour RDD vs sauf() est pour DataFrame.
3. étant donné que les DataFrames sont comme une table relationnelle, elles suivent des règles strictes lors de l'utilisation de transformations de théorie des ensembles/relationnelles, par exemple si vous vouliez unir deux dataframes, l'exigence est que les deux dfs aient le même nombre de colonnes et les types de colonnes associés. Les noms de colonne peuvent être différents. Ces règles ne s'appliquent pas aux RDDs. Voici un bon tutoriel expliquant ces faits.
4. il y a des gains de performance lorsque l'on utilise des images de données comme d'autres l'ont déjà expliqué en profondeur.
5. en utilisant des images de données, vous n'avez pas besoin de passer la fonction arbitraire comme vous le faites lors de la programmation avec RDDs.
6. vous avez besoin du SQLContext/HiveContext pour programmer des images de données comme elles se trouvent dans la zone SparkSQL de spark eco-system, mais pour RDD vous n'avez besoin que de SparkContext / JavaSparkContext qui se trouvent dans les bibliothèques Spark Core.
7. vous pouvez créer un df à partir d'un RDD si vous pouvez définir un schéma pour celui-ci.
8. vous pouvez également convertir un df en rdd et rdd en DF.

j'espère que cela aide!

vous pouvez utiliser les RDD avec structuré et non structuré où comme Dataframe / Dataset ne peut traiter des données structurées et Semi-structurées (il a le schéma approprié)

A DataFrame est un RDD qui possède un schéma. Vous pouvez penser à lui comme une table de base de données relationnelle, en ce que chaque colonne a un nom et un type connu. La puissance de DataFrames vient du fait que, lorsque vous créez une DataFrame à partir d'un ensemble structuré de données (Json, Parquet..), Spark est capable de déduire un schéma en faisant un passage sur l'ensemble (JSON, Parquet..) ensemble de données qui est en cours de chargement. Puis, en calculant le plan d'exécution, Spark, peut utilisez le schéma et faites de meilleures optimisations de calcul. Notez que DataFrame a été appelé SchemaRDD avant Spark v1.3.0