Spark SQL Dataframe

Een dataframe vergelijkbaar met RDD is een abstractie voor gestructureerde gegevens in de Spark SQL-bibliotheek. Het is een gedistribueerde verzameling gegevens die kan worden beschouwd als een tabel in een relationele database waaraan een schema is gekoppeld. Het kan ook worden gedefinieerd als de verzameling benoemde kolommen. Spark SQL is een van de bibliotheken in de Spark-stapel die informatie bevat over de structuur en de berekening die op de gegevens wordt uitgevoerd. Deze aanvullende informatie wordt gebruikt om optimalisaties uit te voeren. Een dataframe bevat de voordelen van RDD samen met optimalisatietechnieken en deze API is beschikbaar in Python, R, Scala en Java.

De verschillende bronnen die een dataframe genereren zijn-

  • Bestaande RDD
  • Gestructureerde gegevensbestanden en databases
  • Bijenkorftafels

Dataframe nodig

De vonkengemeenschap heeft altijd geprobeerd de gegevens te structureren, waarbij vonk-SQL-dataframes de stappen in die richting zijn. De initiële API van Spark, RDD, is voor ongestructureerde gegevens waarbij de berekeningen en gegevens beide ondoorzichtig zijn. Er was dus een vereiste om een ​​API te maken die extra voordelen van optimalisatie kon bieden. Hieronder staan ​​enkele vereisten die de basis vormden voor dataframe-

  • Verwerk gestructureerde en semi-gegevens
  • Meerdere gegevensbronnen
  • Integratie met meerdere programmeertalen
  • Het aantal bewerkingen dat kan worden uitgevoerd op de gegevens, zoals selecteren en filteren.

Hoe Spark SQL Dataframe te maken?

Voordat u manieren begrijpt om een ​​dataframe te maken, is het belangrijk om een ​​ander concept te begrijpen waarmee vonktoepassingen een dataframe uit verschillende bronnen maken. Dit concept staat bekend als vonksessie en is het startpunt voor alle vonkenfunctionaliteit. Eerder moesten we sparkConf, sparkContext of sqlContext individueel maken, maar met sparksession, ze zijn allemaal ingekapseld in één sessie waarin spark fungeert als een sparksession-object.

import org.apache.spark.sql.SparkSession
val spark = SparkSession
.builder()
.appName("SampleWork")
.config("config.option", "value")
.getOrCreate()

Manieren om een ​​dataframe te maken

  1. Van bestaande RDD

Er zijn twee manieren waarop een Dataframe kan worden gemaakt via RDD. Een manier is om reflectie te gebruiken die automatisch het schema van de gegevens afleidt en de andere manier is om een ​​schema programmatisch te maken en vervolgens op de RDD toe te passen.

  • Door het schema af te leiden

Een eenvoudige manier om een ​​RDD naar Dataframe te converteren is wanneer deze case-klassen bevat vanwege de Spark's SQL-interface. De argumenten die aan de casusklassen worden doorgegeven, worden opgehaald met reflectie en dit wordt de naam van de kolommen van de tabel. Sequenties en arrays kunnen ook worden gedefinieerd in casusklassen. De RDD die met de case-klasse wordt gemaakt, kan impliciet worden geconverteerd naar Dataframe met de methode 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()

Een dataframe-voertuig wordt gemaakt en kan worden geregistreerd als een tabel waartegen sql-instructies kunnen worden uitgevoerd.

  • Door het Schema programmatisch te specificeren

Er kunnen gevallen zijn waarin we ons vooraf niet bewust zijn van het schema of scenario's waarin case-klassen niet meer dan 22 velden kunnen bevatten. In dergelijke omstandigheden gebruiken we de benadering om het schema programmatisch te maken. Eerst wordt een RDD van rijen gemaakt van de oorspronkelijke RDD, dat wil zeggen het rdd-object converteren van rdd (t) naar rdd (rij). Maak vervolgens een schema met de objecten StructType (tabel) en StructField (veld). Dit schema wordt toegepast op de RDD van rijen met behulp van de methode createDataFrame die lijkt op de eerder gemaakte structuur van rdd (rij).

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)

  1. Via gegevensbronnen

Spark maakt het mogelijk om dataframes te maken via meerdere bronnen zoals hive, json, parket, csv en tekstbestanden die ook kunnen worden gebruikt om dataframes te maken.

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

DataFrame-bewerkingen

Omdat de gegevens samen met het schema in tabelvorm worden opgeslagen, zijn er een aantal bewerkingen die op de dataframes kunnen worden uitgevoerd. Hiermee kunnen meerdere bewerkingen op gegevens in dataframes worden uitgevoerd.

Beschouw bestand is een dataframe dat is gemaakt op basis van een csv-bestand met twee kolommen - FullName en AgePerPA

  1. printSchema () - Om de schemastructuur te bekijken

file.printSchema()
// |-- AgePerPA: long (nullable = true)
// |-- FullName: string (nullable = true)

  1. select- Vergelijkbaar met select statement in SQL, toont de gegevens zoals vermeld in het select statement.

file.select("FullName").show()
// +-------+
// | name|
// +-------+
// |Sam|
// |Jodi|
// | Bala|
// +-------+

  1. Filter- Om de gefilterde gegevens van het dataframe te bekijken. De voorwaarde vermeld in het commando

file.filter($"AgePerPA" > 18).show()

  1. GroupBy- Groeperen op basis van de waarden

file.groupBy("AgePerPA").count().show()

  1. show () - om de inhoud van het dataframe weer te geven

file.show()

beperkingen

Hoewel u met dataframes SQLL-syntaxisfouten kunt krijgen tijdens het compileren zelf, is het niet in staat om enige analyse gerelateerde fout af te handelen tot runtime. Als er bijvoorbeeld in de code naar een niet-bestaande kolomnaam wordt verwezen, wordt deze tot runtime niet opgemerkt. Dit zou leiden tot verspilling van de tijd en projectkosten van de ontwikkelaar.

Conclusie - Spark SQL Dataframe

Dit artikel geeft een algemeen beeld (behoefte, creatie, beperkingen) over de dataframe-API van Spark SQL. Vanwege de populariteit van dataframe-API's blijft Spark SQL een van de meest gebruikte bibliotheken. Net als een RDD biedt het functies zoals fouttolerantie, luie evaluatie, verwerking in het geheugen, samen met enkele extra voordelen. Het kan worden gedefinieerd als gegevens die in tabelvorm over het cluster worden verspreid. Aan een dataframe is dus een schema gekoppeld en dit kan via meerdere bronnen via een spark-sessieobject worden gemaakt.

Aanbevolen artikelen

Dit is een handleiding voor Spark SQL Dataframe. Hier bespreken we de manieren om een ​​dataframe te maken met de DataFrame-bewerkingen en -beperkingen. U kunt ook het volgende artikel bekijken voor meer informatie -

  1. Spark Shell-opdrachten
  2. Cursors in SQL
  3. SQL-beperkingen
  4. Database in SQL
  5. Soorten joins in Spark SQL (voorbeelden)
  6. Handleiding voor de lijst met Unix Shell-opdrachten

Categorie:

Big Data