Spark SQL Dataframe
Un frame di dati simile a RDD è un'astrazione fornita per i dati strutturati nella libreria Spark SQL. È una raccolta distribuita di dati che può essere considerata una tabella in un database relazionale con uno schema allegato. Può anche essere definito come la raccolta di colonne con nome. Spark SQL è una delle librerie disponibili nello stack Spark che contiene informazioni sulla struttura e sul calcolo che viene eseguito sui dati. Queste informazioni aggiuntive vengono utilizzate per eseguire ottimizzazioni. Un dataframe incorpora i vantaggi di RDD insieme alle tecniche di ottimizzazione e questa API è disponibile in Python, R, Scala e Java.
Le diverse fonti che generano un frame di dati sono-
- RDD esistente
- File e database di dati strutturati
- Tabelle alveare
Necessità di Dataframe
La comunità spark ha sempre cercato di portare struttura ai dati, dove spark SQL-dataframes sono i passi fatti in quella direzione. L'API iniziale di spark, RDD è per i dati non strutturati in cui i calcoli e i dati sono entrambi opachi. Pertanto, era necessario creare un'API in grado di fornire ulteriori vantaggi di ottimizzazione. Di seguito sono riportati i pochi requisiti che hanno costituito la base di dataframe-
- Processo strutturato e semi-dati
- Fonti di dati multiple
- Integrazione con più linguaggi di programmazione
- Il numero di operazioni che è possibile eseguire sui dati come selezionare e filtrare.
Come creare Spark SQL Dataframe?
Prima di comprendere le modalità di creazione di un frame di dati, è importante comprendere un altro concetto in base al quale le applicazioni spark creano un frame di dati da origini diverse. Questo concetto è noto come sparksession ed è il punto di accesso per tutte le funzionalità spark. In precedenza abbiamo dovuto creare sparkConf, sparkContext o sqlContext singolarmente ma con sparksession, tutti sono incapsulati in una sessione in cui spark funge da oggetto sparksession.
import org.apache.spark.sql.SparkSession
val spark = SparkSession
.builder()
.appName("SampleWork")
.config("config.option", "value")
.getOrCreate()
Modi per creare un frame di dati
-
Da RDD esistente
Esistono due modi in cui è possibile creare un Dataframe tramite RDD. Un modo è usare la riflessione che infligge automaticamente lo schema dei dati e l'altro approccio è quello di creare uno schema a livello di codice e quindi applicare al RDD.
- Inferendo lo schema
Un modo semplice per convertire un RDD in Dataframe è quando contiene classi di casi dovute all'interfaccia SQL di Spark. Gli argomenti passati alle classi case vengono recuperati usando reflection e diventa il nome delle colonne della tabella. Sequenze e matrici possono anche essere definite in classi di casi. Il RDD che verrà creato utilizzando la classe case può essere convertito implicitamente in Dataframe utilizzando il metodo toDF ().
val sqlContext = new org.apache.spark.sql.SQLContext(sc)
import sqlContext.implicits._
case class Transport(AutoName: String, year: Int)
val Vehicle = sc.textFile("//path//").map(_.split(", ")).map(p => Transport(p(0), p(1)).toDF()
Viene creato un veicolo frame di dati che può essere registrato come una tabella in base alla quale è possibile eseguire le istruzioni sql.
- Specificando a livello di codice lo schema
Ci possono essere casi in cui non siamo a conoscenza dello schema in anticipo o di scenari in cui le classi di casi non possono occupare più di 22 campi. In tali condizioni, utilizziamo l'approccio della creazione programmatica dello schema. Innanzitutto viene creato un RDD di righe dal RDD originale, ovvero convertendo l'oggetto rdd da rdd (t) a rdd (riga). Quindi creare uno schema usando gli oggetti StructType (Table) e StructField (Field). Questo schema viene applicato a RDD of Rows usando il metodo createDataFrame in quanto ricorda la struttura di rdd (riga) creata in precedenza.
val Vehicle = sc.textFile("//path")
import org.apache.spark.sql._
val schema = StructType(Array(StructField("AutoName", StringType, true), StructField("Year", IntegerType, true)))
scala> val rowRDD = vehicle.map(_.split(", ")).map(p => org.apache.spark.sql.Row(p(0), p(1).toInt))
val vehicleSchemaRDD = sqlContext.applySchema(rowRDD, schema)
-
Attraverso fonti di dati
Spark consente la creazione di frame di dati attraverso più origini come hive, json, parquet, CSV e file di testo che possono essere utilizzati anche per creare frame di dati.
Val file=sqlContext.read.json(“path to the json file”)
Val file=sqlContext.read.csv(“path to the json file”)
Val file=sqlContext.read.text(“path to the json file”)
val hiveData = new org.apache.spark.sql.hive.HiveContext(sc)
val hiveDF = hiveData.sql(“select * from tablename”)
Operazioni DataFrame
Poiché i dati sono archiviati in un formato tabulare insieme allo schema, esistono diverse operazioni che possono essere eseguite sui frame di dati. Consente più operazioni che possono essere eseguite sui dati nei frame di dati.
Considerare che il file è un frame di dati che è stato creato da un file CSV con due colonne: FullName e AgePerPA
- printSchema () - Per visualizzare la struttura dello schema
file.printSchema()
// |-- AgePerPA: long (nullable = true)
// |-- FullName: string (nullable = true)
- select- Simile all'istruzione select in SQL, mostra i dati come indicato nell'istruzione select.
file.select("FullName").show()
// +-------+
// | name|
// +-------+
// |Sam|
// |Jodi|
// | Bala|
// +-------+
- Filtro: per visualizzare i dati filtrati dal frame di dati. La condizione menzionata nel comando
file.filter($"AgePerPA" > 18).show()
- GroupBy- Per raggruppare i valori
file.groupBy("AgePerPA").count().show()
- show () - per visualizzare il contenuto di dataframe
file.show()
limitazioni
Sebbene con i frame di dati sia possibile rilevare l'errore di sintassi sql al momento della compilazione, non è in grado di gestire alcun errore relativo all'analisi fino al runtime. Ad esempio, se si fa riferimento a un nome di colonna inesistente nel codice, questo non verrà notato fino al runtime. Ciò porterebbe a sprecare il tempo dello sviluppatore e il costo del progetto.
Conclusione - Spark SQL Dataframe
Questo articolo fornisce un quadro generale (necessità, creazione, limitazioni) sull'API dataframe di Spark SQL. A causa della popolarità delle API dei frame di dati, Spark SQL rimane una delle librerie più utilizzate. Proprio come un RDD, offre funzionalità come tolleranza agli errori, valutazione pigra, elaborazione in memoria e alcuni vantaggi aggiuntivi. Può essere definito come dati distribuiti nel cluster in forma tabellare. Pertanto un dataframe avrà uno schema associato ad esso e può essere creato attraverso più origini tramite l'oggetto sessione spark.
Articoli consigliati
Questa è una guida a Spark SQL Dataframe. Qui discutiamo i modi per creare un dataframe con DataFrame Operations and Limitations. Puoi anche leggere il seguente articolo per saperne di più -
- Comandi Spark Shell
- Cursori in SQL
- Vincoli SQL
- Database in SQL
- Tipi di join in Spark SQL (esempi)
- Guida all'elenco dei comandi Unix Shell