Mi sto solo chiedendo quale sia la differenza tra an RDDe DataFrame (Spark 2.0.0 DataFrame è un semplice alias di tipo per Dataset[Row]) in Apache Spark?

Puoi convertirlo l'uno nell'altro?

A DataFrameè definito bene con una ricerca su Google per "Definizione DataFrame":

Un frame di dati è una tabella, o struttura bidimensionale simile ad una matrice, in cui ogni colonna contiene misurazioni su una variabile e ogni riga contiene un caso.

Pertanto, a DataFrameha metadati aggiuntivi grazie al suo formato tabulare, che consente a Spark di eseguire determinate ottimizzazioni sulla query finalizzata.

Una RDD, d'altra parte, è solo un R esilient D istributed D ataset che è più di un blackbox di dati che non possono essere ottimizzate le operazioni che possono essere eseguite contro di essa, non sono così limitate.

Tuttavia, puoi passare da un DataFrame a un RDDtramite il suo rddmetodo e puoi passare da un RDDa un DataFrame(se RDD è in un formato tabulare) tramite il toDFmetodo

In generale si consiglia di utilizzare un DataFramedove possibile a causa dell'ottimizzazione delle query integrata.

La prima cosa è DataFramestata evoluta da SchemaRDD.

Sì .. la conversione tra Dataframeed RDDè assolutamente possibile.

Di seguito sono riportati alcuni frammenti di codice di esempio.

• df.rdd è RDD[Row]

Di seguito sono riportate alcune opzioni per creare un frame di dati.

• 1) yourrddOffrow.toDFconverte in DataFrame.

• 2) Utilizzo createDataFramedel contesto sql

  val df = spark.createDataFrame(rddOfRow, schema)

dove lo schema può provenire da alcune delle opzioni seguenti, come descritto da un bel post SO ..
Dalla scala case class e scala reflection api

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

O usando Encoders

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

come descritto da Schema può anche essere creato usando StructTypee StructField

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

In effetti ci sono ora 3 API Apache Spark ..

1. RDD API:

L' RDDAPI (Resilient Distributed Dataset) è in Spark dalla versione 1.0.

L' RDDAPI offre molti metodi di trasformazione, come map(), filter() e reduce() per eseguire calcoli sui dati. Ognuno di questi metodi si traduce in un nuovo che RDDrappresenta i dati trasformati. Tuttavia, questi metodi stanno solo definendo le operazioni da eseguire e le trasformazioni non vengono eseguite fino a quando non viene chiamato un metodo di azione. Esempi di metodi di azione sono collect() e saveAsObjectFile().

Esempio RDD:

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

Esempio: filtro per attributo con RDD

rdd.filter(_.age > 21)

2. DataFrame API

Spark 1.3 ha introdotto una nuova DataFrameAPI come parte dell'iniziativa Project Tungsten che mira a migliorare le prestazioni e la scalabilità di Spark. L' DataFrameAPI introduce il concetto di uno schema per descrivere i dati, consentendo a Spark di gestire lo schema e passare solo i dati tra i nodi, in un modo molto più efficiente rispetto all'uso della serializzazione Java.

L' DataFrameAPI è radicalmente diversa RDDdall'API perché è un'API per la creazione di un piano di query relazionale che l'ottimizzatore Catalyst di Spark può quindi eseguire. L'API è naturale per gli sviluppatori che hanno familiarità con la creazione di piani di query

Esempio di stile SQL:

df.filter("age > 21");

Limitazioni: poiché il codice fa riferimento agli attributi dei dati per nome, non è possibile che il compilatore rilevi errori. Se i nomi degli attributi non sono corretti, l'errore verrà rilevato solo in fase di esecuzione, quando viene creato il piano di query.

Un altro aspetto negativo DataFramedell'API è che è molto scalare-centrico e mentre supporta Java, il supporto è limitato.

Ad esempio, quando si crea un oggetto Java DataFrameesistente da uno RDD, l'ottimizzatore Catalyst di Spark non può inferire lo schema e presuppone che qualsiasi oggetto nel DataFrame implementi l' scala.Productinterfaccia. Scala case classrisolve il problema perché implementano questa interfaccia.

3. Dataset API

L' DatasetAPI, rilasciata come anteprima API in Spark 1.6, mira a fornire il meglio di entrambi i mondi; il familiare stile di programmazione orientato agli oggetti e la sicurezza del tipo in fase di compilazione RDDdell'API ma con i vantaggi in termini di prestazioni di Query Optimizer di Catalyst. I set di dati utilizzano anche lo stesso meccanismo di archiviazione off-heap efficiente DataFramedell'API.

Quando si tratta di serializzare i dati, l' DatasetAPI ha il concetto di encoder che traducono tra rappresentazioni (oggetti) JVM e il formato binario interno di Spark. Spark ha encoder integrati che sono molto avanzati in quanto generano un codice byte per interagire con i dati off-heap e forniscono accesso su richiesta a singoli attributi senza dover serializzare un intero oggetto. Spark non fornisce ancora un'API per l'implementazione di codificatori personalizzati, ma è prevista per una versione futura.

Inoltre, l' DatasetAPI è progettata per funzionare altrettanto bene sia con Java che con Scala. Quando si lavora con oggetti Java, è importante che siano completamente conformi ai bean.

Esempio di Datasetstile SQL API:

dataset.filter(_.age < 21);

Valutazioni diff. tra DataFrame& DataSet:

Flusso di livello catalista. (Demistificazione della presentazione di DataFrame e Dataset dal summit spark)

Ulteriori letture ... articolo di databricks - A Tale of Three Apache Spark API: RDDs vs DataFrames e Dataset

Apache Spark fornisce tre tipi di API

1. RDD
2. dataframe
3. dataset

Ecco il confronto delle API tra RDD, Dataframe e Dataset.

RDD

L'astrazione principale fornita da Spark è un set di dati distribuito resiliente (RDD), che è una raccolta di elementi partizionati attraverso i nodi del cluster su cui è possibile operare in parallelo.

Caratteristiche RDD: -

• Raccolta distribuita:
  RDD utilizza operazioni MapReduce ampiamente utilizzate per l'elaborazione e la generazione di set di dati di grandi dimensioni con un algoritmo distribuito parallelo su un cluster. Consente agli utenti di scrivere calcoli paralleli, utilizzando una serie di operatori di alto livello, senza doversi preoccupare della distribuzione del lavoro e della tolleranza agli errori.

• Immutabile: RDD composti da una raccolta di record che sono partizionati. Una partizione è un'unità di base del parallelismo in un RDD e ogni partizione è una divisione logica di dati che è immutabile e creata attraverso alcune trasformazioni su partizioni esistenti. L'immutabilità aiuta a ottenere coerenza nei calcoli.

• Tollerante ai guasti: in caso di perdita di una partizione di RDD, è possibile riprodurre la trasformazione su quella partizione in derivazione per ottenere lo stesso calcolo, anziché eseguire la replica dei dati su più nodi. Questa caratteristica è il principale vantaggio di RDD perché consente di risparmiare molti sforzi nella gestione e nella replica dei dati, ottenendo così calcoli più rapidi.

• Valutazioni pigre: tutte le trasformazioni in Spark sono pigre, in quanto non calcolano immediatamente i loro risultati. Invece, ricordano solo le trasformazioni applicate ad alcuni set di dati di base. Le trasformazioni vengono calcolate solo quando un'azione richiede che un risultato sia restituito al programma del driver.

• Trasformazioni funzionali: i RDD supportano due tipi di operazioni: trasformazioni, che creano un nuovo set di dati da uno esistente, e azioni, che restituiscono un valore al programma del driver dopo aver eseguito un calcolo sul set di dati.

• Formati di elaborazione dei dati: è in
  grado di elaborare in modo semplice ed efficiente dati strutturati e non strutturati.

• Linguaggi di programmazione supportati:
  API RDD è disponibile in Java, Scala, Python e R.

Limitazioni RDD: -

• Nessun motore di ottimizzazione integrato: quando si lavora con dati strutturati, gli RDD non possono trarre vantaggio dagli ottimizzatori avanzati di Spark, inclusi l'ottimizzatore del catalizzatore e il motore di esecuzione del tungsteno. Gli sviluppatori devono ottimizzare ciascun RDD in base ai suoi attributi.

• Gestione dei dati strutturati: a differenza di Dataframe e set di dati, i RDD non inferiscono lo schema dei dati ingeriti e richiedono all'utente di specificarli.

Dataframes

Spark ha introdotto Dataframes nella versione Spark 1.3. Il Dataframe supera le principali sfide che i RDD hanno dovuto affrontare.

Un DataFrame è una raccolta distribuita di dati organizzata in colonne denominate. È concettualmente equivalente a una tabella in un database relazionale o un R / Python Dataframe. Insieme a Dataframe, Spark ha anche introdotto l'ottimizzatore del catalizzatore, che sfrutta funzionalità di programmazione avanzate per creare un ottimizzatore di query estensibile.

Caratteristiche del Dataframe: -

• Raccolta distribuita di oggetti riga: un DataFrame è una raccolta distribuita di dati organizzata in colonne denominate. È concettualmente equivalente a una tabella in un database relazionale, ma con ottimizzazioni più complete.

• Elaborazione dei dati: elaborazione di formati di dati strutturati e non strutturati (Avro, CSV, ricerca elastica e Cassandra) e sistemi di archiviazione (HDFS, tabelle HIVE, MySQL, ecc.). Può leggere e scrivere da tutte queste varie origini dati.

• Ottimizzazione tramite l'ottimizzatore catalizzatore: alimenta sia le query SQL che l'API DataFrame. Il frame di dati utilizza il framework di trasformazione dell'albero del catalizzatore in quattro fasi,

   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: utilizzando Spark SQL, è possibile eseguire query Hive non modificate sui magazzini Hive esistenti. Riutilizza frontend Hive e MetaStore e ti offre piena compatibilità con i dati Hive, le query e gli UDF esistenti.

• Tungsteno: il tungsteno fornisce un backend di esecuzione fisica che gestisce in modo esplicito la memoria e genera dinamicamente un bytecode per la valutazione delle espressioni.

• Linguaggi di programmazione supportati:
  l'API Dataframe è disponibile in Java, Scala, Python e R.

Limitazioni del frame di dati: -

• Sicurezza dei tipi in fase di compilazione: come discusso, l'API Dataframe non supporta la sicurezza in fase di compilazione che ti impedisce di manipolare i dati quando la struttura non è nota. L'esempio seguente funziona durante il tempo di compilazione. Tuttavia, si otterrà un'eccezione di runtime durante l'esecuzione di questo codice.

Esempio:

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

Ciò è particolarmente impegnativo quando si lavora con diverse fasi di trasformazione e aggregazione.

• Impossibile operare sull'oggetto dominio (oggetto dominio perduto): una volta trasformato un oggetto dominio in frame di dati, non è possibile rigenerarlo da esso. Nel seguente esempio, una volta creato personDF da personRDD, non recupereremo la classe RDD originale della persona (RDD [Person]).

Esempio:

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 set di dati

L'API Dataset è un'estensione di DataFrames che fornisce un'interfaccia di programmazione orientata al tipo e orientata agli oggetti. È una raccolta di oggetti immutabile e fortemente tipizzata mappata su uno schema relazionale.

Al centro del set di dati, API è un nuovo concetto chiamato encoder, che è responsabile della conversione tra oggetti JVM e rappresentazione tabulare. La rappresentazione tabulare viene archiviata utilizzando il formato binario Spark interno in tungsteno, consentendo operazioni su dati serializzati e un migliore utilizzo della memoria. Spark 1.6 viene fornito con il supporto per la generazione automatica di codificatori per un'ampia varietà di tipi, inclusi i tipi primitivi (ad esempio String, Integer, Long), Classi Scala e Java Beans.

Caratteristiche del set di dati: -

• Fornisce il meglio sia di RDD che di Dataframe: RDD (programmazione funzionale, sicurezza dei tipi), DataFrame (modello relazionale, ottimizzazione delle query, esecuzione di tungsteno, ordinamento e shuffling)

• Encoder: con l'uso di Encoder, è facile convertire qualsiasi oggetto JVM in un set di dati, consentendo agli utenti di lavorare con dati strutturati e non strutturati a differenza di Dataframe.

• Linguaggi di programmazione supportati: l' API dei set di dati è attualmente disponibile solo in Scala e Java. Python e R non sono attualmente supportati nella versione 1.6. Il supporto di Python è previsto per la versione 2.0.

• Tipo di sicurezza: l' API dei set di dati offre una sicurezza in fase di compilazione che non era disponibile in Dataframes. Nell'esempio seguente, possiamo vedere come Dataset può operare su oggetti di dominio con funzioni lambda di compilazione.

Esempio:

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]

• Interoperabile: i set di dati consentono di convertire facilmente i RDD e i frame di dati esistenti in set di dati senza codice della caldaia.

Limitazione API set di dati: -

• Richiede il cast del tipo su String: la query dei dati dai set di dati richiede attualmente di specificare i campi della classe come stringa. Dopo aver interrogato i dati, siamo costretti a trasmettere la colonna al tipo di dati richiesto. D'altra parte, se utilizziamo l'operazione di mappatura su set di dati, non utilizzerà l'ottimizzatore Catalyst.

Esempio:

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

Nessun supporto per Python e R: dalla versione 1.6, i set di dati supportano solo Scala e Java. Il supporto per Python sarà introdotto in Spark 2.0.

L'API Dataset offre numerosi vantaggi rispetto all'API RDD e Dataframe esistenti con una migliore sicurezza del tipo e una programmazione funzionale. Con la sfida dei requisiti di cast di tipo nell'API, non avresti ancora la sicurezza del tipo richiesta e renderai il tuo codice fragile.

Tutto (RDD, DataFrame e DataSet) in un'unica immagine.

crediti di immagine

RDD

RDD è una raccolta di elementi tolleranti ai guasti che può essere utilizzata in parallelo.

DataFrame

DataFrameè un set di dati organizzato in colonne denominate. È concettualmente equivalente a una tabella in un database relazionale o a un frame di dati in R / Python, ma con ottimizzazioni più ricche sotto il cofano .

Dataset

Datasetè una raccolta distribuita di dati. Il set di dati è una nuova interfaccia aggiunta in Spark 1.6 che offre i vantaggi degli RDD (digitazione avanzata , capacità di utilizzare potenti funzioni lambda) con i vantaggi del motore di esecuzione ottimizzata di Spark SQL .

---

Nota:

Il set di dati di righe ( Dataset[Row]) in Scala / Java si riferirà spesso a DataFrames .

Nice comparison of all of them with a code snippet.

fonte

D: Riesci a convertire l'uno nell'altro come RDD in DataFrame o viceversa?

Sì, entrambi sono possibili

1. RDDa DataFramecon.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|
+------+----+----+

altri modi: convertire un oggetto RDD in Dataframe in Spark

2. DataFrame/ DataSeta RDDcon il .rdd()metodo

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

Perché DataFrameè tipizzato debolmente e gli sviluppatori non ottengono i vantaggi del sistema di tipi. Ad esempio, supponiamo che tu voglia leggere qualcosa da SQL ed eseguire un po 'di aggregazione su di esso:

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")))

Quando dici people("deptId"), non stai tornando indietro a Int, o a Long, stai recuperando un Columnoggetto su cui devi operare. In linguaggi con sistemi di tipo ricco come Scala, si finisce per perdere tutta la sicurezza del tipo che aumenta il numero di errori di runtime per cose che potrebbero essere scoperte in fase di compilazione.

Al contrario, DataSet[T]viene digitato. quando lo fai:

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

Stai effettivamente recuperando un Peopleoggetto, dove si deptIdtrova un tipo integrale effettivo e non un tipo di colonna, sfruttando così il sistema di tipi.

A partire da Spark 2.0, le API DataFrame e DataSet saranno unificate, dove DataFramesarà un alias di tipo per DataSet[Row].

Semplicemente RDDè il componente principale, ma DataFrameè un'API introdotta in spark 1.30.

RDD

Raccolta di partizioni di dati chiamata RDD. Questi RDDdevono seguire alcune proprietà come:

• Immutabile,
• Tollerante agli errori,
• distribuito,
• Di Più.

Qui RDDè strutturato o non strutturato.

dataframe

DataFrameè un'API disponibile in Scala, Java, Python e R. Permette di elaborare qualsiasi tipo di dato strutturato e semi strutturato. Per definire DataFrame, viene chiamata una raccolta di dati distribuiti organizzata in colonne denominate DataFrame. Puoi facilmente ottimizzare l ' RDDsin DataFrame. È possibile elaborare contemporaneamente dati JSON, dati di parquet, dati HiveQL DataFrame.

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

val sample_DF = sampleRDD.toDF()

Qui Sample_DF considera come DataFrame. sampleRDDviene chiamato (dati non elaborati) RDD.

La maggior parte delle risposte sono corrette solo per aggiungere un punto qui

In Spark 2.0 le due API (DataFrame + DataSet) verranno unificate insieme in un'unica API.

"Unificazione di DataFrame e Dataset: In Scala e Java, DataFrame e Dataset sono stati unificati, ovvero DataFrame è solo un alias di tipo per Dataset of Row. In Python e R, data la mancanza di sicurezza del tipo, DataFrame è l'interfaccia di programmazione principale."

I set di dati sono simili ai RDD, tuttavia, invece di utilizzare la serializzazione Java o Kryo, utilizzano un codificatore specializzato per serializzare gli oggetti per l'elaborazione o la trasmissione in rete.

Spark SQL supporta due diversi metodi per convertire i RDD esistenti in set di dati. Il primo metodo utilizza la riflessione per inferire lo schema di un RDD che contiene tipi specifici di oggetti. Questo approccio basato sulla riflessione porta a un codice più conciso e funziona bene quando si conosce già lo schema durante la scrittura dell'applicazione Spark.

Il secondo metodo per la creazione di set di dati è tramite un'interfaccia programmatica che consente di costruire uno schema e quindi applicarlo a un RDD esistente. Sebbene questo metodo sia più dettagliato, consente di costruire set di dati quando le colonne e i loro tipi non sono noti fino al runtime.

Qui puoi trovare la risposta alla conversazione di frame di dati RDD tof

Come convertire l'oggetto RDD in frame di dati in Spark

Un DataFrame equivale a una tabella in RDBMS e può anche essere manipolato in modo simile alle raccolte distribuite "native" nei RDD. A differenza dei RDD, i Dataframe tengono traccia dello schema e supportano varie operazioni relazionali che portano a un'esecuzione più ottimizzata. Ogni oggetto DataFrame rappresenta un piano logico ma a causa della loro natura "pigra" non viene eseguita alcuna esecuzione fino a quando l'utente chiama una specifica "operazione di output".

Pochi approfondimenti dal punto di vista dell'utilizzo, RDD vs DataFrame:

1. Gli RDD sono fantastici! poiché ci offrono tutta la flessibilità necessaria per gestire quasi ogni tipo di dati; dati non strutturati, semi strutturati e strutturati. Poiché molte volte i dati non sono pronti per essere inseriti in un DataFrame, (anche JSON), gli RDD possono essere utilizzati per eseguire la preelaborazione dei dati in modo che possano adattarsi a un frame di dati. Gli RDD sono l'astrazione dei dati core in Spark.
2. Non tutte le trasformazioni possibili su RDD sono possibili su DataFrames, ad esempio subtract () è per RDD vs tranne () è per DataFrame.
3. Poiché i DataFrame sono come una tabella relazionale, seguono regole rigorose quando si usano trasformazioni di set / teoria relazionale, ad esempio se si desidera unire due frame di dati il ​​requisito è che entrambi i dfs abbiano lo stesso numero di colonne e tipi di dati associati. I nomi delle colonne possono essere diversi. Queste regole non si applicano ai RDD. Ecco un buon tutorial che spiega questi fatti.
4. Ci sono miglioramenti delle prestazioni quando si utilizzano DataFrames come altri hanno già spiegato in modo approfondito.
5. Utilizzando DataFrames non è necessario passare la funzione arbitraria come si fa durante la programmazione con RDD.
6. È necessario SQLContext / HiveContext per programmare i frame di dati che si trovano nell'area SparkSQL dell'ecosistema spark, ma per RDD sono necessari solo SparkContext / JavaSparkContext che si trovano nelle librerie Spark Core.
7. È possibile creare un df da un RDD se è possibile definire uno schema per esso.
8. Puoi anche convertire un df in rdd e un rdd in df.

Spero possa essere d'aiuto!

Un Dataframe è un RDD di oggetti Row, ognuno dei quali rappresenta un record. Un Dataframe conosce anche lo schema (ovvero i campi dati) delle sue righe. Mentre i Dataframe sembrano normali RDD, internamente archiviano i dati in modo più efficiente, sfruttando il loro schema. Inoltre, forniscono nuove operazioni non disponibili sui RDD, come la possibilità di eseguire query SQL. I frame di dati possono essere creati da origini dati esterne, dai risultati di query o da normali RDD.

Riferimento: Zaharia M., et al. Learning Spark (O'Reilly, 2015)

Spark RDD (resilient distributed dataset) :

RDD è l'API per l'estrazione dei dati principali ed è disponibile sin dalla prima versione di Spark (Spark 1.0). È un'API di livello inferiore per manipolare la raccolta distribuita di dati. Le API RDD espongono alcuni metodi estremamente utili che possono essere utilizzati per ottenere un controllo molto stretto sulla struttura dei dati fisici sottostanti. È una raccolta immutabile (sola lettura) di dati partizionati distribuiti su macchine diverse. RDD consente il calcolo in memoria su cluster di grandi dimensioni per accelerare l'elaborazione di big data in modo tollerante ai guasti. Per abilitare la tolleranza agli errori, RDD utilizza DAG (Directed Acyclic Graph) che consiste in un insieme di vertici e bordi. I vertici e i bordi in DAG rappresentano RDD e l'operazione da applicare rispettivamente su quel RDD. Le trasformazioni definite su RDD sono pigre ed eseguono solo quando viene chiamata un'azione

Spark DataFrame :

Spark 1.3 ha introdotto due nuove API per l'astrazione dei dati: DataFrame e DataSet. Le API DataFrame organizzano i dati in colonne denominate come una tabella nel database relazionale. Consente ai programmatori di definire lo schema su una raccolta distribuita di dati. Ogni riga in un DataFrame è di tipo riga oggetto. Come una tabella SQL, ogni colonna deve avere lo stesso numero di righe in un DataFrame. In breve, DataFrame è piano pigramente valutato che specifica le operazioni che devono essere eseguite sulla raccolta distribuita dei dati. DataFrame è anche una raccolta immutabile.

Spark DataSet :

Come estensione delle API DataFrame, Spark 1.3 ha anche introdotto API DataSet che forniscono un'interfaccia di programmazione tipizzata e orientata agli oggetti in Spark. È una raccolta immutabile e sicura di dati distribuiti. Come DataFrame, anche le API DataSet utilizzano il motore Catalyst per consentire l'ottimizzazione dell'esecuzione. DataSet è un'estensione delle API DataFrame.

Other Differences -

Un DataFrame è un RDD che ha uno schema. Puoi pensarlo come una tabella di database relazionale, in quanto ogni colonna ha un nome e un tipo noto. Il potere di DataFrames deriva dal fatto che, quando si crea un DataFrame da un set di dati strutturato (Json, Parquet ..), Spark è in grado di inferire uno schema effettuando un passaggio sull'intero set di dati (Json, Parquet ..) che è essere caricato. Quindi, quando si calcola il piano di esecuzione, Spark, è possibile utilizzare lo schema ed eseguire ottimizzazioni di calcolo sostanzialmente migliori. Si noti che DataFrame è stato chiamato SchemaRDD prima di Spark v1.3.0

Apache Spark: RDD, DataFrame e DataSet

Spark RDD -

Un RDD è l'acronimo di Resilient Distributed Dataset. È una raccolta di record di partizioni di sola lettura. RDD è la struttura dati fondamentale di Spark. Consente a un programmatore di eseguire calcoli in memoria su cluster di grandi dimensioni in modo tollerante ai guasti. Pertanto, accelerare l'attività.

Spark Dataframe -

A differenza di un RDD, i dati sono organizzati in colonne denominate. Ad esempio una tabella in un database relazionale. È una raccolta di dati distribuita immutabile. DataFrame in Spark consente agli sviluppatori di imporre una struttura su una raccolta distribuita di dati, consentendo l'astrazione di livello superiore.

Spark Dataset -

I set di dati in Apache Spark sono un'estensione dell'API DataFrame che fornisce un'interfaccia di programmazione orientata al tipo e orientata agli oggetti. Il set di dati sfrutta l'ottimizzatore Catalyst di Spark esponendo espressioni e campi dati a un pianificatore di query.

È possibile utilizzare RDD con strutturato e non strutturato in cui il Dataframe / set di dati può elaborare solo dati strutturati e semi-strutturati (ha uno schema adeguato)

Tutte le risposte fantastiche e l'utilizzo di ciascuna API ha qualche compromesso. Il set di dati è stato creato per essere una super API per risolvere molti problemi, ma molte volte RDD funziona ancora meglio se capisci i tuoi dati e se l'algoritmo di elaborazione è ottimizzato per fare molte cose in Single pass a dati di grandi dimensioni, RDD sembra l'opzione migliore.

L'aggregazione che utilizza l'API del set di dati consuma ancora memoria e migliorerà nel tempo.