Spark SQL Dataframe
Une trame de données similaire à RDD est une abstraction fournie pour les données structurées dans la bibliothèque Spark SQL. Il s'agit d'une collection distribuée de données qui peut être considérée comme une table dans une base de données relationnelle avec un schéma attaché. Il peut également être défini comme la collection de colonnes nommées. Spark SQL est l'une des bibliothèques disponibles dans la pile Spark qui contient des informations sur la structure et le calcul effectué sur les données. Ces informations supplémentaires sont utilisées pour effectuer des optimisations. Une trame de données intègre les avantages du RDD ainsi que des techniques d'optimisation et cette API est disponible en Python, R, Scala et Java.
Les différentes sources qui génèrent une trame de données sont-
- RDD existant
- Fichiers et bases de données structurés
- Tables de ruche
Besoin de Dataframe
La communauté spark a toujours essayé de structurer les données, où les cadres de données SQL spark sont les étapes prises dans cette direction. L'API initiale de spark, RDD est pour les données non structurées où les calculs et les données sont tous deux opaques. Il était donc nécessaire de créer une API capable de fournir des avantages supplémentaires d'optimisation. Voici les quelques exigences qui ont constitué la base du cadre de données.
- Processus structurés et semi-données
- Plusieurs sources de données
- Intégration avec plusieurs langages de programmation
- Le nombre d'opérations pouvant être effectuées sur les données telles que la sélection et le filtrage.
Comment créer Spark SQL Dataframe?
Avant de comprendre les moyens de créer une trame de données, il est important de comprendre un autre concept par lequel les applications spark créent des trames de données à partir de différentes sources. Ce concept est connu sous le nom de sparksession et est le point d'entrée pour toutes les fonctionnalités de l'étincelle. Auparavant, nous devions créer sparkConf, sparkContext ou sqlContext individuellement mais avec sparksession, tous sont encapsulés dans une seule session où spark agit comme un objet sparksession.
import org.apache.spark.sql.SparkSession
val spark = SparkSession
.builder()
.appName("SampleWork")
.config("config.option", "value")
.getOrCreate()
Façons de créer une trame de données
-
À partir d'un RDD existant
Il existe deux façons de créer un Dataframe via RDD. Une façon consiste à utiliser la réflexion qui déduit automatiquement le schéma des données et l'autre approche consiste à créer un schéma par programme, puis à l'appliquer au RDD.
- En déduisant le schéma
Un moyen facile de convertir un RDD en Dataframe est quand il contient des classes de cas en raison de l'interface SQL de Spark. Les arguments passés aux classes de cas sont récupérés à l'aide de la réflexion et il devient le nom des colonnes de la table. Les séquences et les tableaux peuvent également être définis dans les classes de cas. Le RDD qui sera créé à l'aide de la classe case peut être implicitement converti en Dataframe à l'aide de la méthode 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()
Un véhicule de trame de données est créé et peut être enregistré en tant que table par rapport à laquelle les instructions SQL peuvent être exécutées.
- En spécifiant par programme le schéma
Il peut y avoir des cas où nous ne connaissons pas le schéma à l'avance ou des scénarios où les classes de cas ne peuvent pas prendre plus de 22 champs. Dans de telles conditions, nous utilisons l'approche de création par programme du schéma. Tout d'abord, un RDD de lignes est créé à partir du RDD d'origine, c'est-à-dire la conversion de l'objet rdd de rdd (t) en rdd (ligne). Créez ensuite un schéma à l'aide des objets StructType (Table) et StructField (Field). Ce schéma est appliqué au RDD de lignes à l'aide de la méthode createDataFrame, qui ressemble à la structure de rdd (ligne) créée précédemment.
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)
-
Via des sources de données
Spark permet la création de cadres de données via plusieurs sources telles que ruche, json, parquet, csv et fichiers texte qui peuvent également être utilisés pour créer des cadres de données.
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”)
Opérations DataFrame
Comme les données sont stockées dans un format tabulaire avec le schéma, un certain nombre d'opérations peuvent être effectuées sur les trames de données. Il permet plusieurs opérations qui peuvent être effectuées sur des données dans des trames de données.
Considérer que le fichier est une trame de données qui a été créée à partir d'un fichier csv avec deux colonnes - FullName et AgePerPA
- printSchema () - Pour afficher la structure du schéma
file.printSchema()
// |-- AgePerPA: long (nullable = true)
// |-- FullName: string (nullable = true)
- select- Similaire à l'instruction select en SQL, présente les données comme mentionné dans l'instruction select.
file.select("FullName").show()
// +-------+
// | name|
// +-------+
// |Sam|
// |Jodi|
// | Bala|
// +-------+
- Filtre - Pour afficher les données filtrées à partir de la trame de données. La condition mentionnée dans la commande
file.filter($"AgePerPA" > 18).show()
- GroupBy- Pour grouper les valeurs
file.groupBy("AgePerPA").count().show()
- show () - pour afficher le contenu de la trame de données
file.show()
Limites
Bien qu'avec les cadres de données, vous pouvez détecter une erreur de syntaxe SQL au moment de la compilation, il n'est pas capable de gérer les erreurs liées à l'analyse jusqu'à l'exécution. Par exemple, si un nom de colonne inexistant est référencé dans le code, il ne sera pas remarqué jusqu'à l'exécution. Cela conduirait à gaspiller le temps du développeur et le coût du projet.
Conclusion - Spark SQL Dataframe
Cet article donne une image globale (besoin, création, limitations) de l'API Dataframe de Spark SQL. En raison de la popularité des API de dataframe, Spark SQL reste l'une des bibliothèques les plus utilisées. Tout comme un RDD, il offre des fonctionnalités telles que la tolérance aux pannes, l'évaluation paresseuse, le traitement en mémoire ainsi que certains avantages supplémentaires. Il peut être défini comme des données réparties sur le cluster sous forme de tableau. Ainsi, une trame de données sera associée à un schéma et pourra être créée via plusieurs sources via un objet de session spark.
Articles recommandés
Ceci est un guide de Spark SQL Dataframe. Nous discutons ici des façons de créer une trame de données avec les opérations et limitations de DataFrame. Vous pouvez également consulter l'article suivant pour en savoir plus -
- Commandes Spark Shell
- Curseurs en SQL
- Contraintes SQL
- Base de données en SQL
- Types de jointures dans Spark SQL (exemples)
- Guide de la liste des commandes du shell Unix