Je me demande simplement quelle est la différence entre un RDDet DataFrame (Spark 2.0.0 DataFrame est un simple alias de type pour Dataset[Row]) dans Apache Spark?

Pouvez-vous convertir l'un à l'autre?

A DataFrameest bien défini avec une recherche google pour "DataFrame definition":

Une trame de données est une table, ou une structure de type tableau bidimensionnel, dans laquelle chaque colonne contient des mesures sur une variable et chaque ligne contient un cas.

Ainsi, a DataFramepossède des métadonnées supplémentaires en raison de son format tabulaire, ce qui permet à Spark d'exécuter certaines optimisations sur la requête finalisée.

Un RDD, d'autre part, est simplement un R esilient D istributed D ataset qui est plus d'une boîte noire des données qui ne peuvent être optimisées que les opérations qui peuvent être effectuées contre, ne sont pas aussi limitées.

Cependant, vous pouvez passer d'un DataFrame à un RDDvia sa rddméthode, et vous pouvez passer d'un RDDà un DataFrame(si le RDD est dans un format tabulaire) via la toDFméthode

En général, il est recommandé d'utiliser un DataFramedans la mesure du possible en raison de l'optimisation des requêtes intégrée.

La première chose a DataFrameété développée à partir de SchemaRDD.

Oui .. la conversion entre Dataframeet RDDest absolument possible.

Voici quelques exemples d'extraits de code.

• df.rdd est RDD[Row]

Vous trouverez ci-dessous quelques options pour créer un cadre de données.

• 1) se yourrddOffrow.toDFconvertit en DataFrame.

• 2) Utilisation createDataFramedu contexte SQL

  val df = spark.createDataFrame(rddOfRow, schema)

où le schéma peut provenir de certaines des options ci-dessous, comme décrit par un joli message SO ..
De la classe de cas scala et de l'api de réflexion scala

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 Schema peut également être créé en utilisant StructTypeet StructField

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

En fait, il existe maintenant 3 API Apache Spark.

1. RDD API:

L' RDDAPI (Resilient Distributed Dataset) est présente dans Spark depuis la version 1.0.

L' RDDAPI fournit de nombreuses méthodes de transformation, telles que map(), filter() et reduce() pour effectuer des calculs sur les données. Chacune de ces méthodes aboutit à une nouvelle RDDreprésentation des données transformées. Cependant, ces méthodes ne font que définir les opérations à effectuer et les transformations ne sont pas effectuées tant qu'une méthode d'action n'est pas 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: filtrer par attribut avec RDD

rdd.filter(_.age > 21)

2. DataFrame API

Spark 1.3 a introduit une nouvelle DataFrameAPI dans le cadre de l'initiative Project Tungsten qui vise à améliorer les performances et l'évolutivité de Spark. L' DataFrameAPI introduit le concept d'un schéma pour décrire les données, permettant à Spark de gérer le schéma et de ne transmettre des données qu'entre nœuds, d'une manière beaucoup plus efficace que d'utiliser la sérialisation Java.

L' DataFrameAPI est radicalement différente de l' RDDAPI car il s'agit d'une API pour la construction d'un plan de requête relationnel que l'optimiseur Catalyst de Spark peut ensuite exécuter. L'API est naturelle pour les développeurs qui connaissent bien la création de plans de requête

Exemple de style SQL:

df.filter("age > 21");

Limitations: le code faisant référence aux attributs de données par leur nom, il n'est pas possible pour le compilateur de détecter des erreurs. Si les noms d'attributs sont incorrects, l'erreur n'est détectée qu'au moment de l'exécution, lorsque le plan de requête est créé.

Un autre inconvénient de l' DataFrameAPI est qu'elle est très centrée sur l'échelle et qu'elle prend en charge Java, mais la prise en charge est limitée.

Par exemple, lors de la création d'un à DataFramepartir d'un RDDobjet Java existant , l'optimiseur Catalyst de Spark ne peut pas déduire le schéma et suppose que tous les objets du DataFrame implémentent l' scala.Productinterface. Scala case classtravaille sur la boîte car ils implémentent cette interface.

3. Dataset API

L' DatasetAPI, publiée en tant qu'aperçu API dans Spark 1.6, vise à fournir le meilleur des deux mondes; le style de programmation orienté objet familier et la sécurité de type au moment de la compilation de l' RDDAPI, mais avec les avantages de performance de l'optimiseur de requêtes Catalyst. Les jeux de données utilisent également le même mécanisme de stockage hors segment efficace que l' DataFrameAPI.

En ce qui concerne la sérialisation des données, l' DatasetAPI a le concept d' encodeurs qui se traduisent entre les représentations JVM (objets) et le format binaire interne de Spark. Spark a des encodeurs intégrés qui sont très avancés en ce qu'ils génèrent du code octet pour interagir avec les données hors tas et fournir un accès à la demande aux attributs individuels sans avoir à désérialiser un objet entier. Spark ne fournit pas encore d'API pour implémenter des encodeurs personnalisés, mais cela est prévu pour une prochaine version.

De plus, l' DatasetAPI est conçue pour fonctionner aussi bien avec Java que Scala. Lorsque vous travaillez avec des objets Java, il est important qu'ils soient entièrement compatibles avec le bean.

Exemple de Datasetstyle SQL API:

dataset.filter(_.age < 21);

Les évaluations diff. entre DataFrame& DataSet:

Flux de niveau cataliste. . (Démystification de la présentation du DataFrame et du Dataset depuis Spark Summit)

Pour en savoir plus ... article databricks - Une histoire de trois API Apache Spark: RDD vs DataFrames et Datasets

Apache Spark propose trois types d'API

1. RDD
2. Trame de données
3. Base de données

Voici la comparaison des API entre RDD, Dataframe et Dataset.

RDD

L'abstraction principale fournie par Spark est un ensemble de données réparties résilient (RDD), qui est une collection d'éléments partitionnés sur les nœuds du cluster qui peuvent être exploités en parallèle.

Caractéristiques RDD: -

• Collection distribuée:
  RDD utilise les opérations MapReduce qui sont largement adoptées 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 parallèles, 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: RDD composé d'une collection d'enregistrements qui sont partitionnés. Une partition est une unité de base du parallélisme dans un RDD, et chaque partition est une division logique des données qui est immuable et créée par le biais de certaines transformations sur les partitions existantes. L'immutabilité aide à assurer la cohérence des calculs.

• Tolérant aux pannes: dans le 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 une réplication de données sur plusieurs nœuds. Cette caractéristique est le plus grand avantage du RDD car il enregistre beaucoup d'efforts dans la gestion et la réplication des données et permet ainsi des calculs plus rapides.

• Évaluations paresseuses: toutes les transformations dans Spark sont paresseuses, en ce sens qu'elles ne calculent pas immédiatement leurs résultats. Au lieu de cela, ils se souviennent simplement des transformations appliquées à un ensemble de données de base. Les transformations ne sont calculées que lorsqu'une action nécessite qu'un résultat soit renvoyé au programme pilote.

• Transformations fonctionnelles: les RDD 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 du pilote après avoir exécuté un calcul sur l'ensemble de données.

• Formats de traitement des 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: -

• Aucun moteur d'optimisation intégré: lorsqu'ils travaillent avec des données structurées, les RDD ne peuvent pas tirer parti des optimiseurs avancés de Spark, y compris l'optimiseur de catalyseur et le moteur d'exécution Tungsten. Les développeurs doivent optimiser chaque RDD en fonction de ses attributs.

• Gestion des données structurées: contrairement au Dataframe et aux ensembles de données, les RDD n'infèrent pas le schéma des données ingérées et nécessitent que l'utilisateur le spécifie.

Cadres de données

Spark a introduit les Dataframes dans la version Spark 1.3. La trame de données surmonte les principaux défis rencontrés par les RDD.

Un DataFrame est une collection distribuée de données organisée en colonnes nommées. Il est conceptuellement équivalent à une table dans une base de données relationnelle ou un Dataframe R / Python. Parallèlement à Dataframe, Spark a également introduit l'optimiseur de catalyseur, qui exploite des fonctionnalités de programmation avancées pour créer un optimiseur de requête extensible.

Caractéristiques de la trame de données: -

• Collection distribuée d'objets de ligne: un DataFrame est une collection distribuée de données organisée en colonnes nommées. Il est conceptuellement équivalent à une table dans une base de données relationnelle, mais avec des optimisations plus riches sous le capot.

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

• Optimisation à l'aide de l'optimiseur de catalyseur: il alimente à la fois les requêtes SQL et l'API DataFrame. La trame de données utilise un cadre de transformation d'arbre de catalyseur 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é Hive: à l' aide de Spark SQL, vous pouvez exécuter des requêtes Hive non modifiées sur vos entrepôts Hive existants. Il réutilise le frontend Hive et MetaStore et vous offre une compatibilité totale avec les données, requêtes et UDF Hive existants.

• Tungsten: Tungsten fournit un backend d'exécution physique qui gère explicitement la mémoire et génère dynamiquement des bytecodes pour l'évaluation des expressions.

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

Limitations de la trame de données: -

• Sécurité de type à la compilation: Comme indiqué, l'API Dataframe ne prend pas en charge la sécurité à la compilation, ce qui vous empêche de manipuler des données lorsque la structure n'est pas connue. L'exemple suivant fonctionne pendant la compilation. Cependant, vous obtiendrez une exception Runtime lors de l'exécution de ce code.

Exemple:

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

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

• Impossible d'opérer sur un objet de domaine (objet de domaine perdu): une fois que vous avez transformé un objet de domaine en trame de données, vous ne pouvez pas le régénérer à partir de celui-ci. Dans l'exemple suivant, une fois que nous aurons créé personDF à partir de personRDD, nous ne récupérerons pas le RDD d'origine 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 = sqlContext.createDataframe(personRDD)
personDF.rdd // returns RDD[Row] , does not returns RDD[Person]

API de jeux de données

L'API Dataset est une extension de DataFrames qui fournit une interface de programmation orientée objet sécurisée. Il s'agit d'une collection d'objets fortement typés et immuables qui sont mappés à un schéma relationnel.

Au cœur du Dataset, l'API est un nouveau concept appelé encodeur, 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 Tarksten de Spark, permettant des opérations sur les données sérialisées et une meilleure utilisation de la mémoire. Spark 1.6 prend en charge 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 les Java Beans.

Caractéristiques de l'ensemble de données: -

• Fournit le meilleur du RDD et du Dataframe: RDD (programmation fonctionnelle, type sécurisé), DataFrame (modèle relationnel, optimisation de requête, exécution de tungstène, tri et mélange)

• Encodeurs: avec l'utilisation des encodeurs, il est facile de convertir n'importe quel objet JVM en un 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 Datasets n'est actuellement disponible qu'en Scala et Java. Python et R ne sont actuellement pas pris en charge dans la version 1.6. La prise en charge de Python est prévue pour la version 2.0.

• Sécurité de type: l' API Datasets offre une sécurité de compilation qui n'était pas disponible dans Dataframes. Dans l'exemple ci-dessous, nous pouvons voir comment l'ensemble de données 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 = sqlContext.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 RDD et cadres de données existants en ensembles de données sans code standard.

Limitation de l'API de jeux de données: -

• Requiert un transtypage de type en chaîne: pour interroger les données à partir d'ensembles de données, nous devons actuellement spécifier les champs de la classe sous forme de chaîne. Une fois que nous avons interrogé les données, nous sommes obligés de transtyper la colonne dans le type de données requis. D'un autre côté, si nous utilisons l'opération de carte sur les ensembles de données, il n'utilisera pas l'optimiseur Catalyst.

Exemple:

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

Pas de prise en charge de Python et R: depuis la version 1.6, les jeux de données ne prennent en charge que Scala et Java. La prise en charge de Python sera introduite dans Spark 2.0.

L'API Datasets 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 transtypage de type dans l'API, vous ne seriez toujours pas la sécurité de type requise et rendrait votre code fragile.

Tous (RDD, DataFrame et DataSet) en une seule image.

crédits d'image

RDD

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

DataFrame

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

Dataset

Datasetest une collection distribuée de données. Dataset est une nouvelle interface ajoutée dans Spark 1.6 qui offre les avantages des RDD (typage fort, capacité à utiliser de puissantes fonctions lambda) avec les avantages du moteur d'exécution optimisé de Spark SQL .

---

Remarque:

Le jeu de données de lignes ( Dataset[Row]) dans Scala / Java fera souvent référence à DataFrames .

Nice comparison of all of them with a code snippet.

la source

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

Oui, les deux sont possibles

1. RDDà DataFrameavec.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|
+------+----+----+

plusieurs façons: convertir un objet RDD en Dataframe dans Spark

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

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

Parce qu'il DataFrameest faiblement typé et que les développeurs ne bénéficient pas des avantages du système de saisie. Par exemple, disons que vous voulez lire quelque chose à partir de SQL et exécuter une agrégation dessus:

val people = sqlContext.read.parquet("...")
val department = sqlContext.read.parquet("...")

people.filter("age > 30")
  .join(department, people("deptId") === department("id"))
  .groupBy(department("name"), "gender")
  .agg(avg(people("salary")), max(people("age")))

Lorsque vous dites people("deptId")que vous ne récupérez pas un Intou un Long, vous récupérez un Columnobjet sur lequel vous devez opérer. Dans les langues avec des systèmes de type riches tels que Scala, vous finissez par perdre toute la sécurité de type qui augmente le nombre d'erreurs d'exécution pour les choses qui pourraient être découvertes au moment de la compilation.

Au contraire, DataSet[T]est tapé. quand tu fais:

val people: People = val people = sqlContext.read.parquet("...").as[People]

En fait, vous récupérez un Peopleobjet, où se deptIdtrouve un type intégral réel et non un type de colonne, tirant ainsi parti du système de type.

À partir de Spark 2.0, les API DataFrame et DataSet seront unifiées, où DataFramesera un alias de type pour DataSet[Row].

Il RDDs'agit simplement du composant principal, mais il DataFrames'agit d'une API introduite dans l'étincelle 1.30.

RDD

Collection de partitions de données appelée RDD. Ceux-ci RDDdoivent suivre quelques propriétés telles que:

• Immuable,
• Tolérance de panne,
• Distribué,
• Plus.

Ici, RDDc'est structuré ou non structuré.

Trame de données

DataFrameest 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 RDDsdans le DataFrame. Vous pouvez traiter les données JSON, les données parquet, les données HiveQL à la fois à l'aide de DataFrame.

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

val sample_DF = sampleRDD.toDF()

Ici Sample_DF considère comme DataFrame. sampleRDDest (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 ensemble en une seule API.

"Unification de DataFrame et Dataset: Dans Scala et Java, DataFrame et Dataset ont été unifiés, c'est-à-dire que DataFrame n'est qu'un alias de type pour Dataset of Row. En Python et R, étant donné le manque de sécurité de type, DataFrame est la principale interface de programmation."

Les jeux de données sont similaires aux RDD, 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 des RDD existants en ensembles de données. La première méthode utilise la réflexion pour déduire 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 schéma lors de l'écriture de votre application Spark.

La deuxième méthode de création de jeux de données consiste à utiliser une interface de programmation qui vous permet de construire un schéma, puis de l'appliquer à un RDD existant. Bien que cette méthode soit plus détaillée, 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 RDD tof réponse de conversation de trame de données

Comment convertir un objet RDD en un cadre de données dans Spark

Un DataFrame est équivalent à une table dans un SGBDR et peut également être manipulé de manière similaire aux collections distribuées "natives" dans des RDD. Contrairement aux RDD, les Dataframes assurent le suivi du 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.

Quelques informations du point de vue de l'utilisation, RDD vs DataFrame:

1. Les RDD sont incroyables! car ils nous donnent toute la flexibilité pour traiter presque n'importe quel type de données; données non structurées, semi structurées et structurées. Comme, souvent, les données ne sont pas prêtes à être intégrées dans un DataFrame (même JSON), les RDD peuvent être utilisés pour effectuer un prétraitement sur les données afin qu'elles puissent tenir dans une trame de données. Les RDD sont l'abstraction des données de base dans Spark.
2. Toutes les transformations possibles sur RDD ne sont pas possibles sur DataFrames, par exemple, soustraire () est pour RDD vs sauf que () est pour DataFrame.
3. Étant donné que les DataFrames sont comme une table relationnelle, ils suivent des règles strictes lors de l'utilisation de transformations de théorie des ensembles / relations, par exemple, si vous souhaitez unir deux cadres de données, l'exigence est que les deux dfs aient le même nombre de colonnes et les types de données de colonne associés. Les noms de colonne peuvent être différents. Ces règles ne s'appliquent pas aux RDD. Voici un bon tutoriel expliquant ces faits.
4. Il y a des gains de performances lors de l'utilisation de DataFrames comme d'autres l'ont déjà expliqué en détail.
5. En utilisant DataFrames, vous n'avez pas besoin de passer la fonction arbitraire comme vous le faites lors de la programmation avec des RDD.
6. Vous avez besoin du SQLContext / HiveContext pour programmer les trames de données car elles se trouvent dans la zone SparkSQL de l'écosystème spark, 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 ça aide!

Un Dataframe est un RDD d'objets Row, chacun représentant un enregistrement. Un Dataframe connaît également le schéma (c'est-à-dire les champs de données) de ses lignes. Alors que les cadres de données ressemblent à des RDD normaux, en interne, ils stockent les données de manière plus efficace, en tirant parti de leur schéma. En outre, ils fournissent de nouvelles opérations non disponibles sur les RDD, telles que la possibilité d'exécuter des requêtes SQL. Les cadres de données peuvent être créés à partir de sources de données externes, à partir des résultats de requêtes ou à partir de RDD standard.

Référence: Zaharia M., et al. Learning Spark (O'Reilly, 2015)

Spark RDD (resilient distributed dataset) :

RDD est l'API d'abstraction des données de base et est disponible depuis la toute première version de Spark (Spark 1.0). Il s'agit d'une API de niveau inférieur pour manipuler la collecte distribuée de données. Les API RDD présentent certaines méthodes extrêmement utiles qui peuvent être utilisées pour obtenir un contrôle très strict sur la structure de données physiques sous-jacente. Il s'agit d'une collection immuable (en lecture seule) de données partitionnées réparties sur différentes machines. RDD permet le calcul en mémoire sur de grands clusters pour accélérer le traitement des mégadonnées d'une manière tolérante aux pannes. Pour activer la tolérance aux pannes, RDD utilise DAG (Directed Acyclic Graph) qui consiste en un ensemble de sommets et d'arêtes. Les sommets et les arêtes dans DAG représentent respectivement le RDD et l'opération à appliquer sur ce RDD. Les transformations définies sur RDD sont paresseuses et ne s'exécutent que lorsqu'une action est appelée

Spark DataFrame :

Spark 1.3 a introduit deux nouvelles API d'abstraction de données - DataFrame et DataSet. Les API DataFrame organisent les données dans des colonnes nommées comme une table dans la base de données relationnelle. Il permet aux programmeurs de définir un schéma sur une collection distribuée de données. Chaque ligne d'un DataFrame est de type objet. Comme une table SQL, chaque colonne doit avoir le même nombre de lignes dans un DataFrame. En bref, DataFrame est un plan évalué paresseusement qui spécifie les opérations à effectuer sur la collecte distribuée des données. DataFrame est également une collection immuable.

Spark DataSet :

En tant qu'extension des API DataFrame, Spark 1.3 a également introduit des API DataSet qui fournissent une interface de programmation strictement typée et orientée objet dans Spark. Il s'agit d'une collection immuable et sécurisée de données distribuées. Comme DataFrame, les API DataSet utilisent également le moteur Catalyst pour permettre l'optimisation de l'exécution. DataSet est une extension des API DataFrame.

Other Differences -

Un DataFrame est un RDD qui a un schéma. Vous pouvez la considérer comme une table de base de données relationnelle, dans la mesure où chaque colonne a un nom et un type connu. La puissance des DataFrames vient du fait que, lorsque vous créez un DataFrame à partir d'un ensemble de données structuré (Json, Parquet ..), Spark est capable d'inférer un schéma en effectuant une passe sur l'ensemble (Json, Parquet ..) ensemble de données qui est en cours de chargement. Ensuite, lors du calcul du plan d'exécution, Spark peut utiliser le schéma et effectuer des optimisations de calcul nettement meilleures. Notez que DataFrame était appelé SchemaRDD avant Spark v1.3.0

Apache Spark - RDD, DataFrame et DataSet

Spark RDD -

Un RDD signifie Resilient Distributed Datasets. Il s'agit d'une collection d'enregistrements de partitions en lecture seule. RDD est la structure de données fondamentale de Spark. Il permet à un programmeur d'effectuer des calculs en mémoire sur de grands clusters d'une manière tolérante aux pannes. Accélérez ainsi la tâche.

Spark Dataframe -

Contrairement à un RDD, les données sont organisées en colonnes nommées. Par exemple une table dans une base de données relationnelle. Il s'agit d'une collection de données distribuée immuable. DataFrame dans Spark permet aux développeurs d'imposer une structure à une collection distribuée de données, permettant une abstraction de niveau supérieur.

Ensemble de données Spark -

Les jeux de données dans Apache Spark sont une extension de l'API DataFrame qui fournit une interface de programmation orientée objet et sécurisée. L'ensemble de données tire parti de l'optimiseur Catalyst de Spark en exposant des expressions et des champs de données à un planificateur de requêtes.

Vous pouvez utiliser des RDD avec des structures et des structures non structurées alors que le Dataframe / Dataset ne peut traiter que les données structurées et semi-structurées (il a un schéma approprié)

Toutes les bonnes réponses et l'utilisation de chaque API ont un compromis. L'ensemble de données est conçu pour être une super API pour résoudre beaucoup de problèmes, mais souvent, RDD fonctionne toujours mieux si vous comprenez vos données et si l'algorithme de traitement est optimisé pour faire beaucoup de choses en un seul passage vers de grandes données, alors RDD semble la meilleure option.

L'agrégation utilisant l'API d'ensemble de données consomme toujours de la mémoire et s'améliorera avec le temps.