Écrire dans des tableaux et créer des vues/blogs

Dans cet article de blog, nous verrons les méthodes d’écriture de Spark DataFrame dans des tableaux et de création de vues, pour les tâches essentielles de traitement et d’analyse des données.

Avant de plonger dans ce blog, jetez un œil à mes autres articles de blog traitant de la création du DataFrame et de la manipulation du DataFrame.

Base de données:

Le ci-dessous est l’ensemble de données que nous utiliserons pour rechercher l’écriture dans un tableau et créer des vues à partir de DataFrame.

Écriture de DataFrame dans des tables :

L’écriture dans Table nous permet d’exécuter des requêtes SQL sur les données et d’effectuer des analyses plus complexes. Spark prend en charge divers formats de stockage tels que Parquet, ORC et Delta Lake pour les DataFrames persistants.

insérer dans:

df.write.insertInto("table")

Le bloc de code ci-dessus est un exemple pour écrire un DataFrame dans une table. Nous devons avoir une méthode d’écriture mentionnant que nous allons écrire le DataFrame, puis la méthode insertInto pour écrire dans une table.

Écraser:

Par défaut, la méthode insertInto utilise le mode ajout pour charger les données dans une table. Nous pouvons modifier le mode de chargement en appelant la méthode .mode. Dans ce cadre, nous pouvons mentionner l’écrasement pour tronquer et recharger les données du nouveau df.

df.write.mode("overwrite").insertInto("table")

JDBC :

La méthode insertInto ci-dessus ne fonctionne que pour l’insertion dans la base de données interne dans le cas ci-dessus, il s’agit de Databricks. Alors que nous pouvons utiliser la connexion JDBC pour charger le DataFrame dans une base de données externe. Vous trouverez ci-dessous la syntaxe d’écriture de DataFrame à l’aide de JDBC.

df.write
    .format("jdbc")
    .option("url", "jdbc:postgresql:dbserver")
    .option("dbtable", "schema.tablename")
    .option("user", "username")
    .option("password", "password")
    .save()

enregistrer sous table :

La méthode insertInto peut être utilisée lors de l’écriture dans une table existante, tandis que saveAsTable peut être utilisée pour créer une nouvelle table à partir du DataFrame.

df.write.saveAsTable("table")

Ce qui précède est le résultat de l’écriture du DataFrame dans une table et de la lecture de SQL.

saveAsTable Écraser :

Lorsque nous essayons d’utiliser saveAsTable avec une table existante, nous pourrions nous retrouver avec une exception indiquant que la table existe déjà. Dans ce cas, .mode(« overwrite ») peut être utilisé pour écraser la table existante avec le nouveau DataFrame.

Création de vues à partir de DataFrame :

En plus de conserver les DataFrames sous forme de tables, nous pouvons créer des vues temporaires qui n’existent que pour la durée de la SparkSession. Les vues temporaires sont utiles pour exécuter des requêtes SQL sans avoir besoin de conserver les données de manière permanente.

Spark createTempView :

Vous trouverez ci-dessous la syntaxe pour créer une vue temporaire à partir d’un DataFrame.

df.createTempView("view")

Spark createOrReplaceTempView :

Semblable à saveAsTable, si nous utilisons le même nom de vue pour deux vues de création, nous obtiendrons une exception selon laquelle la table temporaire existe déjà.

Dans ce cas, nous pouvons utiliser createOrReplaceTempView au lieu de createTempView qui remplacera la vue existante par les données du nouveau DataFrame.

Spark créerGlobalTempView :

Cette méthode crée une vue temporaire de portée globale. Cela signifie que la vue existera dans toutes les sessions et même après la fin de l’application Spark qui l’a créée.

df.createGlobalTempView("global_view")

Semblable à createOrReplaceTempView, la vue globale a également une syntaxe similaire pour remplacer la vue temporaire globale.

df.createOrReplaceGlobalTempView("global_view")

Les références:

Vous trouverez ci-dessous les documents Spark qui explorent davantage l’écriture du DataFrame dans des tables et des vues.

Dans cet article de blog, nous avons appris à écrire des DataFrames dans des tables en utilisant différents formats de stockage et à créer des vues temporaires pour une analyse ad hoc.