Accesso ai dati in Jupyterlab notebook

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.

Introduzione

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.

Limiti dei dati per notebook

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 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à, vedi PySpark o Scala tabelle a limiti di dati 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 (circa 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 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.

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.

PySpark (Python kernel) limiti dei dati del notebook:

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.

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.

Spark Limiti dei dati del notebook (kernel Scala):

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.

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.

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 il JupyterLab Launcher all’interno della 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 a 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. 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.

• Utilizzo Scrivi dati nel notebook per generare una cella di scrittura con il set di dati selezionato.
• Utilizzo Esplorare i dati nel notebook per generare una cella di lettura con il set di dati selezionato.
• Utilizzo Query dei dati nel blocco appunti per generare una cella di query di base con il set di dati selezionato.

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

Dati query utilizzati Query Service in Python

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}

Filtro ExperienceEvent dati

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

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 il JupyterLab Launcher all’interno della 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. 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.

• Utilizzo Scrivi dati nel notebook per generare una cella di scrittura con il set di dati selezionato.
• Utilizzo Esplorare i dati nel notebook 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')

Filtro ExperienceEvent dati

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

PySpark 3 notebook

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

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

Utilizzo di %dataset per leggere e scrivere con un blocco appunti PySpark 3

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

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. 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.

• Utilizzo Esplorare i dati nel notebook per generare una cella di lettura.
• Utilizzo 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. 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)

Filtro ExperienceEvent dati

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

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

Leggere un set di dati

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.

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. 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

• Utilizzo Esplorare i dati nel notebook per generare una cella di lettura.
• Utilizzo 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, 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.

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. Ad esempio:

sparkdf.createOrReplaceTempView("sparkdf")

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

Filtro ExperienceEvent dati

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

Passaggi successivi

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.

Flag SQL facoltativi per Query Service

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

Risorse Business.Adobe.com