Spark SQL principes et fonctions
-
Upload
michrafy-mustafa -
Category
Data & Analytics
-
view
4.164 -
download
3
Transcript of Spark SQL principes et fonctions
CONTEXTE
Cette étude a été menée dans le cadre des
rencontres de travail organisées au Laboratoire
CERMSEM, Centre d'Économie de la Sorbonne (CES).
Il vise à présenter Spark SQL:
• Architecture
• API de Spark SQL
• Opérations sur DataFrames
• Opérations sur DataSet
• Opérations relationnelles
2
M.MICHRAFY
PLAN
1. Contexte
2. Objectif et prérequis3. Spark SQL, Motivations
4. Spark SqL et introduction de Catalyst Optimizer
5. Aperçu sur les objets du module Spark SQL
6. Nouvelle architecture Spark ( 2.x)
7. DataWorkflow et Catalyst Optimizer
8. Zoom sur SParkSESSION
9. DataSet et DataFrame
10.DataFrame, caractéristiques, formats supportés, création11.Chargement et persistance des données
12.DataFrameNaFunctions et Préparation des données
13.Graphe de conversion entre Collection, RDD, DataFrame et DataSet
14.Opérations sur les DataSets et les DataFrames
3
M.MICHRAFY
OBJECTIF ET PRÉREQUIS
• Connaissance de l’approche objet
• Connaissance de la programmation
fonctionnelle
• Connaissance du langage Scala
• Connaissance de Spark
Cette étude porte sur la brique Spark SQL de
la plateforme Apache Spark. Il vise à
présenter les concepts et les fonctionnalités
de spark SQL.
PrérequisObjectif
4
M.MICHRAFY
SPARK SQL : DÉFINITION ET MOTIVATIONS ?
• SPARK SQL est une brique logiciel incontournable
de la plate forme Apache Spark.
• Cette brique est dédiée au traitement de
données structurées et semi structurées via l’API
DataSet/DataFrame.
• Spark SQL permet d’effectuer des requêtes sur les
données avec une syntaxe similaire à SQL.
• Spark SQL permet de s’interfacer à diverses
sources de données.
• Les opérations de SPARK SQL sont optimisées à
travers l’utilisation de Catalyst Optimizer.
• Pour formater les données
• Pour extraire des caractéristiques des données
• Pour enrichir les données
• Pour transformer les données
• Pour appliquer des opérations relationnelles
SPARK SQL ? Fonctionnalités
5
M.MICHRAFY
• S’interfacer avec un tableau de bord en utilisant
tableau, Qlik
• Réaliser des requêtes SQL sans faire appel à la
sémantique RDD
• Préparation et Analyse des données à travers l’utilisation
de l’API DataFrame/DataSet avec opérations optimisées
et riches à l’image du package dplyr de R
Cas d’utilisation
SPARK SQL ET INTRODUCTION DE CATALYST OPTIMIZER
6
La popularité des systèmes
relationnels montre que les
utilisateurs favorisent l’écriture des
requêtes déclaratives.
Constat 1
L’approche relationnelle
est insuffisante pour la
majorité des applications
BigData, car :
Limite
Un besoin pour des opérations ETL vers et
à partir de diverses sources de données,
(semi) structurée, nécessitant un code
personnalisé.
L’analyse avancée -basée sur des
algorithmes complexes- ne peut être
réalisée par l’approche relationnelle
1
2
Les workflows de données
peuvent être exprimés par une
combinaison de requêtes
relationnelles et d’algorithmes
complexes.
Constat 2
Ces deux systèmes - relationnel et procédural – sont restés jusqu'à la
version 1.0.2 de Spark largement disjointes, forçant les utilisateurs à
choisir un paradigme ou l'autre.
À noter …
• Il vise à combiner l’approche relationnelle et procédurale dans la brique spark SQL.
o API DATASET/DataFrame permet d’effectuer des opérations relationnelles sur des sources de
données externes et les collections intégrées de Spark
o Divers formats de données et algorithmes distribués supportés via l’introduction de l’optimiseur
Catalyst
Intérêt de SPARK SQL
APERÇU SUR LES OBJETS DU MODULE SPARK SQL
7
Objets
Spark SQL
Point d’entrée pour l’API
DataSet et l’API DataFrame
DataSet est une collection
distribuée immutable, disposant
d’opérations de type action et
transformation. DataFrame est
un DataSet de Type Row
Interface pour charger des
DataSet à partir d’un stockage
externe (TXT, CSV, JSON,
PARQUET, Cle/Valeur, JDBC)
Interface pour persister les
données d’une DataSet vers un
système de stockage externe
Trait qui représente
une colonne
Trait qui représente
une ligne
Point d’entrée pour le module
Spark SQL de la version 1.0.1 à
la version 1.6 de Spark
Collection des méthodes
implicites pour convertir
des Objets Scala en
DataSets
SQLImplicits
SQLContext
Row
ColumnDataFrameWriter
DataFrameReader
DataSet & DataFrame
SparkSession
NOUVELLE ARCHITECTURE SPARK ( 2.X)
8
Spark Core (RDD)
SQL
ML Pipelines
Catalyst Optimizer
DataSet/DataFrame
Structured
Streaming
GraphFrame
Storage
SparkSQL
o La nouvelle architecture s’appuie sur le
module Catalyst Optimizer permettant
d’unifier les APIs et optimiser davantage le
traitement .
o DataSet = DataFrame[Row]
o DataSet, DataFrame et SQL partagent les
mêmes étapes d’optimisation et
d’exécution grâce à Catalyst Optimizer
DATAWORKFLOW ET CATALYST OPTIMIZER
9
SQL AST
DataFrame
DataSet
RDDs
Catalyst Optimizer
Query Plan Optimization
Query
Transformation Génération du code
SPARKSESSION
10
• SparkSession est le point d’entrée de l’API
DataSet/Dataframe, depuis la version 2.0.0
• SparkSession est une classe qui peut être créée à
partir du Builder.
• Elle appartient au package org.apache.spark.sql
Point d’entrée
• Accéder à SparkContext
• Accéder à SparkSql pour garantir la cohérence des versions
de Spark SQL
• Créer des DataFrames à partir des RDD ou des collections
• Créer des DataSet
• Créer une DataFrame ou une DataSet vide
• Créer une DataSet avec une seule colonne
• Exécuter une requête Sql et retourner une dataframe.
• Accéder à des Interfaces permettant de charger une
DataSet, en mode batch ou flux continu, à partir de
systèmes de stockage externes (TEXT, CSV, JSON, ORC,
PARQUET, Cle/valeur, JDBC)
Fonctionnalités
• La majorité des méthodes sont au stade expérimental et sont disponibles à partir de la version 2.
• D’autres méthodes sont dédiés aux développeurs de l’API Spark
• Avant la version 2.0.0, la classe utilisée est SparkSql
À noter bien
• Builder est une classe interne pour SparkSession.
• Cette dernière permet de gérér, créer et
configurer une session spark SQL
• Il dispose de :
• Constructeur sans argument
• appName pour fixer le nom de l’application
• Config pour fixer les options de la conf.
• getOrCreate pour retourner une session
Builder
DATASET ET DATAFRAME
11
• DataSet est une collection distribuée de données
• L’Api DataSet a été introduit dans Spark à partir
de la version 1.6.
• La dataSet est fortement typée.
• DataSet supporte des transformations basées sur
des paradigmes fonctionnels ou relationnels
• À l’image de la RDD, une DataSet dispose des
opérations de type transformation et Action.
• Une DataSet est paresseuse, par conséquent le
calcul se déclenche pour des opérations de type
action.
• L’API DataSet est disponible pour le langage
Scala et Java, pas pour Python
DataSet
• DataFrame est une DataSet avec des éléments
de type Row.
• Une DataFrame est l’équivalent d’une table dans
une base de données ou une dataFrame dans R
ou Python.
• Une DataFrame est non typée.
• Une DataFrame peut être construite à partir
d’une source de données structurées, des tables
Hive, des BD ou des RDDs.
• L’API DataFrame est disponible en Scala, Java,
Python et R.
DataFrame
L’API SPARK SQL s’articule autour de
de la notion de DataSet/DataFrame
DATAFRAME, CARACTÉRISTIQUES, FORMATS SUPPORTÉS, CRÉATION
12
Cinq manières de créer une DataFrame1. A partir d’une source de données2. À partir d’une RDD3. À partir d’une table BD4. A partir d’une table Hive5. Via une opération de
transformation
Création
La dataFrame supporte : des opérations de type transformation et
action. des opérateurs relationnels : select, where,
join, groupby. les langages Scala, Java, Python, R
Elle est : Orientée colonne Partionnée d’une évaluation paresseuse
DataSet = DataFrame[Row]
Caractéristique
In-MemoryImmutable
Lazyevaluated
Cacheable
Parallele
unTyped
Resilient DataFrame
Spark SQL supporte de charger oud’enregistrer des fichiers dansdivers formats : non structuré, semi-structuré, structuré.
Les formats sont :
o Texto Jsono CSVo Parqueto Orc
Formats fichiers
M.MICHRAFY
Partitioned
CHARGEMENT ET PERSISTANCES DES DONNÉES 1/2
13
• DataFrameReader a pour objectif de charger des DataSet à partir d’un système de stockage externe
tels qu’un système de fichier, une table relationnelle,
un stockage clé-valeur, etc.
• L’accès à cette classe se fait à partir d’une session
sparkSession via le membre read.
• Elle dispose des méthodes dédiées à des formats
de type TXT, JSON, Parquet, Orc, CSV. Pour cela,
utiliser les méthodes txt, json, orc, csv, parquet,
textFiles, jdbc…• Elle dispose aussi d’une méthode générique, notée
load, nécessitant la spécification du format, du
schéma et des options.• La majorité des méthodes de chargement
retournent des dataFrames à l’exception de la
méthode textFiles retourne une DataSet[String]
DataFrameReader
• DataFrameWriter permet de persister des DataSetdans un système de stockage externe tels qu’un
système de fichier, JDBS, HIVE, Stockage clé-valeur,
etc.
• L’accès à cette classe se fait à partir d’une session
sparkSession via le membre write.
• Cette classe dispose des méthodes :
• format : spécifier le format de données (json, txt,
parquet, orc, csv)
• modeSave : préciser le comportement lorsque
la donnée ou la table existe.
• Option(s) : ajouter une ou plusieurs options relative la source de données de sortie
• save : enregistrer le contenu de la dataFrame
• jdbc, csv, parquet, orc, txt : sont des méthodes pour enregistrer le contenu dans un format
spécifique.
DataFrameWriter
Dans la classe DataFrameReader (resp. DataFrameWriter), les méthodes csv, json,
orc, parquet, txt sont des cas particuliers de la méthodes load (resp. save).
DATAFRAMENAFUNCTIONS ET PRÉPARATION DES DONNÉES
14
• Il offre des fonctionnalités pour gérer les valeurs
manquantes dans une dataFrame.
• Une instance de cette classe peut être créée en
faisant appel à la méthode na de la dataSet.
• C’est une classe «final». Par conséquent, elle
n’est pas extensible
• Il fait partie du package org.apache.spark.sql
Caractéristiques
• Méthodes de type drop : elles permettent de supprimer des lignes ou des colonnes contenant
null or NaN, selon certains critères et retournent
une nouvelle dataFrame
• Méthodes de type fill : elles permettent de substituer certaines valeurs (nulles ou NaN) et
retournent une nouvelle DataFrame
• Méthodes de type replace : elles permettent de remplacer des occurrences de certaines
colonnes par d’autres.
Fonctionnalités
Une instance de cette classe est utile dans la
phase de préparation des données.
GRAPHE DE CONVERSION ENTRE LA RDD, DATAFRAME, DATASET
15
RDD DataFrame
DataSetCollection
Une RDD peut etre transformée en DataSet enutilisant la méthode toDS()
Une RDD peut être transformée en DataFrame en
utilisant la méthode toDF()
Une Collection peut être transformée en RDD enutilisant la méthode parallelize du sparkContext
Une Collection peut être transformée en DataSeten utilisant toDS()
Une collection peut être transformée enDataFrame en utilisant toDF()
Une DataFrame peut être transformée en DataSeten utilisant as[U](encoder)
Le contenu d’une DataSet/DataFrame peut êtrereprésentée par une RDD en utilisant le membrerdd de la DataSet.
16
Opérations sur les DataSet/DataFrame
• Cette section présente les différentes opérations relatives à une
DataFrame/DataSet :
1. Opération de type Action/transformations sur DataFrame/DataSet
2. Construction d’une DataFrame/DataSet3. Conversion entre DataSet/DataFrame/RDD/Collection
4. Opérations SQL
5. Opérations de nettoyage de données
(*) : Les exemple du code ont été exécutés avec spark-shell, version 2.0.2
M.MICHRAFY
DONNÉES UTILISÉES
17
Michael,
29Andy,
30Justin, 19
people.txt
{"name":"Michael"}
{"name":"Andy","age":30}
{"name":"Justin", "age":19}
people.json
Les deux fichiers people.txt et people.json sont livrés avec la distribution d’Apache
spark.
Le chemin pour accéder aux fichiers est :
PathSpark/examples/src/main/resources
Pour ne pas alourdir le code, nous notons “VotrPathSpark/people.json“ qui fait
référence à “ PathSpark/examples/src/main/resources/people.json”
SPARKSESSION : CREATION ET CONFIGURATION
SparkSession est le point d’entréepour le module Spark Sql
La création d’un objet SparkSession se
fait via l’objet builder qui est uneclasse interne de SparkSession
package : org.apache.spark.sql
Objectif
// importer sparkSession
import org.apache.spark.sql.SparkSession
/***
Créer sparkSession
Nommer l’application
Configurer l’application
en enfin retourner la session crée.
****/
// retour > spark: org.apache.spark.sql.SparkSession =
org.apache.spark.sql.SparkSession@5fd8dd66
val spark = SparkSession .builder()
.appName("Spark SQL")
.config("spark.some.config.option", "value")
.getOrCreate()
// afficher la version de spark
// retour > res1: String = 2.0.2
spark.version
Exemple
18
M.MICHRAFY
Importer le package SparkSession
Créer la session SparkSession
Afficher la version de spark
CRÉATION D’UNE DATAFRAME À PARTIR D’UNE SÉQUENCE
createDataFrame est une méthodede la classe SparkSession permettantde créer une dataFrame à partird’une collection.
Objectif
import org.apache.spark.sql.SparkSession // importer sparkSession
val spark = SparkSession .builder().getOrCreate() // créer une session
// créer des sequences : seqVilles
val seqVilles = Seq(("Paris", 2015, 8),("Paris", 2015, 8),("Lyon", 2016, 7),("Lyon",
2017, 1),("Lyon", 2016, 7))
// créer une dataFrame à partir de la séquence seqVilles
val dfVilles = spark.createDataFrame(seqVilles).toDF("ville", "annee", "mois")// dfVilles: org.apache.spark.sql.DataFrame = [ville: string, annee: int ... 1 more field]
dfVilles.printSchema // afficher le schéma de la dataFrame dfVilleroot|-- ville: string (nullable = true)|-- annee: integer (nullable = false)|-- mois: integer (nullable = false)
dfVilles.show() // afficher le contenu de la dataframe|ville|annee|mois||Paris| 2015 | 8||Paris| 2015 | 8|| Lyon| 2016| 7|| Lyon| 2017| 1|
| Lyon| 2016| 7|
Exemple
19
M.MICHRAFY
Importer le package SparkSession
Créer la session SparkSession
Créer la séquence
Créer la DataFrame à partir de la séquence
Afficher le schema de la dataFrame
Afficher le contenu de la dataFrame
DATAFRAME/DATAFRAMEREADER : CREATION À PARTIR D’UNE DATASOURCE
import org.apache.spark.sql.SparkSession // importer sparkSession
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
val dfReader = spark.read //Pointer la DataFrameReader// Retour > org.apache.spark.sql.DataFrameReader@a323a5b
// Créer des dataFrames via des fichier Json,
val dfJSON = dfReader.json("VotrPathSpark/people.json")// retour > df: org.apache.spark.sql.DataFrame = [age: bigint, name: string]
val dfCSV = dfReader.cvs("VotrPathSpark/people.txt")// retour > dfcsv: org.apache.spark.sql.DataFrame = [_c0: string, _c1: string]
val dfparquet = dfReader.parquet("VotrPathSpark/users.parquet")//retour > dfparquet: org.apache.spark.sql.DataFrame = [_c0: string, _c1: string ... 1 more field]
val dfTEXT = dfReader.txt("VotrPathSpark/people.txt")// retour > dfTXT: org.apache.spark.sql.DataFrame = [value: string]
// afficher le contenu des dataframes avec la methode show()
dfJSON.show()
dfCSV.show()
dfTEXT.show()
Exemple
20
M.MICHRAFY
SparkSession dispose d’un membrenoté read de type DataFrameReader
DataFrameReader permet decharger une dataFrame ou uneDataSet via :
• Un fichier format CSV
• Un fichier format TXT• Un fichier format JSON• Un fichier format Parquet• Un fichier format ORC• Une table JDBC
DataFrameReader permet aussi de
spécifier le shéma.
DataFrameReader
Créer la sessionSparkSession
Pointer le membreDataFrameReader
Charger le fichier JSON
LANCER DES REQUÊTES SQL SUR UNE VUE TEMPORAIRE
import org.apache.spark.sql.SparkSession // importer sparkSession
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
// Créer des dataFrames à partir d’un fichier Json,
val dfJSON = spark.read.json("VotrPathSpark/people.json")// retour > df: org.apache.spark.sql.DataFrame = [age: bigint, name: string]
/*****
créer une vue temporaire,
puis lancer des requetes sur la vue
****/
val sqlDfJson = dfJSON.createOrReplaceTempView("people") // créer la vue temp.
val sqlDF = spark.sql("SELECT * FROM people where age > 18") // interroger la vue//retour > sqlDF: org.apache.spark.sql.DataFrame = [age: bigint, name: string]
// afficher le contentu de la dataFrame sqlDF
sqlDF.show()Retour > |age| name|
| 30 | Andy || 19 |Justin |
Exemple
21
M.MICHRAFY
createOrReplaceTempViewest une méthode de DataSetpermettant de créer une vuepour exécuter des requêtesSQL.
La méthode sql de DataSetpermet d’interroger une vuetemporaire et retourne uneDataFrame
La vue temporaire estaccessible tant que la sessionSpark SQL est disponible.
Requête SQL
Créer la session SparkSession
Charger le fichier Json
Créer une vue temporaire
Lancer une requête sur la vue
Afficher le résultat de la requête
CONVERSION D’UNE COLLECTION EN UNE DATASET
import org.apache.spark.sql.SparkSession // importer sparkSession
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
//créer une classe case
Case class Person(name:String, age:Int)
//créer une dataSet
val ps = Seq(Person(”Alain", 30), Person("Stef", 19), Person("Sam", 25)).toDS()
//retour > ps: org.apache.spark.sql.Dataset[Person] = [name: string, age: bigint]
// afficher les noms des colonnes
ps. Columns
// retour > res1: Array[String] = Array(name, age)
// afficher le schèma de la dataSet
ps.schema
//Retour > res2: org.apache.spark.sql.types.StructType =
StructType(StructField(name,StringType,true), StructField(age,LongType,false))
// afficher le contenu de la dataSet dans un tableau
ps.collect()
// Retour >res3: Array[Person] = Array(Person(Andy,32), Person(Stef,19), Person(Sam,25))
Exemple
22
M.MICHRAFY
Spark SQL dispose des servicespermettant de convertir unecollection en DataSet
Ce mécanisme s’appuie surles encoders.
la méthode toDS() permet deconvertir un Collection versune DataSet.
Requête SQL
Créer la session SparkSession
Créer la classe case
Créer la dataSet
Afficher les nom des colonnes
Afficher le schéma
Afficher le contenu de la dataSet
CONVERSION UNE DATAFRAME EN UNE DATASET
import org.apache.spark.sql.SparkSession // importer sparkSession
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
// Créer la dataFrame à partir d’un fichier Json,
val dfjson = spark.read .json ("VotrPathSpark/people.json")
// retour > org.apache.spark.sql.DataFrame = [age: bigint, name: string]
dfjson.printSchema // afficher le schema de dfjson
// root
|-- age: long (nullable = true)
|-- name: string (nullable = true)
case class Person(name:String, age:Long) //créer une classe case
val DfTODS = dfjson.as[Person] //Convertir la DataFrame en une DataSet
//DfTODS: org.apache.spark.sql.Dataset[Personne] = [age: bigint, name: string]
DfTODS .schema
//Retour > org.apache.spark.sql.types.StructType =
StructType(StructField(age,LongType,true), StructField(name,StringType,true))
Exemple
23
M.MICHRAFY
En Spark SQL, il est possible deconvertir une DataFrame versune DataSet
Pour cela, il suffit d’utiliser laméthode as de la Dataframeavec le nom de la classe.
Requête SQL
Créer la session SparkSession
Créer la classe case
Créer la dataFrame
Afficher le schéma de la DataSet
Convertir la DataFrameen DataSet
CONVERSION D’UNE RDD EN DATAFRAME
import org.apache.spark.sql.SparkSession // importer sparkSession
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
// Créer une RDD à partir du fichier txt
val peopleRDD = spark.sparkContext
.textFile("VotrePathSpark/people.txt")
.map(_.split(","))
.map(attributes => Person(attributes(0), attributes(1).trim.toInt))
// retour > peopleRDD: org.apache.spark.rdd.RDD[Person] = MapPartitionsRDD[79]
peopleRDD.cache() // persister la RDD en mémoire
// retour > peopleRDD.type = MapPartitionsRDD[94] at map at <console>:31
//Convertir la RDD en DataFrame
val peopleDS = peopleRDD.toDF()
//retour > peopleDS: org.apache.spark.sql.DataFrame = [name: string, age: bigint]
peopleDS .show() // afficher le contenu de la dataFrame
| name |age|
|Michael| 29 |
| Andy | 30 |
| Justin | 19 |
Exemple
24
M.MICHRAFY
En Spark SQL, il est possible deconvertir une RDD en uneDataFrame
Pour ce faire, il suffit d’utiliserla méthode toDF de la RDD
Requête SQL
Créer la session SparkSession
Persister la RDD en mémoire
Créer la RDD
Afficher la DataFrame
Convertir la RDD en DataFrame
CONVERSION D’UNE RDD EN DATAFRAME : SPÉCIFIER LE SCHÉMA
import org.apache.spark.sql.{SparkSession, Row} // importer sparkSession, Row
import org.apache.spark.sql.types._
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
// Créer une RDD de type Row à partir du fichier txt
val peopleRDD = spark.sparkContext
.textFile("VotrePathSpark/people.txt")
.map(_.split(","))
.map(attributes => Row(attributes(0), attributes(1).trim.toInt))
// retour > peopleRDD: org.apache.spark.rdd.RDD[org.apache.spark.sql.Row] =
MapPartitionsRDD[111]
val schemaString = "name age"
val fields = schemaString.split(" ").map(w => StructField(w, StringType, nullable = true))
//retour > fields: Array[org.apache.spark.sql.types.StructField] =
Array(StructField(name,StringType,true), StructField(age,StringType,true))
val schema = StructType(fields)
//Convertir la RDD en DataFrame
val peopleDF = spark.createDataFrame(peopleRDD, schema)
// peopleDF: org.apache.spark.sql.DataFrame = [name: string, age: string]
Exemple
25
M.MICHRAFY
En Spark SQL, il est aussipossible de convertir une RDDde type Row en uneDataFrame en spécifiant leschéma.
createDataFrame est uneméthode de sparkSessionpermettant de créer uneDataFrame à partir d’une
RDD[Row] et le schémaassocié à Row
Requête SQL
Importer les packages
Créer la session SparkSession
Créer la RDD[Row]
Créer le schéma
Convertir la RDD en DataFrame
FONCTIONS GÉNÉRIQUES POUR LA CHARGEMENT ET LA PERSISTANCE
import org.apache.spark.sql.SparkSession // importer sparkSession
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
// charger le fichier people.json en utilisant la méthode generique load
val fgl = spark.read.format("json").load("VotrePathSpark/people.json")
//retour > org.apache.spark.sql.DataFrame = [age: bigint, name: string]
//afficher le contenu sous forme d’un tableau
flg.collect()
// retour > Array[org.apache.spark.sql.Row] = Array([null,Michael], [30,Andy], [19,Justin])
// importer SaveMode
import org.apache.spark.sql.SaveMode
//Persister le contenu de la dataframe en utilisant save
val fgs = fgl.write.format("parquet").mode(SaveMode.ErrorIfExists).save("people.parquet")
Exemple
26
M.MICHRAFY
Spark SQL dispose de deuxfonctions génériques pour lechargement ou la persistancedes données vers ou à partird’un système de stockageexterne.
load (Resp. save) est uneméthode de la classeDataFrameReader(respDataSet) pour charger (resp.Persister ) des données.
La méthode load nécessitede préciser le format desdonnées, alors que la
méthode save nécessite despécifier le mode desauvegarde.
mode est une méthode de lacalsse DataFrameWriter,permettant de spécifier lecomportement si le fichier oula table existe.
Load / Save
PERSISTER LE CONTENU D’UNE DATAFRAME
import org.apache.spark.sql.SparkSession // importer sparkSession
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
// créer une dataFrame
val villes = spark.createDataFrame(Seq(("Paris",2015,8),("Lyon",2015,8)
,("Toulon",2016,7))).toDF("ville","annee","mois")
//villes: org.apache.spark.sql.DataFrame = [ville: string, annee: int ... 1 more field]
// Persister le contenu en format json, csv et parquet
villes.write.json("villes.json")
villes.write.csv("villes.csv")
villes.write.parquet("villes.parquet")
Exemple
27
M.MICHRAFY
En Spark SQL, il est possible depersister le contenu d’unedataFrame en differentformat : format JSON, CSV,
PARQUET, …. La classe DataFrameWriter
dispose des méthodes json,csv, parquet pour persister lesdonnées.
Le membre write de ladataframe pointe sur un objetde type DataFrameWriter.
Persister un DF
EXÉCUTER UNE REQUÊTE SQL SUR UN FICHIER SOURCE
import org.apache.spark.sql.SparkSession // importer sparkSession
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
// Lancer une requête SQL sur un fichier json
val sqlJSON = spark.sql("SELECT * FROM json.`VotrePathSpark/people.json`")
// retour > sqlJSON: org.apache.spark.sql.DataFrame = [age: bigint, name: string]
// Lancer une requête SQL sur un fichier CSV
val sqlCSV = spark.sql("SELECT * FROM csv.`VotrePathSpark/people.txt`")
// retour > sqlCSV: org.apache.spark.sql.DataFrame = [_c0: string, _c1: string]
// Lancer une requête SQL sur un fichier parquet
val sqlParquet = spark.sql("SELECT * FROM parquet.`VotrePathSpark/users.parquet`")
// sqlParquet: org.apache.spark.sql.DataFrame = [name: string, favorite_color: string ... 1
more field]
Exemple
28
M.MICHRAFY
En Spark SQL, il est possible delancer une requête sur unfichier de format JSON, CSV,PARQUET, ….
Pour ce faire, il suffit d’utiliserla méthode sql de la classesparkSession.
Requête SQL
TYPAGE D’UNE COLONNE D’UNE DATAFRAME
import org.apache.spark.sql.SparkSession // importer sparkSession
import org.apache.spark.sql.functions._ // pour la fonction udf
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
// Charger un fichier csv
val dfcsv = spark.read.csv("VotrePathSpark/people.txt").toDF("nom", "age")
// dfcsv: org.apache.spark.sql.DataFrame = [nom: string, age: string]
val toInt = udf[Int, String]( _.trim().toInt) // toInt : supprimer le blanc, et convertir en entier
// appliquer la fonction toInt sur la colonne age de dfcsv
val dft = dfcn.withColumn("age", toInt(dfcn("age")))
// dft: org.apache.spark.sql.DataFrame = [name: string, age: int]
Dft.printSchema // afficher le schema de la dataframe dft
root
|-- name: string (nullable = true)
|-- age: integer (nullable = true)
Exemple
29
M.MICHRAFY
En Spark SQL dispose des outilspour accéder à une colonneet typer ses valeurs
withColumn est une méthoded’une dataSet permettant deremplacer une colonne.
La fonction udf permetd’appliquer une opération surles éléments d’une colonne.
Typage
DATAFRAME, CORRIGER LES DONNÉES
import org.apache.spark.sql.SparkSession // importer sparkSession
val spark = SparkSession .builder().getOrCreate() // Créer SparkSession
case class Personne(ville:String, nom:String, score:Double) // case classe
val x = Seq(Personne("Paris", "Stefan", 9), Personne("Lyon", "Alain", 15), Personne("Pariss",
null, 12)) // Créer une séquence de personnes
val dfx = spark.createDataFrame(x) // Créer une dataFrame via la séquence x
dfx.collect() // afficher le contenu de la dataframe dfx// Array[org.apache.spark.sql.Row] = Array([Paris,Stefan,9.0], [Lyon,Alain,15], [Pariss,null,12.0])
// remplacer null de la colonne « nom » par inconnu en utilisant la fonction fill
Val dfy = dfx.na.fill(Map("nom" -> "inconnu"))
// remplacer « pariss » par « paris », colonne « ville »
val dfz = dfy.na.replace("ville", Map("Pariss" -> "Paris"))
dfz.show() // afficher le contenu de la dataframe dfz|ville| nom|score||Paris| Stefan| 9.0|| Lyon| Alain| 15 ||Paris|inconnu| 12.0|
Exemple
30
M.MICHRAFY
DataFrameNaFunctionspermet de gérer les valeursmanquantes d’unedataFrame via les fonctions :
drop, fill, replace
na une méthode de laDataFrame permet
d’accéder un objet de typeDataFrameNaFunctions.
Typage
RÉFÉRENCES
Guide de programmation Spark SQL (http://spark.apache.org/docs/2.0.2/sql-
programming-guide.html)
API SPARK, langage Scala (http://spark.apache.org/docs/2.0.2/api/scala/index.html)
Spark SQL: Relational Data Processing in Spark
(http://people.csail.mit.edu/matei/papers/2015/sigmod_spark_sql.pdf)
31
DR MUSTAPHA MICHRAFY
CONTACT : [email protected]