Apache Spark est le logiciel le plus performant d'Apache Software Foundation et conçu pour le calcul rapide. Plusieurs secteurs utilisent Apache Spark pour trouver leurs solutions. PySpark SQL est un module de Spark qui intègre le traitement relationnel à l'API de programmation fonctionnelle de Spark. Nous pouvons extraire les données en utilisant un langage de requête SQL. Nous pouvons utiliser les requêtes de la même manière que le langage SQL.
Si vous avez une compréhension de base du SGBDR, PySpark SQL sera facile à utiliser, où vous pourrez étendre les limites du traitement des données relationnelles traditionnel. Spark prend également en charge le langage de requête Hive, mais il existe des limitations de la base de données Hive. Spark SQL a été développé pour supprimer les inconvénients de la base de données Hive. Jetons un coup d'œil aux inconvénients suivants de Hive :
Inconvénients de la ruche
- Il ne peut pas reprendre le traitement, ce qui signifie que si l'exécution échoue au milieu d'un flux de travail, vous ne pouvez pas reprendre là où elle était bloquée.
- Nous ne pouvons pas supprimer les bases de données chiffrées en cascade lorsque la corbeille est activée. Cela conduit à l’erreur d’exécution. Pour supprimer ce type de base de données, les utilisateurs doivent utiliser l'option Purge.
- Les requêtes ad hoc sont exécutées à l'aide de MapReduce, qui est lancé par Hive mais lorsque nous analysons la base de données de taille moyenne, cela retarde les performances.
- Hive ne prend pas en charge l'opération de mise à jour ou de suppression.
- Il est limité à la prise en charge des sous-requêtes.
Ces inconvénients sont les raisons de développer Apache SQL.
PySpark SQL Brève introduction
PySpark prend en charge le traitement relationnel intégré avec la programmation fonctionnelle de Spark. Il prend en charge les différentes sources de données pour permettre de tisser des requêtes SQL avec des transformations de code, résultant ainsi en un outil très puissant.
PySpark SQL établit la connexion entre le RDD et la table relationnelle. Il offre une intégration beaucoup plus étroite entre le traitement relationnel et procédural via l'API déclarative Dataframe, qui est intégrée au code Spark.
Grâce à SQL, il peut être facilement accessible à un plus grand nombre d'utilisateurs et améliorer l'optimisation des utilisateurs actuels. Il prend également en charge le large éventail de sources de données et d’algorithmes du Big data.
Fonctionnalité de PySpark SQL
Les fonctionnalités de PySpark SQL sont indiquées ci-dessous :
chaînes en entiers
1) Accès aux données de cohérence
Il fournit un accès cohérent aux données, ce qui signifie que SQL prend en charge une manière partagée d'accéder à une variété de sources de données telles que Ruche, Avro, Parquet, JSON et JDBC. Il joue un rôle important en accueillant tous les utilisateurs existants dans Spark SQL.
2) Incorporation avec Spark
Les requêtes PySpark SQL sont intégrées aux programmes Spark. Nous pouvons utiliser les requêtes dans les programmes Spark.
L'un de ses principaux avantages est que les développeurs n'ont pas à gérer manuellement les défaillances d'état ou à maintenir l'application synchronisée avec les tâches par lots.
3) Connectivité standard
Il fournit une connexion via JDBC ou ODBC, et ces deux normes sont les normes de l'industrie en matière de connectivité pour les outils de business intelligence.
4) Fonctions définies par l'utilisateur
PySpark SQL dispose d'un langage combinant des fonctions définies par l'utilisateur (UDF). UDF est utilisé pour définir une nouvelle fonction basée sur des colonnes qui étend le vocabulaire du DSL de Spark SQL pour transformer DataFrame.
5) Compatibilité de la ruche
PySpark SQL exécute des requêtes Hive non modifiées sur les données actuelles. Il permet une compatibilité totale avec les données Hive actuelles.
Module SQL PySpark
Certaines classes importantes de Spark SQL et DataFrames sont les suivantes :
Prenons l'exemple suivant de 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()
Sortir:
+-----+ |hello| +-----+ |spark| +-----+
Explication du code :
Dans le code ci-dessus, nous avons importé le trouvepark module et appelé findspark.init() constructeur; ensuite, nous avons importé le module SparkSession pour créer une session Spark.
à partir de pyspark.sql, importez SparkSession
Une session Spark peut être utilisée pour créer l'API Dataset et DataFrame. Une SparkSession peut également être utilisée pour créer un DataFrame, enregistrer un DataFrame en tant que table, exécuter du SQL sur des tables, mettre en cache une table et lire un fichier Parquet.
constructeur de classe
C'est un constructeur de Spark Session.
getOrCreate()
Il est utilisé pour obtenir un existant Session Spark, ou s'il n'y en a pas, créez-en un nouveau en fonction des options définies dans le générateur.
Quelques autres méthodes
Quelques méthodes de PySpark SQL sont les suivantes :
1. nom de l'application (nom)
Il est utilisé pour définir le nom de l'application, qui sera affiché dans l'interface utilisateur Web Spark. Le paramètre nom accepte le nom du paramètre.
2. config(key=Aucun, valeur = Aucun, conf = Aucun)
Il est utilisé pour définir une option de configuration. Les options définies à l'aide de cette méthode sont automatiquement propagées aux deux SparkConf et Session Spark la configuration.
from pyspark.conf import SparkConfSparkSession.builder.config(conf=SparkConf())
Paramètres:
3. maître(maître)
Il définit l'URL du maître Spark à laquelle se connecter, par exemple « local » pour s'exécuter localement, « local[4] » pour s'exécuter localement avec 4 cœurs.
Paramètres:
4. SparkSession.catalogue
Il s'agit d'une interface que l'utilisateur peut créer, supprimer, modifier ou interroger la base de données, les tables, les fonctions, etc.
5. SparkSession.conf
Il s'agit d'une interface de configuration d'exécution pour Spark. Il s'agit de l'interface grâce à laquelle l'utilisateur peut obtenir et définir toutes les configurations Spark et Hadoop pertinentes pour Spark SQL.
classe pyspark.sql.DataFrame
Il s'agit d'une collection distribuée de données regroupées en colonnes nommées. Un DataFrame est similaire à la table relationnelle dans Spark SQL et peut être créé à l'aide de diverses fonctions dans SQLContext.
student = sqlContext.read.csv('...')
Après la création du dataframe, nous pouvons le manipuler à l'aide des plusieurs langages spécifiques au domaine (DSL) qui sont des fonctions prédéfinies de DataFrame. Considérez l'exemple suivant.
# 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'}) Considérons l'exemple suivant :
Interroger à l'aide de Spark SQL
Dans le code suivant, nous créons d’abord un DataFrame et exécutons les requêtes SQL pour récupérer les données. Considérez le code suivant :
quand l'école a-t-elle été inventée
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()
Sortir:
+----------------+ | 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| +---+--------------------+-------------+-----+----------------+------+------------+--------------+--------+--------+-------+--------------+------------+----------+
Utilisation de la fonction groupBy()
La fonction groupBy() collecte les données de catégorie similaires.
songdf.groupBy('Genre').count().show()
Sortir:
+----------------+-----+ | 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| +----------------+-----+
repartition(numpartitions, *cols)
Le repartition() renvoie un nouveau DataFrame qui est une expression de partitionnement. Cette fonction accepte deux paramètres nombre de partitions et *col. Le nombre de partitions Le paramètre spécifie le nombre cible de colonnes.
song_spotify.repartition(10).rdd.getNumPartitions() data = song_spotify.union(song_spotify).repartition('Energy') data.show(5)
Sortir:
+---+--------------------+-----------+-------+----------------+------+------------+--------------+--------+--------+-------+--------------+------------+----------+ |_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