Ogni kernel supportato fornisce funzionalità integrate che consentono di leggere i dati di Platform da un set di dati all’interno di un blocco appunti. Attualmente JupyterLab in Adobe Experience Platform Data Science Workspace supporta i notebook per Python, R, PySpark e Scala. Tuttavia, il supporto per i dati di impaginazione è limitato a Python e notebook R. Questa guida si concentra su come utilizzare i notebook JupyterLab per accedere ai dati.
Prima di leggere questa guida, consulta la sezione JupyterLab guida utente per un’introduzione di alto livello a JupyterLab e il suo ruolo in Data Science Workspace.
Per i notebook PySpark e Scala se si riceve un errore con il motivo "Client RPC remoto disassociato". In genere significa che la memoria del driver o dell'esecutore è esaurita. Prova a passare a modalità "batch" per risolvere questo errore.
Le informazioni seguenti definiscono la quantità massima di dati leggibili, il tipo di dati utilizzato e il periodo di tempo stimato necessario per la lettura dei dati.
Per Python e R, un notebook server configurato a 40 GB di RAM è stato utilizzato per i benchmark. Per PySpark e Scala, è stato utilizzato un cluster di database configurato a 64 GB di RAM, 8 core, 2 DBU con un massimo di 4 dipendenti per i benchmark descritti di seguito.
I dati dello schema ExperienceEvent utilizzati variano a partire da mille (1K) righe che variano fino a un miliardo di righe (1B). Tieni presente che per PySpark e Spark per i dati XDM è stato utilizzato un intervallo di date di 10 giorni.
I dati dello schema ad hoc sono stati preelaborati utilizzando Query Service Crea tabella come selezione (CTAS). Questi dati sono anche variati in dimensioni a partire da mille (1K) righe che vanno fino a un miliardo (1B) righe.
Quando si leggono i set di dati con i blocchi appunti PySpark e Scala, è possibile utilizzare la modalità interattiva o la modalità batch per leggere il set di dati. La modalità interattiva viene eseguita per risultati rapidi, mentre la modalità batch è per set di dati di grandi dimensioni.
Schema ExperienceEvent XDM: Dovresti essere in grado di leggere un massimo di 2 milioni di righe (circa 6,1 GB di dati su disco) di dati XDM in meno di 22 minuti. L’aggiunta di righe aggiuntive potrebbe causare errori.
Numero di righe | 1K | 10K | 100.000 | 1M | 2M |
---|---|---|---|---|---|
Dimensioni su disco (MB) | 18.73 | 187.5 | 308 | 3000 | 6050 |
SDK (in secondi) | 20.3 | 86.8 | 63 | 659 | 1315 |
schema ad hoc: Dovresti essere in grado di leggere un massimo di 5 milioni di righe (~5,6 GB di dati su disco) di dati non XDM (ad-hoc) in meno di 14 minuti. L’aggiunta di righe aggiuntive potrebbe causare errori.
Numero di righe | 1K | 10K | 100.000 | 1M | 2M | 3M | 5M |
---|---|---|---|---|---|---|---|
Dimensioni su disco (in MB) | 1.21 | 11.72 | 115 | 1120 | 2250 | 3380 | 5630 |
SDK (in secondi) | 7.27 | 9.04 | 27.3 | 180 | 346 | 487 | 819 |
Schema ExperienceEvent XDM: Dovresti essere in grado di leggere un massimo di 1 milione di righe di dati XDM (dati da 3 GB su disco) in meno di 13 minuti.
Numero di righe | 1K | 10K | 100.000 | 1M |
---|---|---|---|---|
Dimensioni su disco (MB) | 18.73 | 187.5 | 308 | 3000 |
R Kernel (in secondi) | 14.03 | 69.6 | 86.8 | 775 |
schema ad hoc: Dovresti essere in grado di leggere un massimo di 3 milioni di righe di dati ad hoc (293 MB di dati su disco) in circa 10 minuti.
Numero di righe | 1K | 10K | 100.000 | 1M | 2M | 3M |
---|---|---|---|---|---|---|
Dimensioni su disco (in MB) | 0.082 | 0.612 | 9.0 | 91 | 188 | 293 |
SDK R (in secondi) | 7.7 | 4.58 | 35.9 | 233 | 470.5 | 603 |
Schema ExperienceEvent XDM: In modalità interattiva è necessario essere in grado di leggere un massimo di 5 milioni di righe (~13,42 GB di dati su disco) di dati XDM in circa 20 minuti. La modalità interattiva supporta solo fino a 5 milioni di righe. Se desideri leggere set di dati più grandi, ti consigliamo di passare alla modalità batch. In modalità batch è necessario essere in grado di leggere un massimo di 500 milioni di righe (~1,31 TB di dati su disco) di dati XDM in circa 14 ore.
Numero di righe | 1K | 10K | 100.000 | 1M | 2M | 3M | 5M | 10M | 50M | 100M | 500M |
---|---|---|---|---|---|---|---|---|---|---|---|
Dimensioni su disco | 2.93MB | 4.38MB | 29.02 | 2.69 GB | 5.39 GB | 8.09 GB | 13.42 GB | 26.82 GB | 134.24 GB | 268.39 GB | 1.31TB |
SDK (modalità interattiva) | 33s | 32.4s | 55.1s | 253.5s | 489.2s | 729.6s | 1206.8s | - | - | - | - |
SDK (modalità Batch) | 815.8s | 492.8s | 379.1s | 637.4s | 624.5s | 869.2s | 1104.1s | 1786s | 5387.2s | 10624.6s | 50547s |
schema ad hoc: In modalità interattiva è necessario essere in grado di leggere un massimo di 5 milioni di righe (~5,36 GB di dati su disco) di dati non XDM in meno di 3 minuti. In modalità Batch dovresti essere in grado di leggere un massimo di 1 miliardo di righe (~1,05 TB di dati su disco) di dati non XDM in circa 18 minuti.
Numero di righe | 1K | 10K | 100.000 | 1M | 2M | 3M | 5M | 10M | 50M | 100M | 500M | 1B |
---|---|---|---|---|---|---|---|---|---|---|---|---|
Dimensioni su disco | 1.12MB | 11.24MB | 109.48MB | 2.69 GB | 2.14 GB | 3.21 GB | 5.36 GB | 10.71 GB | 53.58 GB | 107.52 GB | 535.88 GB | 1.05TB |
Modalità interattiva SDK (in secondi) | 28.2s | 18.6s | 20.8s | 20.9s | 23.8s | 21.7s | 24.7s | - | - | - | - | - |
Modalità batch SDK (in secondi) | 428.8s | 578.8s | 641.4s | 538.5s | 630.9s | 467.3s | 411s | 675s | 702s | 719.2s | 1022.1s | 1122.3s |
Schema ExperienceEvent XDM: In modalità interattiva è necessario essere in grado di leggere un massimo di 5 milioni di righe (~13,42 GB di dati su disco) di dati XDM in circa 18 minuti. La modalità interattiva supporta solo fino a 5 milioni di righe. Se desideri leggere set di dati più grandi, ti consigliamo di passare alla modalità batch. In modalità batch è necessario essere in grado di leggere un massimo di 500 milioni di righe (~1,31 TB di dati su disco) di dati XDM in circa 14 ore.
Numero di righe | 1K | 10K | 100.000 | 1M | 2M | 3M | 5M | 10M | 50M | 100M | 500M |
---|---|---|---|---|---|---|---|---|---|---|---|
Dimensioni su disco | 2.93MB | 4.38MB | 29.02 | 2.69 GB | 5.39 GB | 8.09 GB | 13.42 GB | 26.82 GB | 134.24 GB | 268.39 GB | 1.31TB |
Modalità interattiva SDK (in secondi) | 37.9s | 22.7s | 45.6s | 231.7s | 444.7s | 660.6s | 1100s | - | - | - | - |
Modalità batch SDK (in secondi) | 374.4s | 398.5s | 527s | 487.9s | 588.9s | 829s | 939.1s | 1441s | 5473.2s | 10118.8 | 49207.6 |
schema ad hoc: In modalità interattiva è necessario essere in grado di leggere un massimo di 5 milioni di righe (~5,36 GB di dati su disco) di dati non XDM in meno di 3 minuti. In modalità batch dovresti essere in grado di leggere un massimo di 1 miliardo di righe (~1.05 TB di dati su disco) di dati non XDM in circa 16 minuti.
Numero di righe | 1K | 10K | 100.000 | 1M | 2M | 3M | 5M | 10M | 50M | 100M | 500M | 1B |
---|---|---|---|---|---|---|---|---|---|---|---|---|
Dimensioni su disco | 1.12MB | 11.24MB | 109.48MB | 2.69 GB | 2.14 GB | 3.21 GB | 5.36 GB | 10.71 GB | 53.58 GB | 107.52 GB | 535.88 GB | 1.05TB |
Modalità interattiva SDK (in secondi) | 35.7s | 31s | 19.5s | 25.3s | 23s | 33.2s | 25.5s | - | - | - | - | - |
Modalità batch SDK (in secondi) | 448.8s | 459.7s | 519s | 475.8s | 599.9s | 347.6s | 407.8s | 397s | 518.8s | 487.9s | 760.2s | 975.4s |
Python i notebook consentono di impaginare i dati quando si accede ai set di dati. Di seguito è illustrato un codice di esempio per leggere i dati con e senza impaginazione. Per ulteriori informazioni sui notebook Python disponibili, visita il JupyterLab Launcher all’interno della guida utente di JupyterLab.
La documentazione di Python riportata di seguito delinea i seguenti concetti:
Senza impaginazione:
L'esecuzione del codice seguente leggerà l'intero set di dati. Se l’esecuzione ha esito positivo, i dati verranno salvati come dataframe panda a cui fa riferimento la variabile 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()
Con impaginazione:
L'esecuzione del codice seguente leggerà i dati dal set di dati specificato. La paginazione si ottiene limitando e compensando i dati attraverso le funzioni limit()
e offset()
rispettivamente. I dati limitanti si riferiscono al numero massimo di punti di dati da leggere, mentre l’offset si riferisce al numero di punti di dati da ignorare prima di leggere i dati. Se l’operazione di lettura viene eseguita correttamente, i dati verranno salvati come dataframe di dati Pandas a cui fa riferimento la variabile 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()
Per scrivere in un set di dati nel notebook JupyterLab, seleziona la scheda Icona Dati (evidenziata di seguito) nella navigazione a sinistra di JupyterLab. La Set di dati e Schemi vengono visualizzate le directory. Seleziona Set di dati e fai clic con il pulsante destro del mouse, quindi seleziona il Scrivi dati nel notebook dal menu a discesa del set di dati che desideri utilizzare. Nella parte inferiore del blocco appunti viene visualizzata una voce di codice eseguibile.
In alternativa, puoi copiare e incollare la seguente cella di codice. Sostituisci entrambe le {DATASET_ID}
e {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')
JupyterLab su Platform consente di utilizzare SQL in un Python blocco appunti per accedere ai dati tramite Servizio query Adobe Experience Platform. Accesso ai dati tramite Query Service può essere utile per gestire set di dati di grandi dimensioni a causa dei suoi tempi di esecuzione superiori. È consigliabile eseguire query sui dati utilizzando Query Service ha un limite di tempo di elaborazione di dieci minuti.
Prima di utilizzare Query Service in JupyterLab, assicurati di avere una comprensione funzionante del Query Service Sintassi SQL.
Query dei dati tramite Query Service richiede di fornire il nome del set di dati di destinazione. Puoi generare le celle di codice necessarie trovando il set di dati desiderato utilizzando la Data Explorer. Fai clic con il pulsante destro del mouse sull’elenco dei set di dati e fai clic su Query dei dati nel blocco appunti per generare due celle di codice nel blocco appunti. Queste due celle sono descritte più dettagliatamente di seguito.
Per utilizzare Query Service in JupyterLab, devi prima creare una connessione tra le attività Python notebook e Query Service. Questo può essere ottenuto eseguendo la prima cella generata.
qs_connect()
Nella seconda cella generata, la prima riga deve essere definita prima della query SQL. Per impostazione predefinita, la cella generata definisce una variabile opzionale (df0
) che salva i risultati della query come dataframe di dati Pandas.
La -c QS_CONNECTION
argomento obbligatorio e indica al kernel di eseguire la query SQL su Query Service. Consulta la sezione appendice per un elenco di argomenti aggiuntivi.
%%read_sql df0 -c QS_CONNECTION
SELECT *
FROM name_of_the_dataset
LIMIT 10
/* Querying table "name_of_the_dataset" (datasetId: {DATASET_ID})*/
È possibile fare riferimento direttamente alle variabili Python all'interno di una query SQL utilizzando la sintassi in formato stringa e racchiudendo le variabili tra parentesi graffe ({}
), come illustrato nell'esempio seguente:
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}
Per accedere e filtrare un ExperienceEvent set di dati in un Python blocco appunti, devi fornire l'ID del set di dati ({DATASET_ID}
) insieme alle regole di filtro che definiscono un intervallo di tempo specifico utilizzando operatori logici. Quando viene definito un intervallo di tempo, qualsiasi impaginazione specifica viene ignorata e viene considerato l’intero set di dati.
Di seguito è descritto un elenco di operatori di filtro:
eq()
: Uguale agt()
: Maggiore dige()
: Maggiore o uguale alt()
: Minore dile()
: Minore o uguale aAnd()
: Operatore AND logicoOr()
: Operatore OR logicoLa cella seguente filtra un ExperienceEvent insieme di dati a dati esistenti esclusivamente tra il 1° gennaio 2019 e la fine del 31 dicembre 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()
I notebook R consentono di impaginare i dati quando si accede ai set di dati. Di seguito è illustrato un codice di esempio per leggere i dati con e senza impaginazione. Per ulteriori informazioni sui notebook R disponibili, visita il JupyterLab Launcher all’interno della guida utente di JupyterLab.
La documentazione R riportata di seguito delinea i seguenti concetti:
Senza impaginazione:
L'esecuzione del codice seguente leggerà l'intero set di dati. Se l’esecuzione ha esito positivo, i dati verranno salvati come dataframe panda a cui fa riferimento la variabile 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)
Con impaginazione:
L'esecuzione del codice seguente leggerà i dati dal set di dati specificato. La paginazione si ottiene limitando e compensando i dati attraverso le funzioni limit()
e offset()
rispettivamente. I dati limitanti si riferiscono al numero massimo di punti di dati da leggere, mentre l’offset si riferisce al numero di punti di dati da ignorare prima di leggere i dati. Se l’operazione di lettura viene eseguita correttamente, i dati verranno salvati come dataframe di dati Pandas a cui fa riferimento la variabile 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()
Per scrivere in un set di dati nel notebook JupyterLab, seleziona la scheda Icona Dati (evidenziata di seguito) nella navigazione a sinistra di JupyterLab. La Set di dati e Schemi vengono visualizzate le directory. Seleziona Set di dati e fai clic con il pulsante destro del mouse, quindi seleziona il Scrivi dati nel notebook dal menu a discesa del set di dati che desideri utilizzare. Nella parte inferiore del blocco appunti viene visualizzata una voce di codice eseguibile.
In alternativa, puoi copiare e incollare la seguente cella di codice:
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')
Per accedere e filtrare un ExperienceEvent in un blocco appunti R, è necessario fornire l'ID del set di dati ({DATASET_ID}
) insieme alle regole di filtro che definiscono un intervallo di tempo specifico utilizzando operatori logici. Quando viene definito un intervallo di tempo, qualsiasi impaginazione specifica viene ignorata e viene considerato l’intero set di dati.
Di seguito è descritto un elenco di operatori di filtro:
eq()
: Uguale agt()
: Maggiore dige()
: Maggiore o uguale alt()
: Minore dile()
: Minore o uguale aAnd()
: Operatore AND logicoOr()
: Operatore OR logicoLa cella seguente filtra un ExperienceEvent insieme di dati a dati esistenti esclusivamente tra il 1° gennaio 2019 e la fine del 31 dicembre 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()
La documentazione di PySpark riportata di seguito delinea i seguenti concetti:
Tutto Spark I notebook 2.4 richiedono l’inizializzazione della sessione con il seguente codice standard.
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
Con l'introduzione di Spark 2.4 %dataset
la magia personalizzata è fornita per l'uso in PySpark 3 (Spark 2.4) notebook. Per maggiori dettagli sui comandi magici disponibili nel kernel IPython, visita il Documentazione magica su IPython.
Utilizzo
%dataset {action} --datasetId {id} --dataFrame {df} --mode batch
Descrizione
Personalizzazione Data Science Workspace comando magico per leggere o scrivere un set di dati da un PySpark blocco appunti (Python 3 kernel).
Nome | Descrizione | Obbligatorio |
---|---|---|
{action} |
Tipo di azione da eseguire sul set di dati. Sono disponibili due azioni: "read" o "write". | Sì |
--datasetId {id} |
Utilizzato per fornire l'ID del set di dati da leggere o scrivere. | Sì |
--dataFrame {df} |
Il dataframe panda.
|
Sì |
--mode |
Un parametro aggiuntivo che modifica la modalità di lettura dei dati. I parametri consentiti sono "batch" e "interattivo". Per impostazione predefinita, la modalità è impostata su "batch". È consigliabile utilizzare la modalità "interattiva" per migliorare le prestazioni delle query sui set di dati più piccoli. |
Sì |
Esamina le tabelle PySpark all’interno della limiti dei dati del blocco appunti sezione per determinare se mode
deve essere impostato su interactive
o batch
.
Esempi
%dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0 --mode batch
%dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0 --mode batch
Memorizzazione in cache dei dati tramite df.cache()
prima di scrivere i dati può migliorare notevolmente le prestazioni del notebook. Questo può essere utile se si riceve uno dei seguenti errori:
Consulta la sezione guida alla risoluzione dei problemi per ulteriori informazioni.
Puoi generare automaticamente gli esempi di cui sopra in JupyterLab buy utilizzando il seguente metodo:
Seleziona la scheda Icona Dati (evidenziata di seguito) nella navigazione a sinistra di JupyterLab. La Set di dati e Schemi vengono visualizzate le directory. Seleziona Set di dati e fai clic con il pulsante destro del mouse, quindi seleziona il Scrivi dati nel notebook dal menu a discesa del set di dati che desideri utilizzare. Nella parte inferiore del blocco appunti viene visualizzata una voce di codice eseguibile.
Per creare un dataframe locale utilizzando PySpark 3, utilizzare le query SQL. Ad esempio:
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)
Puoi anche specificare un campione di seed facoltativo, ad esempio un valore booleano con sostituzione, doppia frazione o un valore di seed lungo.
Accesso e filtraggio di un ExperienceEvent Il set di dati in un blocco appunti PySpark richiede di fornire l'identità del set di dati ({DATASET_ID}
), l’identità IMS della tua organizzazione e le regole di filtro che definiscono un intervallo di tempo specifico. Un intervallo di tempo di filtraggio è definito utilizzando la funzione spark.sql()
, dove il parametro della funzione è una stringa di query SQL.
Le celle seguenti filtrano un ExperienceEvent insieme di dati a dati esistenti esclusivamente tra il 1° gennaio 2019 e la fine del 31 dicembre 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()
La documentazione seguente contiene esempi per i seguenti concetti:
Tutti i notebook Scala richiedono l’inizializzazione della sessione con il seguente codice standard:
import org.apache.spark.sql.{ SparkSession }
val spark = SparkSession
.builder()
.master("local")
.getOrCreate()
In Scala puoi importare clientContext
per ottenere e restituire i valori di Platform, questo elimina la necessità di definire variabili quali var userToken
. Nell'esempio di Scala seguente, clientContext
viene utilizzato per ottenere e restituire tutti i valori richiesti necessari per la lettura di un set di dati.
Memorizzazione in cache dei dati tramite df.cache()
prima di scrivere i dati può migliorare notevolmente le prestazioni del notebook. Questo può essere utile se si riceve uno dei seguenti errori:
Consulta la sezione guida alla risoluzione dei problemi per ulteriori informazioni.
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)
Elemento | Descrizione |
---|---|
df1 | Variabile che rappresenta il dataframe panda utilizzato per leggere e scrivere i dati. |
user-token | Token utente recuperato automaticamente con clientContext.getUserToken() . |
service-token | Il token di servizio recuperato automaticamente utilizzando clientContext.getServiceToken() . |
ims-org | L’ID organizzazione IMS viene recuperato automaticamente utilizzando clientContext.getOrgId() . |
api-key | Chiave API recuperata automaticamente utilizzando clientContext.getApiKey() . |
Esamina le tabelle Scala all'interno del limiti dei dati del blocco appunti sezione per determinare se mode
deve essere impostato su interactive
o batch
.
Puoi generare automaticamente l'esempio precedente in JupyterLab buy utilizzando il seguente metodo:
Seleziona la scheda Icona Dati (evidenziata di seguito) nella navigazione a sinistra di JupyterLab. La Set di dati e Schemi vengono visualizzate le directory. Seleziona Set di dati e fai clic con il pulsante destro del mouse, quindi seleziona il Esplorare i dati nel notebook dal menu a discesa del set di dati che desideri utilizzare. Nella parte inferiore del blocco appunti viene visualizzata una voce di codice eseguibile.
E
In Scala puoi importare clientContext
per ottenere e restituire i valori di Platform, questo elimina la necessità di definire variabili quali var userToken
. Nell'esempio di Scala seguente, clientContext
viene utilizzato per definire e restituire tutti i valori richiesti necessari per la scrittura in un set di dati.
Memorizzazione in cache dei dati tramite df.cache()
prima di scrivere i dati può migliorare notevolmente le prestazioni del notebook. Questo può essere utile se si riceve uno dei seguenti errori:
Consulta la sezione guida alla risoluzione dei problemi per ulteriori informazioni.
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()
element | descrizione |
---|---|
df1 | Variabile che rappresenta il dataframe panda utilizzato per leggere e scrivere i dati. |
user-token | Token utente recuperato automaticamente con clientContext.getUserToken() . |
service-token | Il token di servizio recuperato automaticamente utilizzando clientContext.getServiceToken() . |
ims-org | L’ID organizzazione IMS viene recuperato automaticamente utilizzando clientContext.getOrgId() . |
api-key | Chiave API recuperata automaticamente utilizzando clientContext.getApiKey() . |
Esamina le tabelle Scala all'interno del limiti dei dati del blocco appunti sezione per determinare se mode
deve essere impostato su interactive
o batch
.
Per creare un dataframe locale utilizzando Scala, sono necessarie query SQL. Ad esempio:
sparkdf.createOrReplaceTempView("sparkdf")
val localdf = spark.sql("SELECT * FROM sparkdf LIMIT 1)
Accesso e filtraggio di un ExperienceEvent Il set di dati in un blocco appunti Scala richiede di fornire l'identità del set di dati ({DATASET_ID}
), l’identità IMS della tua organizzazione e le regole di filtro che definiscono un intervallo di tempo specifico. Un intervallo di tempo di filtraggio è definito utilizzando la funzione spark.sql()
, dove il parametro della funzione è una stringa di query SQL.
Le celle seguenti filtrano un ExperienceEvent insieme di dati a dati esistenti esclusivamente tra il 1° gennaio 2019 e la fine del 31 dicembre 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()
Questo documento illustra le linee guida generali per l’accesso ai set di dati utilizzando i notebook JupyterLab. Per esempi più approfonditi su come eseguire query sui set di dati, visita il Servizio query nei notebook JupyterLab documentazione. Per ulteriori informazioni su come esplorare e visualizzare i set di dati, visita il documento su analisi dei dati con i notebook.
Questa tabella delinea i flag SQL facoltativi che possono essere utilizzati per Query Service.
Flag | Descrizione |
---|---|
-h , --help |
Visualizza il messaggio della guida e esci. |
-n , --notify |
Attiva/disattiva l'opzione per la notifica dei risultati della query. |
-a , --async |
L’utilizzo di questo flag esegue la query in modo asincrono e può liberare il kernel durante l’esecuzione della query. Presta attenzione quando assegni i risultati della query alle variabili, in quanto potrebbe non essere definita se la query non è completa. |
-d , --display |
L’utilizzo di questo flag impedisce la visualizzazione dei risultati. |