Accesso ai dati nei notebook Jupyterlab

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. Al momento 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 ai notebook Python e R. Questa guida si concentra su come utilizzare i notebook JupyterLab per accedere ai dati.

Introduzione

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

Limiti dei dati del blocco appunti

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, è 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). 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 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 utilizzare la modalità batch e la modalità interattiva

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.

• Per i notebook PySpark e Scala, utilizzare la modalità batch quando si leggono 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 blocco appunti

Schema ExperienceEvent XDM: dovresti essere in grado di leggere un massimo di 2 milioni di righe (~6,1 GB di dati su disco) di dati XDM in meno di 22 minuti. L’aggiunta di righe aggiuntive potrebbe causare errori.

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.

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 (dati da 3 GB sul disco) in meno di 13 minuti.

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.

Limiti dei dati del notebook PySpark (Python kernel):

Schema XDM ExperienceEvent: in modalità interattiva dovresti essere in grado di leggere un massimo di 5 milioni di righe (circa 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.

schema ad-hoc: in modalità interattiva dovresti 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.

Spark Limiti dei dati del notebook (kernel Scala):

Schema XDM ExperienceEvent: in modalità interattiva dovresti essere in grado di leggere un massimo di 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 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.

schema ad-hoc: in modalità interattiva dovresti 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.

Notebook Python

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 la sezione JupyterLab Launcher nella guida utente di JupyterLab .

La documentazione di Python riportata di seguito delinea i seguenti concetti:

• Lettura da un set di dati
• Scrivere in un set di dati
• Dati query
• Filtrare i dati ExperienceEvent

Leggi da un set di dati in Python

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

Scrivi 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 navigazione a sinistra di JupyterLab. Vengono visualizzate le directory Set di dati e Schemi. Selezionare Set di dati e fare clic con il pulsante destro del mouse, quindi selezionare l'opzione Scrivi dati nel blocco appunti 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.

• Utilizza Scrivi dati nel blocco appunti per generare una cella di scrittura con il set di dati selezionato.
• Utilizza Esplora dati nel blocco appunti per generare una cella di lettura con il set di dati selezionato.
• Utilizza Dati query nel blocco appunti per generare una cella query di base con il set di dati selezionato.

In alternativa, puoi copiare e incollare la seguente cella di codice. Sostituisci sia {DATASET_ID} che {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 utilizzando Query Service in Python

JupyterLab su Platform consente di utilizzare SQL in un Python blocco appunti per accedere ai dati tramite il servizio Query Adobe Experience Platform. L’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 che l’esecuzione di query sui dati utilizzando Query Service abbia un limite di tempo di elaborazione di dieci minuti.

Prima di utilizzare Query Service in JupyterLab, assicurati di avere familiarità con la Query Service sintassi SQL.

Per eseguire la query dei dati utilizzando Query Service è necessario fornire il nome del set di dati di destinazione. Puoi generare le celle di codice necessarie trovando il set di dati desiderato utilizzando Data explorer. Fai clic con il pulsante destro del mouse sull'elenco dei set di dati e fai 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 blocco appunti in uso Python 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 panda.
L' -c QS_CONNECTION argomento è obbligatorio e indica al kernel di eseguire la query SQL su Query Service. Per un elenco di 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})*/

È 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}

Filtrare i dati ExperienceEvent

Per accedere e filtrare un set di dati ExperienceEvent in un blocco appunti Python, è necessario fornire l'ID del set di dati ({DATASET_ID}) insieme alle regole di filtro che definiscono un intervallo di tempo specifico utilizzando gli 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 a
• gt(): Maggiore di
• ge(): Maggiore o uguale a
• lt(): Minore di
• le(): Minore o uguale a
• And(): Operatore AND logico
• Or(): Operatore OR logico

La cella seguente filtra un set di dati ExperienceEvent in base ai 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 un codice di esempio per leggere i dati con e senza impaginazione. Per ulteriori informazioni sui notebook R disponibili, visita la sezione JupyterLab Launcher nella guida utente di JupyterLab .

La documentazione R riportata di seguito delinea i seguenti concetti:

• Lettura da un set di dati
• Scrivere in un set di dati
• Filtrare i dati ExperienceEvent

Leggi da un set di dati in R

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

Scrivi 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 navigazione a sinistra di JupyterLab. Vengono visualizzate le directory Set di dati e Schemi. Selezionare Set di dati e fare clic con il pulsante destro del mouse, quindi selezionare l'opzione Scrivi dati nel blocco appunti 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.

• Utilizza Scrivi dati nel blocco appunti per generare una cella di scrittura con il set di dati selezionato.
• Utilizza Esplora dati nel blocco appunti per generare una cella di lettura con il set di dati selezionato.

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

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 di filtro che definiscono un intervallo di tempo specifico utilizzando gli 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 a
• gt(): Maggiore di
• ge(): Maggiore o uguale a
• lt(): Minore di
• le(): Minore o uguale a
• And(): Operatore AND logico
• Or(): Operatore OR logico

La cella seguente filtra un set di dati ExperienceEvent in base ai 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 delinea i seguenti concetti:

• Inizializza sparkSession
• Lettura e scrittura di dati
• Creare un dataframe locale
• Filtrare i dati ExperienceEvent

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 leggere e scrivere con un blocco appunti PySpark 3

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

Utilizzo

%dataset {action} --datasetId {id} --dataFrame {df} --mode batch

Descrizione

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

Esempi

• Esempio di lettura: %dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0 --mode batch
• Esempio di scrittura: %dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0 --mode batch

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. Vengono visualizzate le directory Set di dati e Schemi. Selezionare Set di dati e fare clic con il pulsante destro del mouse, quindi selezionare l'opzione Scrivi dati nel blocco appunti 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 Esplora dati nel notebook per generare una cella di lettura.
• Utilizzare Scrivi dati nel notebook per generare una cella di scrittura.

Creare un dataframe locale

Per creare un dataframe locale utilizzando PySpark 3, utilizzare 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)

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 della propria organizzazione e le regole del filtro che definiscono un intervallo di tempo specifico. Un intervallo di tempo di filtro viene definito utilizzando la funzione spark.sql(), dove il parametro della funzione è una stringa di query SQL.

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

Notebook Scala

La documentazione seguente contiene esempi per i seguenti concetti:

• Inizializza sparkSession
• Leggere un set di dati
• Scrivere in un set di dati
• Creare un dataframe locale
• Filtrare i dati ExperienceEvent

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, puoi importare clientContext per ottenere e restituire i valori di Platform, eliminando 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.

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)

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. Vengono visualizzate le directory Set di dati e Schemi. Selezionare Set di dati e fare clic con il pulsante destro del mouse, quindi selezionare l'opzione Esplora dati nel blocco appunti 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.
E

• Utilizzare Esplora dati nel notebook per generare una cella di lettura.
• Utilizzare Scrivi dati nel notebook per generare una cella di scrittura.

Scrivere in un set di dati

In Scala, puoi importare clientContext per ottenere e restituire i valori di Platform, eliminando 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.

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

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 della propria organizzazione e le regole del filtro che definiscono un intervallo di tempo specifico. Un intervallo di tempo di filtro viene definito utilizzando la funzione spark.sql(), dove il parametro della funzione è una stringa di query SQL.

Le celle seguenti filtrano un set di dati ExperienceEvent in base ai 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 illustra le linee guida generali per l’accesso ai set di dati utilizzando i notebook JupyterLab. Per esempi più approfonditi sulla query dei set di dati, visita la documentazione Query Service in JupyterLab Notebook . Per ulteriori informazioni su come esplorare e visualizzare i set di dati, visita il documento relativo all’ analisi dei dati tramite blocchi appunti.

Flag SQL facoltativi per Query Service

Questa tabella delinea i flag SQL facoltativi che possono essere utilizzati per Query Service.