Accès aux données dans les notebooks Jupyterlab
Créé pour :
- Utilisateur ou utilisatrice
- Développeur
NOTEChaque noyau pris en charge fournit des fonctionnalités intégrées qui vous permettent de lire les données d’Experience Platform à partir d’un jeu de données dans un notebook . Actuellement, JupyterLab dans Adobe Experience Platform Data Science Workspace prend en charge les notebooks pour Python, R, PySpark et Scala. Toutefois, la prise en charge de la pagination des données se limite aux notebooks Python et R. Ce guide explique comment utiliser les notebooks JupyterLab pour accéder à vos données.
Commencer
Avant de lire ce guide, veuillez consulter le JupyterLab guide de l’utilisateur pour une présentation détaillée du JupyterLab et de son rôle dans le Workspace de science des données.
Limites de données des notebooks
IMPORTANTLes informations suivantes définissent la quantité maximale de données pouvant être lues, le type de données utilisées et le délai estimé de lecture des données.
Pour Python et R, un serveur pour ordinateurs portables configuré à 40 Go de RAM a été utilisé pour les références. Pour PySpark et Scala, un cluster de briques de données configuré à 64 Go de RAM, 8 cœurs, 2 DBU avec un maximum de 4 travailleurs a été utilisé pour les références décrites ci-dessous.
La taille des données de schéma ExperienceEvent utilisées varie de mille (1K) lignes à un milliard (1B) de lignes. Notez que pour les mesures PySpark et Spark, une période de 10 jours a été utilisée pour les données XDM.
Les données de schéma ad hoc ont été prétraitées à l’aide de Query Service Create Table as Select (CTAS). Ces données variaient également en taille à partir de mille (1K) lignes allant jusqu'à un milliard (1B) lignes.
Quand utiliser le mode batch ou interactif ?
Lors de la lecture de jeux de données avec des notebooks PySpark et Scala, vous avez la possibilité d’utiliser le mode interactif ou le mode batch pour lire le jeu de données. L’interactif est conçu pour des résultats rapides, tandis que le mode batch est conçu pour les jeux de données volumineux.
Python des limites de données des notebooks
Schéma XDM ExperienceEvent : vous devriez être en mesure de lire un maximum de 2 millions de lignes (environ 6,1 Go de données sur le disque) de données XDM en moins de 22 minutes. L’ajout de lignes supplémentaires peut entraîner des erreurs.
schéma ad hoc : vous devriez être en mesure de lire un maximum de 5 millions de lignes (~5,6 Go de données sur le disque) de données non XDM (ad hoc) en moins de 14 minutes. L’ajout de lignes supplémentaires peut entraîner des erreurs.
Limites de données des notebooks R
Schéma XDM ExperienceEvent : vous devriez être en mesure de lire un maximum de 1 million de lignes de données XDM (3 Go de données sur le disque) en moins de 13 minutes.
schéma ad hoc : vous devriez être en mesure de lire un maximum de 3 millions de lignes de données ad hoc (données 293MB sur le disque) en 10 minutes environ.
Limites de données des notebooks PySpark (noyau Python) :
Schéma XDM ExperienceEvent : en mode interactif, vous devriez être en mesure de lire un maximum de 5 millions de lignes (environ 13,42 Go de données sur le disque) de données XDM en 20 minutes environ. Le mode interactif ne prend en charge que 5 millions de lignes au maximum. Si vous souhaitez lire des jeux de données plus volumineux, il est suggéré de passer en mode batch. En mode batch, vous devriez être en mesure de lire un maximum de 500 millions de lignes (environ 1,31 To de données sur le disque) de données XDM en environ 14 heures.
schéma ad hoc : en mode interactif, vous devriez être en mesure de lire un maximum de 5 millions de lignes (environ 5,36 Go de données sur le disque) de données non XDM en moins de 3 minutes. En mode Lot, vous devriez être en mesure de lire un maximum de 1 milliard de lignes (environ 1,05 To de données sur le disque) de données non XDM en environ 18 minutes.
Limites de données des notebooks Spark (noyau Scala) :
Schéma XDM ExperienceEvent : en mode interactif, vous devriez être en mesure de lire un maximum de 5 millions de lignes (environ 13,42 Go de données sur le disque) de données XDM en 18 minutes environ. Le mode interactif ne prend en charge que 5 millions de lignes au maximum. Si vous souhaitez lire des jeux de données plus volumineux, il est suggéré de passer en mode batch. En mode batch, vous devriez être en mesure de lire un maximum de 500 millions de lignes (environ 1,31 To de données sur le disque) de données XDM en environ 14 heures.
schéma ad hoc : en mode interactif, vous devriez être en mesure de lire un maximum de 5 millions de lignes (environ 5,36 Go de données sur le disque) de données non XDM en moins de 3 minutes. En mode batch, vous devriez être en mesure de lire un maximum de 1 milliard de lignes (environ 1,05 To de données sur le disque) de données non XDM en environ 16 minutes.
Notebooks Python
Python notebooks vous permettent de paginer les données lors de l’accès aux jeux de données. L’exemple de code pour lire les données avec et sans pagination est illustré ci-dessous. Pour plus d’informations sur les notebooks Python de démarrage disponibles, consultez la section JupyterLab Launcher dans le guide d’utilisation de JupyterLab.
La documentation Python ci-dessous décrit les concepts suivants :
Lecture à partir d'un jeu de données en Python
Sans pagination :
L’exécution du code suivant lit le jeu de données complet. Si l’exécution est réussie, les données sont enregistrées sous la forme d’un cadre de données pandas référencé par la variable df.
# Python
from platform_sdk.dataset_reader import DatasetReader
dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.read()
df.head()
Avec pagination :
L’exécution du code suivant lit les données du jeu de données spécifié. La pagination est obtenue en limitant et en décalant les données à l’aide des fonctions limit() et offset() respectivement. La limitation des données fait référence au nombre maximal de points de données à lire, tandis que le décalage fait référence au nombre de points de données à ignorer avant la lecture des données. Si l’opération de lecture s’exécute correctement, les données sont enregistrées sous la forme d’un cadre de données pandas référencé par la variable df.
# Python
from platform_sdk.dataset_reader import DatasetReader
dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.limit(100).offset(10).read()
Écrire dans un jeu de données en Python
Pour écrire dans un jeu de données dans votre notebook JupyterLab, sélectionnez l’onglet Icône de données (mis en surbrillance ci-dessous) dans le volet de navigation de gauche de JupyterLab. Les jeux de données et les répertoires de schémas s’affichent. Sélectionnez Jeux de données puis cliquez avec le bouton droit de la souris. Sélectionnez ensuite l’option Écrire des données dans Notebook dans le menu déroulant du jeu de données que vous souhaitez utiliser. Une entrée de code exécutable s’affiche au bas de votre notebook.
- Utilisez Write Data in Notebook pour générer une cellule d’écriture avec le jeu de données sélectionné.
- Utilisez Explorer des données dans Notebook pour générer une cellule de lecture avec le jeu de données sélectionné.
- Utilisez Query Data in Notebook pour générer une cellule de requête de base avec le jeu de données sélectionné.
Vous pouvez également copier et coller la cellule de code suivante. Remplacez les {DATASET_ID} et les {PANDA_DATAFRAME}.
from platform_sdk.models import Dataset
from platform_sdk.dataset_writer import DatasetWriter
dataset = Dataset(get_platform_sdk_client_context()).get_by_id(dataset_id="{DATASET_ID}")
dataset_writer = DatasetWriter(get_platform_sdk_client_context(), dataset)
write_tracker = dataset_writer.write({PANDA_DATAFRAME}, file_format='json')
Interroger des données à l’aide de Query Service dans Python
JupyterLab sur Experience Platform vous permet d’utiliser SQL dans un notebook Python pour accéder aux données via Adobe Experience Platform Query Service. L’accès aux données par le biais de Query Service peut s’avérer utile pour la gestion de jeux de données volumineux grâce à ses temps d’exécution plus performants. Notez que l’interrogation de données à l’aide de Query Service est limitée à dix minutes de traitement.
Avant d’utiliser Query Service dans JupyterLab, assurez-vous de bien comprendre le fonctionnement de la syntaxe SQL de Query Service.
L’interrogation de données à l’aide de Query Service nécessite que vous fournissiez le nom du jeu de données cible. Vous pouvez générer les cellules de code nécessaires en recherchant le jeu de données souhaité à l’aide de l’explorateur de données. Cliquez avec le bouton droit sur la liste des jeux de données et cliquez sur Requête de données dans Notebook pour générer deux cellules de code dans votre notebook. Ces deux cellules sont décrites plus en détail ci-dessous.
Pour utiliser Query Service dans JupyterLab, vous devez d’abord créer une connexion entre votre notebook Python de travail et Query Service. Pour ce faire, exécutez la première cellule générée.
qs_connect()
Dans la seconde cellule générée, la première ligne doit être définie avant la requête SQL. Par défaut, la cellule générée définit une variable facultative (df0) qui enregistre les résultats des requêtes sous la forme d’un cadre de données pandas.
L’argument -c QS_CONNECTION est obligatoire et indique au noyau d’exécuter la requête SQL sur Query Service. Consultez l’annexe pour obtenir une liste d’arguments supplémentaires.
%%read_sql df0 -c QS_CONNECTION
SELECT *
FROM name_of_the_dataset
LIMIT 10
/* Querying table "name_of_the_dataset" (datasetId: {DATASET_ID})*/
Vous pouvez référencer les variables Python directement dans une requête SQL en utilisant une syntaxe au format chaîne et en mettant les variables entre accolades ({}), comme indiqué dans l’exemple suivant :
table_name = 'name_of_the_dataset'
table_columns = ','.join(['col_1','col_2','col_3'])
%%read_sql demo -c QS_CONNECTION
SELECT {table_columns}
FROM {table_name}
Filtrer ExperienceEvent données
Pour accéder à un jeu de données ExperienceEvent et le filtrer dans un notebook Python, vous devez fournir l’identifiant du jeu de données ({DATASET_ID}) ainsi que les règles de filtrage qui définissent une période spécifique à l’aide d’opérateurs logiques. Lorsqu’un intervalle de temps est défini, toute pagination spécifiée est ignorée et le jeu de données complet est pris en compte.
Une liste d’opérateurs de filtrage est décrite ci-dessous :
eq(): égal àgt(): supérieur àge(): supérieur ou égal àlt(): inférieur àle(): inférieur ou égal àAnd(): opérateur ET logiqueOr(): opérateur OU logique
La cellule suivante filtre un jeu de données ExperienceEvent sur les données existant exclusivement entre le 1er janvier 2019 et la fin du 31 décembre 2019.
# Python
from platform_sdk.dataset_reader import DatasetReader
dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.\
where(dataset_reader["timestamp"].gt("2019-01-01 00:00:00").\
And(dataset_reader["timestamp"].lt("2019-12-31 23:59:59"))\
).read()
Notebooks R
Les notebooks R vous permettent de paginer les données lors de l’accès aux jeux de données. L’exemple de code pour lire les données avec et sans pagination est illustré ci-dessous. Pour plus d’informations sur les notebooks starter R disponibles, consultez la section JupyterLab Launcher dans le guide d’utilisation de JupyterLab.
La documentation en R ci-dessous présente les concepts suivants :
Lecture à partir d’un jeu de données dans R
Sans pagination :
L’exécution du code suivant lit le jeu de données complet. Si l’exécution est réussie, les données sont enregistrées sous la forme d’un cadre de données pandas référencé par la variable df0.
# R
library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")
DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df0 <- dataset_reader$read()
head(df0)
Avec pagination :
L’exécution du code suivant lit les données du jeu de données spécifié. La pagination est obtenue en limitant et en décalant les données à l’aide des fonctions limit() et offset() respectivement. La limitation des données fait référence au nombre maximal de points de données à lire, tandis que le décalage fait référence au nombre de points de données à ignorer avant la lecture des données. Si l’opération de lecture s’exécute correctement, les données sont enregistrées sous la forme d’un cadre de données pandas référencé par la variable df0.
# R
library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")
DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df0 <- dataset_reader$limit(100L)$offset(10L)$read()
Écrire dans un jeu de données dans R
Pour écrire dans un jeu de données dans votre notebook JupyterLab, sélectionnez l’onglet Icône de données (mis en surbrillance ci-dessous) dans le volet de navigation de gauche de JupyterLab. Les jeux de données et les répertoires de schémas s’affichent. Sélectionnez Jeux de données puis cliquez avec le bouton droit de la souris. Sélectionnez ensuite l’option Écrire des données dans Notebook dans le menu déroulant du jeu de données que vous souhaitez utiliser. Une entrée de code exécutable s’affiche au bas de votre notebook.
- Utilisez Write Data in Notebook pour générer une cellule d’écriture avec le jeu de données sélectionné.
- Utilisez Explorer des données dans Notebook pour générer une cellule de lecture avec le jeu de données sélectionné.
Vous pouvez également copier et coller la cellule de code suivante :
psdk <- import("platform_sdk")
dataset <- psdk$models$Dataset(py$get_platform_sdk_client_context())$get_by_id(dataset_id="{DATASET_ID}")
dataset_writer <- psdk$dataset_writer$DatasetWriter(py$get_platform_sdk_client_context(), dataset)
write_tracker <- dataset_writer$write(df, file_format='json')
Filtrer ExperienceEvent données
Pour accéder à un jeu de données ExperienceEvent et le filtrer dans un notebook R, vous devez fournir l’identifiant du jeu de données ({DATASET_ID}) ainsi que les règles de filtrage qui définissent une période spécifique à l’aide d’opérateurs logiques. Lorsqu’un intervalle de temps est défini, toute pagination spécifiée est ignorée et le jeu de données complet est pris en compte.
Une liste d’opérateurs de filtrage est décrite ci-dessous :
eq(): égal àgt(): supérieur àge(): supérieur ou égal àlt(): inférieur àle(): inférieur ou égal àAnd(): opérateur ET logiqueOr(): opérateur OU logique
La cellule suivante filtre un jeu de données ExperienceEvent sur les données existant exclusivement entre le 1er janvier 2019 et la fin du 31 décembre 2019.
# R
library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")
client_context <- py$PLATFORM_SDK_CLIENT_CONTEXT
DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df0 <- dataset_reader$
where(dataset_reader["timestamp"]$gt("2019-01-01 00:00:00")$
And(dataset_reader["timestamp"]$lt("2019-12-31 23:59:59"))
)$read()
PySpark 3 notebooks
La documentation de PySpark ci-dessous décrit les concepts suivants :
Initialisation de sparkSession
Tous les notebooks Spark 2.4 nécessitent que vous initialisiez la session avec le code standard suivant.
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
Utilisation de %dataset pour lire et écrire avec un notebook PySpark 3
Avec l’introduction d’Spark 2.4, %dataset magie personnalisée est disponible pour une utilisation dans les notebooks PySpark 3 (Spark 2.4). Pour plus d'informations sur les commandes magiques disponibles dans le noyau IPython, consultez la documentation magique IPython.
Utilisation
%dataset {action} --datasetId {id} --dataFrame {df} --mode batch
Description
Commande magique Data Science Workspace personnalisée pour lire ou écrire un jeu de données à partir d’un notebook PySpark (noyau Python 3).
{action}--datasetId {id}--dataFrame {df}Le Dataframe Pandas.
- Lorsque l’action est « read », {df} est la variable dans laquelle les résultats de l’opération de lecture du jeu de données sont disponibles (comme un Dataframe).
- Lorsque l’action est « write », ce {df} de cadre de données est écrit dans le jeu de données.
--modeIl est recommandé d’utiliser le mode « interactif » pour améliorer les performances des requêtes sur des jeux de données plus petits.
TIPmode doit être défini sur interactive ou batch.Exemples
- Lire l'exemple :
%dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0 --mode batch - Exemple d’écriture :
%dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0 --mode batch
IMPORTANTdf.cache() avant l’écriture des données peut améliorer considérablement les performances des notebooks. Cela peut s’avérer utile si vous recevez l’une des erreurs suivantes :- Tâche abandonnée en raison d’un échec de test … Peut uniquement compresser les RDD avec le même nombre d’éléments dans chaque partition.
- Client RPC distant dissocié et autres erreurs de mémoire.
- Mauvaises performances lors de la lecture et de l’écriture de jeux de données.
Vous pouvez générer automatiquement les exemples ci-dessus dans JupyterLab, mais en utilisant la méthode suivante :
Sélectionnez l’onglet Icône de données (mis en surbrillance ci-dessous) dans le volet de navigation de gauche de JupyterLab. Les jeux de données et les répertoires de schémas s’affichent. Sélectionnez Jeux de données puis cliquez avec le bouton droit de la souris. Sélectionnez ensuite l’option Écrire des données dans Notebook dans le menu déroulant du jeu de données que vous souhaitez utiliser. Une entrée de code exécutable s’affiche au bas de votre notebook.
- Utilisez Explorer les données dans Notebook pour générer une cellule de lecture.
- Utilisez Write Data in Notebook pour générer une cellule d’écriture.
Créer un Dataframe local
Pour créer un Dataframe local à l’aide de PySpark 3, utilisez des requêtes SQL. Par exemple :
date_aggregation.createOrReplaceTempView("temp_df")
df = spark.sql('''
SELECT *
FROM sparkdf
''')
local_df
df = spark.sql('''
SELECT *
FROM sparkdf
LIMIT limit
''')
sample_df = df.sample(fraction)
Filtrer ExperienceEvent données
Pour accéder à un jeu de données ExperienceEvent et le filtrer dans un notebook PySpark, vous devez fournir l’identité du jeu de données ({DATASET_ID}), l’identité IMS de votre organisation et les règles de filtrage définissant une période spécifique. Une période de filtrage est définie à l’aide de la fonction spark.sql(), où le paramètre de fonction est une chaîne de requête SQL.
Les cellules suivantes filtrent un jeu de données ExperienceEvent sur les données existant exclusivement entre le 1er janvier 2019 et la fin du 31 décembre 2019.
# PySpark 3 (Spark 2.4)
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
%dataset read --datasetId {DATASET_ID} --dataFrame df --mode batch
df.createOrReplaceTempView("event")
timepd = spark.sql("""
SELECT *
FROM event
WHERE timestamp > CAST('2019-01-01 00:00:00.0' AS TIMESTAMP)
AND timestamp < CAST('2019-12-31 23:59:59.9' AS TIMESTAMP)
""")
timepd.show()
Notebooks Scala
La documentation ci-dessous contient des exemples pour les concepts suivants :
Initialisation de SparkSession
Tous les notebooks Scala nécessitent d’initialiser la session avec le code standard suivant :
import org.apache.spark.sql.{ SparkSession }
val spark = SparkSession
.builder()
.master("local")
.getOrCreate()
Lire un jeu de données
Dans Scala, vous pouvez importer des clientContext pour obtenir et renvoyer des valeurs Experience Platform, ce qui élimine la nécessité de définir des variables telles que var userToken. Dans l’exemple Scala ci-dessous, clientContext est utilisé pour obtenir et renvoyer toutes les valeurs requises nécessaires à la lecture d’un jeu de données.
IMPORTANTdf.cache() avant l’écriture des données peut améliorer considérablement les performances des notebooks. Cela peut s’avérer utile si vous recevez l’une des erreurs suivantes :- Tâche abandonnée en raison d’un échec de test … Peut uniquement compresser les RDD avec le même nombre d’éléments dans chaque partition.
- Client RPC distant dissocié et autres erreurs de mémoire.
- Mauvaises performances lors de la lecture et de l’écriture de jeux de données.
import org.apache.spark.sql.{Dataset, SparkSession}
import com.adobe.platform.token.ClientContext
val spark = SparkSession.builder().master("local").config("spark.sql.warehouse.dir", "/").getOrCreate()
val clientContext = ClientContext.getClientContext()
val df1 = spark.read.format("com.adobe.platform.query")
.option("user-token", clientContext.getUserToken())
.option("ims-org", clientContext.getOrgId())
.option("api-key", clientContext.getApiKey())
.option("service-token", clientContext.getServiceToken())
.option("sandbox-name", clientContext.getSandboxName())
.option("mode", "batch")
.option("dataset-id", "5e68141134492718af974844")
.load()
df1.printSchema()
df1.show(10)
clientContext.getUserToken().clientContext.getServiceToken().clientContext.getOrgId().clientContext.getApiKey().TIPmode doit être défini sur interactive ou batch.Vous pouvez générer automatiquement l’exemple ci-dessus dans JupyterLab à l’aide de la méthode suivante :
Sélectionnez l’onglet Icône de données (mis en surbrillance ci-dessous) dans le volet de navigation de gauche de JupyterLab. Les jeux de données et les répertoires de schémas s’affichent. Sélectionnez Jeux de données puis cliquez avec le bouton droit de la souris. Sélectionnez ensuite l’option Exploration des données dans Notebook dans le menu déroulant du jeu de données que vous souhaitez utiliser. Une entrée de code exécutable s’affiche au bas de votre notebook.
Et
- Utilisez Explorer les données dans Notebook pour générer une cellule de lecture.
- Utilisez Write Data in Notebook pour générer une cellule d’écriture.
Écrire dans un jeu de données
Dans Scala, vous pouvez importer des clientContext pour obtenir et renvoyer des valeurs Experience Platform, ce qui élimine la nécessité de définir des variables telles que var userToken. Dans l’exemple Scala ci-dessous, clientContext est utilisé pour définir et renvoyer toutes les valeurs requises nécessaires pour écrire dans un jeu de données.
IMPORTANTdf.cache() avant l’écriture des données peut améliorer considérablement les performances des notebooks. Cela peut s’avérer utile si vous recevez l’une des erreurs suivantes :- Tâche abandonnée en raison d’un échec de test … Peut uniquement compresser les RDD avec le même nombre d’éléments dans chaque partition.
- Client RPC distant dissocié et autres erreurs de mémoire.
- Mauvaises performances lors de la lecture et de l’écriture de jeux de données.
import org.apache.spark.sql.{Dataset, SparkSession}
import com.adobe.platform.token.ClientContext
val spark = SparkSession.builder().master("local").config("spark.sql.warehouse.dir", "/").getOrCreate()
val clientContext = ClientContext.getClientContext()
df1.write.format("com.adobe.platform.query")
.option("user-token", clientContext.getUserToken())
.option("service-token", clientContext.getServiceToken())
.option("ims-org", clientContext.getOrgId())
.option("api-key", clientContext.getApiKey())
.option("sandbox-name", clientContext.getSandboxName())
.option("mode", "batch")
.option("dataset-id", "5e68141134492718af974844")
.save()
clientContext.getUserToken().clientContext.getServiceToken().clientContext.getOrgId().clientContext.getApiKey().TIPmode doit être défini sur interactive ou batch.créer un Dataframe local
Pour créer un cadre de données local à l’aide de Scala, des requêtes SQL sont requises. Par exemple :
sparkdf.createOrReplaceTempView("sparkdf")
val localdf = spark.sql("SELECT * FROM sparkdf LIMIT 1)
Filtrer ExperienceEvent données
Pour accéder à un jeu de données ExperienceEvent et le filtrer dans un notebook Scala, vous devez fournir l’identité du jeu de données ({DATASET_ID}), l’identité IMS de votre organisation et les règles de filtrage définissant une période spécifique. Un intervalle de temps de filtrage est défini à l’aide de la fonction spark.sql(), où le paramètre de fonction est une chaîne de requête SQL.
Les cellules suivantes filtrent un jeu de données ExperienceEvent sur les données existant exclusivement entre le 1er janvier 2019 et la fin du 31 décembre 2019.
// Spark (Spark 2.4)
// Turn off extra logging
import org.apache.log4j.{Level, Logger}
Logger.getLogger("org").setLevel(Level.OFF)
Logger.getLogger("com").setLevel(Level.OFF)
import org.apache.spark.sql.{Dataset, SparkSession}
val spark = org.apache.spark.sql.SparkSession.builder().appName("Notebook")
.master("local")
.getOrCreate()
// Stage Exploratory
val dataSetId: String = "{DATASET_ID}"
val orgId: String = sys.env("IMS_ORG_ID")
val clientId: String = sys.env("PYDASDK_IMS_CLIENT_ID")
val userToken: String = sys.env("PYDASDK_IMS_USER_TOKEN")
val serviceToken: String = sys.env("PYDASDK_IMS_SERVICE_TOKEN")
val mode: String = "batch"
var df = spark.read.format("com.adobe.platform.query")
.option("user-token", userToken)
.option("ims-org", orgId)
.option("api-key", clientId)
.option("mode", mode)
.option("dataset-id", dataSetId)
.option("service-token", serviceToken)
.load()
df.createOrReplaceTempView("event")
val timedf = spark.sql("""
SELECT *
FROM event
WHERE timestamp > CAST('2019-01-01 00:00:00.0' AS TIMESTAMP)
AND timestamp < CAST('2019-12-31 23:59:59.9' AS TIMESTAMP)
""")
timedf.show()
Étapes suivantes
Ce document couvrait les directives générales pour l’accès aux jeux de données à l’aide des notebooks JupyterLab. Pour obtenir des exemples plus détaillés sur l’interrogation de jeux de données, consultez la documentation de Query Service dans les notebooks JupyterLab. Pour plus d’informations sur l’exploration et la visualisation de vos jeux de données, consultez le document sur l’analyse de vos données à l’aide de notebooks.
Indicateurs SQL facultatifs pour Query Service
Ce tableau décrit les indicateurs SQL facultatifs qui peuvent être utilisés pour Query Service.
-h, --help-n, --notify-a, --async-d, --display