Apache Spark är den mest framgångsrika programvaran från Apache Software Foundation och designad för snabb beräkning. Flera industrier använder Apache Spark för att hitta sina lösningar. PySpark SQL är en modul i Spark som integrerar relationsbehandling med Sparks funktionella programmerings-API. Vi kan extrahera data genom att använda ett SQL-frågespråk. Vi kan använda frågorna på samma sätt som SQL-språket.
Om du har en grundläggande förståelse för RDBMS kommer PySpark SQL att vara lätt att använda, där du kan utöka begränsningen av traditionell relationsdatabehandling. Spark stöder också Hive Query Language, men det finns begränsningar för Hive-databasen. Spark SQL utvecklades för att ta bort nackdelarna med Hive-databasen. Låt oss ta en titt på följande nackdelar med Hive:
Nackdelarna med Hive
- Den kan inte återuppta bearbetningen, vilket innebär att om exekveringen misslyckas mitt i ett arbetsflöde, kan du inte återuppta där det fastnade.
- Vi kan inte släppa de krypterade databaserna i kaskad när papperskorgen är aktiverad. Det leder till exekveringsfelet. För att ta bort en sådan typ av databas måste användare använda alternativet Rensa.
- Ad-hoc-frågorna körs med MapReduce, som lanseras av Hive, men när vi analyserar den medelstora databasen försenar det prestandan.
- Hive stöder inte uppdateringen eller borttagningen.
- Det är begränsat till stöd för underfrågan.
Dessa nackdelar är skälen till att utveckla Apache SQL.
PySpark SQL Kort introduktion
PySpark stöder integrerad relationsbehandling med Sparks funktionella programmering. Det ger stöd för de olika datakällorna för att göra det möjligt att väva SQL-frågor med kodtransformationer, vilket resulterar i ett mycket kraftfullt verktyg.
PySpark SQL upprättar kopplingen mellan RDD och relationstabellen. Det ger mycket närmare integration mellan relations- och procedurbehandling genom deklarativ Dataframe API, som är integrerad med Spark-kod.
innehåller i sträng
Med hjälp av SQL kan den vara lättillgänglig för fler användare och förbättra optimeringen för de nuvarande. Den stöder också det breda utbudet av datakällor och algoritmer i Big-data.
Funktion i PySpark SQL
Funktionerna i PySpark SQL ges nedan:
1) Tillgång till konsistensdata
Det ger konsekvent dataåtkomst innebär att SQL stöder ett delat sätt att komma åt en mängd olika datakällor som Hive, Avro, Parquet, JSON och JDBC. Det spelar en viktig roll för att tillgodose alla befintliga användare i Spark SQL.
2) Inkorporering med Spark
PySpark SQL-frågor är integrerade med Spark-program. Vi kan använda frågorna i Spark-programmen.
En av dess största fördelar är att utvecklare inte behöver hantera tillståndsfel manuellt eller hålla applikationen synkroniserad med batchjobb.
3) Standardanslutning
Den tillhandahåller en anslutning via JDBC eller ODBC, och dessa två är branschstandarderna för anslutning för affärsinformationsverktyg.
4) Användardefinierade funktioner
PySpark SQL har en språkkombinerad användardefinierad funktion (UDF). UDF används för att definiera en ny kolumnbaserad funktion som utökar vokabulären för Spark SQLs DSL för att transformera DataFrame.
partiellt derivat av latex
5) Hive-kompatibilitet
PySpark SQL kör omodifierade Hive-frågor på aktuell data. Det tillåter full kompatibilitet med aktuella Hive-data.
PySpark SQL-modul
Några viktiga klasser av Spark SQL och DataFrames är följande:
Tänk på följande exempel på PySpark SQL.
import findspark findspark.init() import pyspark # only run after findspark.init() from pyspark.sql import SparkSession spark = SparkSession.builder.getOrCreate() df = spark.sql('''select 'spark' as hello ''') df.show()
Produktion:
+-----+ |hello| +-----+ |spark| +-----+
Kodförklaring:
I koden ovan har vi importerat findspark modul och ringde findspark.init() konstruktör; sedan importerade vi SparkSession-modulen för att skapa sparksession.
np.unik
från pyspark.sql importera SparkSession
En sparksession kan användas för att skapa Dataset och DataFrame API. En SparkSession kan också användas för att skapa DataFrame, registrera DataFrame som en tabell, exekvera SQL över tabeller, cachetabell och läsa parkettfil.
klassbyggare
Det är en byggare av Spark Session.
getOrCreate()
Den används för att få en existerande SparkSession, eller om det inte finns någon befintlig, skapa en ny baserat på alternativen som ställts in i byggaren.
Några andra metoder
Några metoder för PySpark SQL är följande:
1. appnamn(namn)
Den används för att ställa in namnet på applikationen, som kommer att visas i Sparks webbgränssnitt. Parametern namn accepterar namnet på parametern.
2. config(key=Ingen, värde = Ingen, conf = Ingen)
Den används för att ställa in ett konfigurationsalternativ. Alternativ som ställs in med den här metoden sprids automatiskt till båda SparkConf och SparkSession s konfiguration.
from pyspark.conf import SparkConfSparkSession.builder.config(conf=SparkConf())
Parametrar:
numpy standardavvikelse
3. mästare (mästare)
Den ställer in den sparkmaster-url som ska anslutas till, till exempel 'local' för att köras lokalt, 'local[4]' för att köras lokalt med 4 kärnor.
Parametrar:
4. SparkSession.catalog
Det är ett gränssnitt som användaren kan skapa, släppa, ändra eller fråga efter den underliggande databasen, tabellerna, funktionerna etc.
5. SparkSession.conf
array.från java
Det är runtime-konfigurationsgränssnitt för spark. Detta är gränssnittet genom vilket användaren kan få och ställa in alla Spark- och Hadoop-konfigurationer som är relevanta för Spark SQL.
klass pyspark.sql.DataFrame
Det är en distribuerad samling av data grupperad i namngivna kolumner. En DataFrame liknar relationstabellen i Spark SQL, kan skapas med olika funktioner i SQLContext.
student = sqlContext.read.csv('...')
Efter att ha skapat en dataram kan vi manipulera den med hjälp av flera domänspecifika språk (DSL) som är fördefinierade funktioner i DataFrame. Betrakta följande exempel.
# To create DataFrame using SQLContext student = sqlContext.read.parquet('...') department = sqlContext.read.parquet('...') student.filter(marks > 55).join(department, student.student_Id == department.id) .groupBy(student.name, 'gender').({'name': 'student_Id', 'mark': 'department'}) Låt oss överväga följande exempel:
Fråga med Spark SQL
I följande kod skapar vi först en DataFrame och kör SQL-frågorna för att hämta data. Tänk på följande kod:
from pyspark.sql import * #Create DataFrame songdf = spark.read.csv(r'C:UsersDEVANSH SHARMA op50.csv', inferSchema = True, header = True) #Perform SQL queries songdf.select('Genre').show() songdf.filter(songdf['Genre']=='pop').show()
Produktion:
+----------------+ | Genre| +----------------+ | canadian pop| | reggaeton flow| | dance pop| | pop| | dfw rap| | pop| | trap music| | pop| | country rap| | electropop| | reggaeton| | dance pop| | pop| | panamanian pop| |canadian hip hop| | dance pop| | latin| | dfw rap| |canadian hip hop| | escape room| +----------------+ only showing top 20 rows +---+--------------------+-------------+-----+----------------+------+------------+--------------+--------+--------+-------+--------------+------------+----------+ |_c0| Track.Name| Artist.Name|Genre|Beats.Per.Minute|Energy|Danceability|Loudness..dB..|Liveness|Valence.|Length.|Acousticness..|Speechiness.|Popularity| +---+--------------------+-------------+-----+----------------+------+------------+--------------+--------+--------+-------+--------------+------------+----------+ | 4|Beautiful People ...| Ed Sheeran| pop| 93| 65| 64| -8| 8| 55| 198| 12| 19| 86| | 6|I Don't Care (wit...| Ed Sheeran| pop| 102| 68| 80| -5| 9| 84| 220| 9| 4| 84| | 8| How Do You Sleep?| Sam Smith| pop| 111| 68| 48| -5| 8| 35| 202| 15| 9| 90| | 13| Someone You Loved|Lewis Capaldi| pop| 110| 41| 50| -6| 11| 45| 182| 75| 3| 88| | 38|Antisocial (with ...| Ed Sheeran| pop| 152| 82| 72| -5| 36| 91| 162| 13| 5| 87| | 44| Talk| Khalid| pop| 136| 40| 90| -9| 6| 35| 198| 5| 13| 84| | 50|Cross Me (feat. C...| Ed Sheeran| pop| 95| 79| 75| -6| 7| 61| 206| 21| 12| 82| +---+--------------------+-------------+-----+----------------+------+------------+--------------+--------+--------+-------+--------------+------------+----------+
Använder groupBy()-funktionen
groupBy()-funktionen samlar in liknande kategoridata.
songdf.groupBy('Genre').count().show()
Produktion:
+----------------+-----+ | Genre|count| +----------------+-----+ | boy band| 1| | electropop| 2| | pop| 7| | brostep| 2| | big room| 1| | pop house| 1| | australian pop| 1| | edm| 3| | r&b en espanol| 1| | dance pop| 8| | reggaeton| 2| | canadian pop| 2| | trap music| 1| | escape room| 1| | reggaeton flow| 2| | panamanian pop| 2| | atl hip hop| 1| | country rap| 2| |canadian hip hop| 3| | dfw rap| 2| +----------------+-----+
distribution (antalpartitioner, *cols)
De distribution() returnerar en ny DataFrame som är ett partitioneringsuttryck. Denna funktion accepterar två parametrar antal partitioner och *kol. De antal partitioner parametern anger målantalet kolumner.
song_spotify.repartition(10).rdd.getNumPartitions() data = song_spotify.union(song_spotify).repartition('Energy') data.show(5)
Produktion:
+---+--------------------+-----------+-------+----------------+------+------------+--------------+--------+--------+-------+--------------+------------+----------+ |_c0| Track.Name|Artist.Name| Genre|Beats.Per.Minute|Energy|Danceability|Loudness..dB..|Liveness|Valence.|Length.|Acousticness..|Speechiness.|Popularity| +---+--------------------+-----------+-------+----------------+------+------------+--------------+--------+--------+-------+--------------+------------+----------+ | 4|Beautiful People ...| Ed Sheeran| pop| 93| 65| 64| -8| 8| 55| 198| 12| 19| 86| | 5|Goodbyes (Feat. Y...|Post Malone|dfw rap| 150| 65| 58| -4| 11| 18| 175| 45| 7| 94| | 17| LA CANCI?N| J Balvin| latin| 176| 65| 75| -6| 11| 43| 243| 15| 32| 90| | 4|Beautiful People ...| Ed Sheeran| pop| 93| 65| 64| -8| 8| 55| 198| 12| 19| 86| | 5|Goodbyes (Feat. Y...|Post Malone|dfw rap| 150| 65| 58| -4| 11| 18| 175| 45| 7| 94| +---+--------------------+-----------+-------+----------------+------+------------+--------------+--------+--------+-------+--------------+------------+----------+ only showing top 5 rows