Accesso ai dati nei notebook Jupyterlab

Ogni kernel supportato fornisce funzionalità integrate che consentono di leggere i dati della piattaforma da un dataset 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 l'impaginazione dei dati è limitato ai notebook Python e R. Questa guida è incentrata su come utilizzare i notebook JupyterLab per accedere ai dati.

Introduzione

Prima di leggere questa guida, consultare la JupyterLab guida utente per un'introduzione di alto livello a JupyterLab e il relativo ruolo all'interno di Data Science Workspace.

Limiti dei dati del notebook

IMPORTANTE

Per i notebook PySpark e Scala se viene visualizzato un errore con il motivo "Client RPC remoto non associato". In genere significa che il driver o l'esecutore non dispongono di memoria sufficiente. Per risolvere l'errore, provare a passare alla modalità "batch".

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, per i benchmark è stato utilizzato un server notebook configurato a 40 GB di RAM. Per PySpark e Scala, un cluster di database configurato a 64 GB di RAM, 8 core, 2 DBU con un massimo di 4 dipendenti è stato utilizzato per i benchmark indicati di seguito.

I dati dello schema ExperienceEvent utilizzati variavano nelle dimensioni a partire da mille (1K) righe fino a un miliardo di righe (1B). Per le metriche PySpark e Spark è stato utilizzato un intervallo di date di 10 giorni per i dati XDM.

I dati dello schema ad hoc sono stati pre-elaborati utilizzando Query Service Crea tabella come Seleziona (CTAS). Questi dati sono anche variati in dimensioni a partire da mille (1K) righe che vanno fino a un miliardo (1B) righe.

Quando utilizzare la modalità batch e la modalità interattiva

Quando si leggono i set di dati con i notebook PySpark e Scala, è possibile utilizzare la modalità interattiva o la modalità batch per leggere il set di dati. Interattivo è fatto per risultati veloci, mentre la modalità batch è per set di dati di grandi dimensioni.

  • Per i notebook PySpark e Scala, la modalità batch deve essere utilizzata per la lettura di almeno 5 milioni di righe di dati. Per ulteriori informazioni sull'efficienza di ciascuna modalità, vedere le tabelle dei limiti di dati PySpark o Scala riportate di seguito.

Python limiti dei dati del notebook

Schema ExperienceEvent XDM: è necessario 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 10.000 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: dovreste essere in grado di leggere un massimo di 5 milioni di righe (circa 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 10.000 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

Limiti dei dati del notebook R

schema XDM ExperienceEvent: dovresti essere in grado di leggere un massimo di 1 milione di righe di dati XDM (3 GB di dati su disco) in meno di 13 minuti.

Numero di righe 1K 10.000 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: dovreste 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 10.000 100.000 1M 2M 3M
Dimensioni su disco (in MB) 0,082 0,612 9,0 91 188 293
SDK R (in sec) 7,7 4,58 35,9 233 470,5 603

Limiti dei dati del notebook PySpark (Python kernel):

Schema ExperienceEvent XDM: in modalità interattiva è possibile leggere fino a 5 milioni di righe (circa 5 milioni di dati da 13,42 GB su disco) di dati XDM in circa 20 minuti. La modalità interattiva supporta solo fino a 5 milioni di righe. Se si desidera leggere set di dati più grandi, è consigliabile passare alla modalità batch. In modalità batch è necessario essere in grado di leggere un massimo di 500 milioni di righe (circa 1,31 TB di dati su disco) di dati XDM in circa 14 ore.

Numero di righe 1K 10.000 100.000 1M 2M 3M 5M 10 M 50 M 100 M 500 M
Dimensioni su disco 2,93 MB 4,38 MB 29,02 2.69 GB 5.39 GB 8.09 GB 13.42 GB 26.82 GB 134.24 GB 268.39 GB 1,31 TB
SDK (modalità interattiva) 33 sec 32,4 s 55,1 s 253,5 s 489,2 s 729,6 s 1206,8 s - - - -
SDK (modalità batch) 815,8 sec 492,8 s 379,1 s 637,4 s 624,5 s 869,2 s 1104,1 s 1786 s 5387,2 s 10624,6s 50547 s

schema ad hoc: in modalità interattiva è possibile leggere un massimo di 5 milioni di righe (circa 5,36 GB di dati su disco) di dati non XDM in meno di 3 minuti. In modalità Batch dovreste essere in grado di leggere un massimo di 1 miliardo di righe (circa 1,05 TB di dati su disco) di dati non XDM in circa 18 minuti.

Numero di righe 1K 10.000 100.000 1M 2M 3M 5M 10 M 50 M 100 M 500 M 1B
Dimensioni su disco 1,12 MB 11,24 MB 109,48 MB 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,05 TB
Modalità interattiva SDK (in secondi) 28,2 s 18,6 sec 20,8 sec 20,9 s 23,8 sec 21,7 sec 24,7 sec - - - - -
Modalità batch SDK (in secondi) 428,8 sec 578,8 sec 641,4 s 538,5 s 630,9 s 467,3 s 411 s 675 s 702 s 719,2 s 1022,1 s 1122,3 s

Spark Limiti dei dati del notebook (kernel Scala):

Schema ExperienceEvent XDM: in modalità interattiva è possibile leggere fino a 5 milioni di righe (circa 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 si desidera leggere set di dati più grandi, è consigliabile passare alla modalità batch. In modalità batch è necessario essere in grado di leggere un massimo di 500 milioni di righe (circa 1,31 TB di dati su disco) di dati XDM in circa 14 ore.

Numero di righe 1K 10.000 100.000 1M 2M 3M 5M 10 M 50 M 100 M 500 M
Dimensioni su disco 2,93 MB 4,38 MB 29,02 2.69 GB 5.39 GB 8.09 GB 13.42 GB 26.82 GB 134.24 GB 268.39 GB 1,31 TB
Modalità interattiva SDK (in secondi) 37,9 s 22,7 sec 45,6 s 231,7 sec 444,7 s 660,6 s 1100 sec. - - - -
Modalità batch SDK (in secondi) 374,4 s 398,5 s 527 s 487,9 s 588,9 s 829 s 939,1 s 1441 s 5473,2 s 10118,8 49207,6

schema ad hoc: in modalità interattiva è possibile leggere un massimo di 5 milioni di righe (circa 5,36 GB di dati su disco) di dati non XDM in meno di 3 minuti. In modalità batch è necessario essere in grado di leggere un massimo di 1 miliardo di righe (circa 1,05 TB di dati su disco) di dati non XDM in circa 16 minuti.

Numero di righe 1K 10.000 100.000 1M 2M 3M 5M 10 M 50 M 100 M 500 M 1B
Dimensioni su disco 1,12 MB 11,24 MB 109,48 MB 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,05 TB
Modalità interattiva SDK (in secondi) 35,7 sec 31 s 19,5 s 25,3 s 23 sec 33,2 s 25,5 sec - - - - -
Modalità batch SDK (in secondi) 448,8 s 459,7 s 519 s 475,8 sec 599,9 s 347,6 s 407,8 s 397 s 518,8 sec 487,9 s 760,2 s 975,4 s

Notebook Python

Python i notebook consentono di impaginare i dati quando si accede ai set di dati. Di seguito è illustrato il codice di esempio per leggere i dati con e senza impaginazione. Per ulteriori informazioni sui notebook Python di avvio disponibili, visitare la sezione JupyterLab Launcher nella guida utente di JupyterLab.

La documentazione Python riportata di seguito illustra i seguenti concetti:

Leggi da un set di dati in Python

Senza impaginazione:

L'esecuzione del codice seguente consente di leggere l'intero set di dati. Se l'esecuzione ha esito positivo, i dati verranno salvati come fotogramma 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.read()
df.head()

Con impaginazione:

L'esecuzione del codice seguente consente di leggere 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 limitati si riferiscono al numero massimo di punti dati da leggere, mentre l'offset fa riferimento al numero di punti dati da ignorare prima della lettura dei dati. Se l'operazione di lettura viene eseguita correttamente, i dati verranno salvati come fotogramma 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()

Scrivere in un set di dati in Python

Per scrivere in un set di dati nel notebook JupyterLab, seleziona la scheda Icona dati (evidenziata di seguito) nella barra di navigazione a sinistra di JupyterLab. Vengono visualizzate le directory Datasets e Schemas. Selezionare Datasets e fare clic con il pulsante destro del mouse, quindi selezionare l'opzione Write Data in Notebook dal menu a discesa del set di dati che si desidera utilizzare. Nella parte inferiore del blocco appunti viene visualizzata una voce di codice eseguibile.

  • Utilizzare Write Data in Notebook per generare una cella di scrittura con il set di dati selezionato.
  • Utilizzare Explore Data in Notebook per generare una cella di lettura con il set di dati selezionato.
  • Utilizzare Query Data in Notebook per generare una cella di query di base con il set di dati selezionato.

In alternativa, è possibile copiare e incollare la seguente cella di codice. Sostituire sia il {DATASET_ID} che il {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')

Dati query che utilizzano Query Service in Python

JupyterLab on Platform consente di utilizzare SQL in un Python blocco appunti per accedere ai dati tramite Adobe Experience Platform Query Service. L'accesso ai dati tramite Query Service può essere utile per gestire i set di dati di grandi dimensioni a causa dei suoi tempi di esecuzione superiori. Tenere presente che l'esecuzione di query sui dati utilizzando Query Service ha un limite di tempo di elaborazione di dieci minuti.

Prima di utilizzare Query Service in JupyterLab, verificare di disporre di una conoscenza approfondita della Query Service sintassi SQL.

Per eseguire la query dei dati utilizzando Query Service è necessario fornire il nome del set di dati di destinazione. È possibile generare le celle di codice necessarie individuando il set di dati desiderato utilizzando Data explorer. Fare clic con il pulsante destro del mouse sull'elenco dei set di dati e fare clic su Query Data in Notebook per generare due celle di codice nel blocco appunti. Queste due celle sono descritte più dettagliatamente di seguito.

Per utilizzare Query Service in JupyterLab, è innanzitutto necessario creare una connessione tra il notebook Python in uso 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 fotogramma dati Pandas.
L' -c QS_CONNECTION argomento è obbligatorio e indica al kernel di eseguire la query SQL con Query Service. Per un elenco degli argomenti aggiuntivi, vedere l' appendice.

%%read_sql df0 -c QS_CONNECTION
SELECT *
FROM name_of_the_dataset
LIMIT 10
/* Querying table "name_of_the_dataset" (datasetId: {DATASET_ID})*/

Alle variabili Python è possibile fare riferimento direttamente 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}

Filtrare i dati ExperienceEvent

Per accedere e filtrare un dataset ExperienceEvent in un blocco appunti Python, è necessario fornire l'ID del dataset ({DATASET_ID}) insieme alle regole del filtro che definiscono un intervallo di tempo specifico utilizzando operatori logici. Quando viene definito un intervallo di tempo, qualsiasi impaginazione specificata viene ignorata e viene considerato l'intero set di dati.

Di seguito è riportato un elenco di operatori di filtraggio:

  • eq(): Uguale a
  • gt(): Maggiore di
  • ge(): Maggiore o uguale a
  • lt(): Minore di
  • le(): Minore o uguale a
  • And(): Operatore logico AND
  • Or(): Operatore OR logico

La cella seguente filtra un set di dati ExperienceEvent 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()

Notebook R

I notebook R consentono di impaginare i dati quando si accede ai set di dati. Di seguito è illustrato il codice di esempio per leggere i dati con e senza impaginazione. Per ulteriori informazioni sui notebook R disponibili, consultare la sezione JupyterLab Launcher nella guida utente di JupyterLab.

La documentazione R seguente delinea i seguenti concetti:

Leggi da un set di dati in R

Senza impaginazione:

L'esecuzione del codice seguente consente di leggere l'intero set di dati. Se l'esecuzione ha esito positivo, i dati verranno salvati come fotogramma 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$read()
head(df0)

Con impaginazione:

L'esecuzione del codice seguente consente di leggere 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 limitati si riferiscono al numero massimo di punti dati da leggere, mentre l'offset fa riferimento al numero di punti dati da ignorare prima della lettura dei dati. Se l'operazione di lettura viene eseguita correttamente, i dati verranno salvati come fotogramma 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()

Scrivere in un set di dati in R

Per scrivere in un set di dati nel notebook JupyterLab, seleziona la scheda Icona dati (evidenziata di seguito) nella barra di navigazione a sinistra di JupyterLab. Vengono visualizzate le directory Datasets e Schemas. Selezionare Datasets e fare clic con il pulsante destro del mouse, quindi selezionare l'opzione Write Data in Notebook dal menu a discesa del set di dati che si desidera utilizzare. Nella parte inferiore del blocco appunti viene visualizzata una voce di codice eseguibile.

  • Utilizzare Write Data in Notebook per generare una cella di scrittura con il set di dati selezionato.
  • Utilizzare Explore Data in Notebook per generare una cella di lettura con il set di dati selezionato.

In alternativa, potete 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')

Filtrare i dati ExperienceEvent

Per accedere e filtrare un set di dati ExperienceEvent in un blocco appunti R, è necessario fornire l'ID del set di dati ({DATASET_ID}) insieme alle regole del filtro che definiscono un intervallo di tempo specifico utilizzando operatori logici. Quando viene definito un intervallo di tempo, qualsiasi impaginazione specificata viene ignorata e viene considerato l'intero set di dati.

Di seguito è riportato un elenco di operatori di filtraggio:

  • eq(): Uguale a
  • gt(): Maggiore di
  • ge(): Maggiore o uguale a
  • lt(): Minore di
  • le(): Minore o uguale a
  • And(): Operatore logico AND
  • Or(): Operatore OR logico

La cella seguente filtra un set di dati ExperienceEvent 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()

Notebook PySpark 3

La documentazione di PySpark riportata di seguito descrive i seguenti concetti:

Inizializzazione di sparkSession

Tutti i notebook Spark 2.4 richiedono l'inizializzazione della sessione con il seguente codice standard.

from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()

Utilizzo di %dataset per la lettura e la scrittura con un blocco appunti PySpark 3

Con l'introduzione di Spark 2.4, %dataset la magia personalizzata viene fornita per l'utilizzo nei notebook PySpark 3 (Spark 2.4). Per ulteriori dettagli sui comandi magici disponibili nel kernel IPython, visitare la Documentazione magica IPython.

Utilizzo

%dataset {action} --datasetId {id} --dataFrame {df}`

Descrizione

Comando Data Science Workspace personalizzato per la lettura o la scrittura di un dataset da un blocco appunti PySpark (Python 3 kernel).

Nome Descrizione Obbligatorio
{action} Tipo di azione da eseguire sul set di dati. Sono disponibili due azioni: "read" o "write".
--datasetId {id} Utilizzato per fornire l'ID del set di dati da leggere o scrivere.
--dataFrame {df} Il dataframe panda.
  • Quando l'azione è "read", {df} è la variabile in cui sono disponibili i risultati dell'operazione di lettura del dataset.
  • Quando l'azione è "scrivi", il dataframe {df} viene scritto nel dataset.
--mode Un parametro aggiuntivo che modifica il modo in cui i dati vengono letti. I parametri consentiti sono "batch" e "interattivo". Per impostazione predefinita, la modalità è impostata su "interattivo". Si consiglia di utilizzare la modalità "batch" durante la lettura di grandi quantità di dati. No
SUGGERIMENTO

Esaminare le tabelle PySpark all'interno della sezione limiti dei dati del notebook per determinare se mode deve essere impostato su interactive o batch.

Esempi

  • Leggi l'esempio: %dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0
  • Esempio di scrittura: %dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0

Potete generare automaticamente gli esempi di cui sopra in JupyterLab buy utilizzando il seguente metodo:

Selezionate la scheda Icona dati (evidenziata di seguito) nella navigazione a sinistra di JupyterLab. Vengono visualizzate le directory Datasets e Schemas. Selezionare Datasets e fare clic con il pulsante destro del mouse, quindi selezionare l'opzione Write Data in Notebook dal menu a discesa del set di dati che si desidera utilizzare. Nella parte inferiore del blocco appunti viene visualizzata una voce di codice eseguibile.

  • Utilizzare Explore Data in Notebook per generare una cella di lettura.
  • Utilizzare Write Data in Notebook per generare una cella di scrittura.

Creare un dataframe locale

Per creare un dataframe locale utilizzando PySpark 3, utilizzate le query SQL. 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)
SUGGERIMENTO

È inoltre possibile specificare un campione di sementi facoltativo, ad esempio un valore booleano conSostituzione, una doppia frazione o un valore seed lungo.

Filtrare i dati ExperienceEvent

Per accedere e filtrare un set di dati ExperienceEvent in un blocco appunti PySpark è necessario fornire l'identità del set di dati ({DATASET_ID}), l'identità IMS dell'azienda e le regole del 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 set di dati su 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

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()

Notebook Scala

La documentazione seguente contiene esempi per i seguenti concetti:

Inizializzazione di SparkSession

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()

Leggi un set di dati

In Scala, è possibile importare clientContext per ottenere e restituire i valori della piattaforma, eliminando la necessità di definire variabili come var userToken. Nell'esempio di Scala seguente, clientContext viene utilizzato per ottenere e restituire tutti i valori richiesti necessari per la lettura di un dataset.

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", "interactive")
  .option("dataset-id", "5e68141134492718af974844")
  .load()

df1.printSchema()
df1.show(10)
Elemento Descrizione
df1 Variabile che rappresenta il fotogramma dati Pandas utilizzato per leggere e scrivere i dati.
token utente Token utente recuperato automaticamente con clientContext.getUserToken().
service-token Token di servizio recuperato automaticamente con clientContext.getServiceToken().
ims-org L'ID organizzazione IMS che viene recuperato automaticamente utilizzando clientContext.getOrgId().
api-key La chiave API recuperata automaticamente utilizzando clientContext.getApiKey().
SUGGERIMENTO

Esaminare le tabelle Scala all'interno della sezione limiti dei dati del notebook per determinare se mode deve essere impostato su interactive o batch.

È possibile generare automaticamente l'esempio di cui sopra in JupyterLab buy utilizzando il seguente metodo:

Selezionate la scheda Icona dati (evidenziata di seguito) nella navigazione a sinistra di JupyterLab. Vengono visualizzate le directory Datasets e Schemas. Selezionare Datasets e fare clic con il pulsante destro del mouse, quindi selezionare l'opzione Explore Data in Notebook dal menu a discesa del set di dati che si desidera utilizzare. Nella parte inferiore del blocco appunti viene visualizzata una voce di codice eseguibile.
And

  • Utilizzare Explore Data in Notebook per generare una cella di lettura.
  • Utilizzare Write Data in Notebook per generare una cella di scrittura.

Scrivere in un set di dati

In Scala, è possibile importare clientContext per ottenere e restituire i valori della piattaforma, eliminando la necessità di definire variabili come var userToken. Nell'esempio di Scala seguente, clientContext viene utilizzato per definire e restituire tutti i valori necessari per la scrittura in un dataset.

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", "interactive")
  .option("dataset-id", "5e68141134492718af974844")
  .save()
elemento description
df1 Variabile che rappresenta il fotogramma dati Pandas utilizzato per leggere e scrivere i dati.
token utente Token utente recuperato automaticamente con clientContext.getUserToken().
service-token Token di servizio recuperato automaticamente con clientContext.getServiceToken().
ims-org L'ID organizzazione IMS che viene recuperato automaticamente utilizzando clientContext.getOrgId().
api-key La chiave API recuperata automaticamente utilizzando clientContext.getApiKey().
SUGGERIMENTO

Esaminare le tabelle Scala all'interno della sezione limiti dei dati del notebook per determinare se mode deve essere impostato su interactive o batch.

creare un dataframe locale

Per creare un dataframe locale utilizzando Scala, sono necessarie query SQL. Esempio:

sparkdf.createOrReplaceTempView("sparkdf")

val localdf = spark.sql("SELECT * FROM sparkdf LIMIT 1)

Filtrare i dati ExperienceEvent

Per accedere e filtrare un set di dati ExperienceEvent in un blocco appunti Scala è necessario fornire l'identità del set di dati ({DATASET_ID}), l'identità IMS dell'azienda e le regole del filtro che definiscono un intervallo di tempo specifico. Un intervallo di tempo di filtro è definito utilizzando la funzione spark.sql(), dove il parametro della funzione è una stringa di query SQL.

Le celle seguenti filtrano un ExperienceEvent set di dati su 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()

Passaggi successivi

Questo documento ha trattato le linee guida generali per l'accesso ai dataset utilizzando i notebook JupyterLab. Per esempi dettagliati sull'esecuzione di query sui set di dati, consultare la documentazione Query Service in JupyterLab Notebook. Per ulteriori informazioni su come esplorare e visualizzare i set di dati, consultare il documento relativo all' analisi dei dati utilizzando i blocchi appunti.

Flag SQL facoltativi per Query Service

La tabella riportata di seguito illustra i flag SQL facoltativi utilizzabili 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 consente di eseguire la query in modo asincrono e di liberare il kernel durante l'esecuzione della query. Prestate attenzione quando assegnate i risultati della query alle variabili, in quanto potrebbe essere undefined se la query non è completa.
-d, --display L'utilizzo di questo flag impedisce la visualizzazione dei risultati.

In questa pagina