Cada núcleo soportado proporciona funcionalidades incorporadas que permiten leer datos de Platform desde un conjunto de datos dentro de un bloc de notas. Actualmente, JupyterLab en Adobe Experience Platform Data Science Workspace admite portátiles para Python, R, PySpark y Scala. Sin embargo, la compatibilidad con la paginación de datos se limita a los Python y los portátiles R. Esta guía se centra en cómo utilizar los portátiles JupyterLab para acceder a sus datos.
Antes de leer esta guía, consulte la JupyterLab guía del usuario para obtener una introducción de alto nivel a JupyterLab y su función dentro de Data Science Workspace.
Para los blocs de notas PySpark y Scala si recibe un error con el motivo "Cliente RPC remoto desasociado". Esto suele significar que el controlador o un ejecutor se está quedando sin memoria. Intente cambiar al modo "batch" para resolver este error.
La siguiente información define la cantidad máxima de datos que se pueden leer, qué tipo de datos se han utilizado y el intervalo de tiempo estimado que se tarda en leer los datos.
Para Python y R, se utilizó un servidor portátil configurado con 40 GB de RAM para los puntos de referencia. Para PySpark y Scala, se utilizó un clúster de databricks configurado en 64 GB de RAM, 8 núcleos, 2 DBU con un máximo de 4 trabajadores para los puntos de referencia descritos a continuación.
Los datos de esquema de ExperienceEvent utilizados variaron en su tamaño a partir de mil filas (1K) de hasta mil millones de filas (1B). Tenga en cuenta que para las métricas PySpark y Spark se ha utilizado un intervalo de fechas de 10 días para los datos XDM.
Los datos de esquema ad hoc se preprocesaron utilizando Query Service Crear tabla como selección (CTAS). Estos datos también variaron en el tamaño a partir de mil filas (1K) que oscilaban entre mil millones de filas (1B).
Al leer conjuntos de datos con portátiles PySpark y Scala, tiene la opción de utilizar el modo interactivo o el modo por lotes para leer el conjunto de datos. Interactive se realiza para obtener resultados rápidos, mientras que el modo por lotes es para conjuntos de datos grandes.
Esquema XDM ExperienceEvent: debería poder leer un máximo de 2 millones de filas (unos 6,1 GB de datos en disco) de datos XDM en menos de 22 minutos. La adición de filas adicionales puede provocar errores.
Número de filas | 1K | 10K | 100K | 1M | 2M |
---|---|---|---|---|---|
Tamaño en disco (MB) | 18,73 | 187,5 | 308 | 3000 | 6050 |
SDK (en segundos) | 20,3 | 86,8 | 63 | 659 | 1315 |
esquema ad hoc: debe poder leer un máximo de 5 millones de filas (~5,6 GB de datos en disco) de datos que no sean XDM (ad-hoc) en menos de 14 minutos. La adición de filas adicionales puede provocar errores.
Número de filas | 1K | 10K | 100 K | 1M | 2M | 3M | 5M |
---|---|---|---|---|---|---|---|
Tamaño en disco (en MB) | 1,21 | 11,72 | 115 | 1120 | 2250 | 3380 | 5630 |
SDK (en segundos) | 7,27 | 9,04 | 27,3 | 180 | 346 | 487 | 819 |
Esquema XDM ExperienceEvent: debería poder leer un máximo de 1 millón de filas de datos XDM (datos de 3 GB en disco) en menos de 13 minutos.
Número de filas | 1K | 10K | 100 K | 1M |
---|---|---|---|---|
Tamaño en disco (MB) | 18,73 | 187,5 | 308 | 3000 |
Núcleo R (en segundos) | 14,03 | 69,6 | 86,8 | 775 |
esquema ad hoc: debe poder leer un máximo de 3 millones de filas de datos ad hoc (datos de 293 MB en disco) en unos 10 minutos.
Número de filas | 1K | 10K | 100 K | 1M | 2M | 3M |
---|---|---|---|---|---|---|
Tamaño en disco (en MB) | 0,082 | 0,612 | 9.0 | 91 | 188 | 293 |
SDK R (en segundos) | 7,7 | 4,58 | 35,9 | 233 | 470,5 | 603 |
Esquema XDM ExperienceEvent: en el modo interactivo debe poder leer un máximo de 5 millones de filas (unos 13,42 GB de datos en disco) de datos XDM en unos 20 minutos. El modo interactivo solo admite hasta 5 millones de filas. Si desea leer conjuntos de datos más grandes, se sugiere cambiar al modo por lotes. En el modo por lotes, debería poder leer un máximo de 500 millones de filas (unos 1,31 TB de datos en disco) de datos XDM en unas 14 horas.
Número de filas | 1K | 10K | 100 K | 1M | 2M | 3M | 5M | 10M | 50 M | 100 M | 500 M |
---|---|---|---|---|---|---|---|---|---|---|---|
Tamaño en 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 (modo interactivo) | 33s | 32,4 s | 55.1s | 253,5 s | 489,2 | 729,6 s | 1206,8 s | - | - | - | - |
SDK (modo por lotes) | 815,8 s | 492,8 s | 379,1s | 637,4 s | 624,5 s | 869,2 | 1104.1s | 1786s | 5387,2 s | 10624,6s | 50547s |
esquema ad hoc: En el modo interactivo, debe poder leer un máximo de 5 millones de filas (unos 5,36 GB de datos en disco) de datos que no sean XDM en menos de 3 minutos. En el modo Lote, debería poder leer un máximo de 100 millones de filas (unos 1,05 TB de datos en disco) de datos que no sean XDM en unos 18 minutos.
Número de filas | 1K | 10K | 100 K | 1M | 2M | 3M | 5M | 10M | 50 M | 100 M | 500 M | 1B |
---|---|---|---|---|---|---|---|---|---|---|---|---|
Tamaño en 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 |
Modo interactivo del SDK (en segundos) | 28,2 s | 18,6 s | 20,8 s | 20,9s | 23,8 s | 21,7 s | 24,7 s | - | - | - | - | - |
Modo por lotes de SDK (en segundos) | 428,8 s | 578,8 s | 641,4 s | 538,5 s | 630,9s | 467,3 s | 411s | 675s | 702s | 719,2 | 1022.1s | 1122,3s |
Esquema XDM ExperienceEvent: en el modo interactivo debe poder leer un máximo de 5 millones de filas (unos 13,42 GB de datos en disco) de datos XDM en unos 18 minutos. El modo interactivo solo admite hasta 5 millones de filas. Si desea leer conjuntos de datos más grandes, se sugiere cambiar al modo por lotes. En el modo por lotes, debería poder leer un máximo de 500 millones de filas (unos 1,31 TB de datos en disco) de datos XDM en unas 14 horas.
Número de filas | 1K | 10K | 100 K | 1M | 2M | 3M | 5M | 10M | 50 M | 100 M | 500 M |
---|---|---|---|---|---|---|---|---|---|---|---|
Tamaño en 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 |
Modo interactivo del SDK (en segundos) | 37,9 s | 22,7 s | 45,6 s | 231,7 s | 444,7 s | 660,6 s | 1100s | - | - | - | - |
Modo por lotes de SDK (en segundos) | 374,4 s | 398,5 s | 527s | 487,9s | 588,9s | 829s | 939.1s | 1441s | 5473,2 s | 10118,8 | 49207,6 |
esquema ad hoc: En el modo interactivo, debe poder leer un máximo de 5 millones de filas (unos 5,36 GB de datos en disco) de datos que no sean XDM en menos de 3 minutos. En el modo por lotes, debería poder leer un máximo de 100 millones de filas (unos 1,05 TB de datos en disco) de datos que no sean XDM en unos 16 minutos.
Número de filas | 1K | 10K | 100 K | 1M | 2M | 3M | 5M | 10M | 50 M | 100 M | 500 M | 1B |
---|---|---|---|---|---|---|---|---|---|---|---|---|
Tamaño en 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 |
Modo interactivo del SDK (en segundos) | 35,7 s | 31s | 19,5 s | 25,3 s | 23s | 33,2 s | 25,5 s | - | - | - | - | - |
Modo por lotes de SDK (en segundos) | 448,8 s | 459,7 s | 519s | 475,8 s | 599,9s | 347,6 s | 407,8 s | 397s | 518,8 s | 487,9s | 760,2 s | 975,4 s |
Python los blocs de notas permiten paginar datos al acceder a conjuntos de datos. A continuación se muestra el código de muestra para leer datos con o sin paginación. Para obtener más información sobre los portátiles Python de inicio disponibles, visite la sección JupyterLab Launcher dentro de la guía del usuario de JupyterLab.
La documentación de Python a continuación describe los siguientes conceptos:
Sin paginación:
Al ejecutar el siguiente código se leerá todo el conjunto de datos. Si la ejecución se realiza correctamente, los datos se guardarán como un dataframe de Pandas al que hace referencia la variable df
.
# Python
from platform_sdk.dataset_reader import DatasetReader
dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.read()
df.head()
Con paginación:
Al ejecutar el siguiente código se leerán los datos del conjunto de datos especificado. La paginación se logra limitando y compensando los datos a través de las funciones limit()
y offset()
respectivamente. La limitación de datos se refiere al número máximo de puntos de datos que se deben leer, mientras que la compensación se refiere al número de puntos de datos que se deben omitir antes de leer los datos. Si la operación de lectura se ejecuta correctamente, los datos se guardarán como un dataframe de Pandas al que hace referencia la variable df
.
# Python
from platform_sdk.dataset_reader import DatasetReader
dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.limit(100).offset(10).read()
Para escribir en un conjunto de datos en su bloc de notas de JupyterLab, seleccione la pestaña Icono de datos (resaltado abajo) en la navegación izquierda de JupyterLab. Aparecen los directorios Datasets y schemas. Seleccione Datasets y haga clic con el botón derecho y, a continuación, seleccione la opción Escribir datos en el bloc de notas en el menú desplegable del conjunto de datos que desee utilizar. Aparece una entrada de código ejecutable en la parte inferior del bloc de notas.
Como alternativa, puede copiar y pegar la siguiente celda de código. Reemplace {DATASET_ID}
y {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 on Platform permite utilizar SQL en un Python bloc de notas para acceder a los datos a través del servicio de consulta de Adobe Experience Platform. El acceso a los datos a través de Query Service puede resultar útil para tratar con conjuntos de datos grandes debido a sus tiempos de ejecución superiores. Tenga en cuenta que la consulta de datos mediante Query Service tiene un límite de tiempo de procesamiento de diez minutos.
Antes de utilizar Query Service en JupyterLab, asegúrese de tener una comprensión práctica de la sintaxis Query Service SQL.
Para realizar consultas de datos mediante Query Service es necesario proporcionar el nombre del conjunto de datos de destino. Puede generar las celdas de código necesarias buscando el conjunto de datos deseado mediante el Explorador de datos. Haga clic con el botón derecho en la lista de conjuntos de datos y haga clic en Query Data in Notebook para generar dos celdas de código en el bloc de notas. Estas dos celdas se describen con más detalle a continuación.
Para utilizar Query Service en JupyterLab, primero debe crear una conexión entre el bloc de notas Python en funcionamiento y Query Service. Esto se puede lograr ejecutando la primera celda generada.
qs_connect()
En la segunda celda generada, la primera línea debe definirse antes que la consulta SQL. De forma predeterminada, la celda generada define una variable opcional (df0
) que guarda los resultados de la consulta como un dataframe de Pandas.
El -c QS_CONNECTION
argumento es obligatorio y le indica al núcleo que ejecute la consulta SQL con Query Service. Consulte el apéndice para obtener una lista de argumentos adicionales.
%%read_sql df0 -c QS_CONNECTION
SELECT *
FROM name_of_the_dataset
LIMIT 10
/* Querying table "name_of_the_dataset" (datasetId: {DATASET_ID})*/
Se puede hacer referencia a las variables Python directamente dentro de una consulta SQL utilizando sintaxis con formato de cadena y ajustando las variables entre llaves ({}
), como se muestra en el siguiente ejemplo:
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}
Para acceder y filtrar un conjunto de datos ExperienceEvent en un bloc de notas Python, debe proporcionar el ID del conjunto de datos ({DATASET_ID}
) junto con las reglas de filtro que definen un intervalo de tiempo específico mediante operadores lógicos. Cuando se define un intervalo de tiempo, se ignora cualquier paginación especificada y se considera todo el conjunto de datos.
A continuación se describe una lista de operadores de filtrado:
eq()
: Equal togt()
: Greater thange()
: Greater than or equal tolt()
: Less thanle()
: Less than or equal toAnd()
: Operador AND lógicoOr()
: Operador OR lógicoLa siguiente celda filtra un conjunto de datos ExperienceEvent a los datos existentes exclusivamente entre el 1 de enero de 2019 y finales del 31 de diciembre de 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()
Los portátiles R permiten paginar los datos al acceder a los conjuntos de datos. A continuación se muestra el código de muestra para leer datos con o sin paginación. Para obtener más información sobre los portátiles R de inicio disponibles, visite la sección JupyterLab Launcher dentro de la guía del usuario de JupyterLab.
La documentación R que aparece a continuación describe los siguientes conceptos:
Sin paginación:
Al ejecutar el siguiente código se leerá todo el conjunto de datos. Si la ejecución se realiza correctamente, los datos se guardarán como un dataframe de Pandas al que hace referencia la variable df0
.
# R
library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")
DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df0 <- dataset_reader$read()
head(df0)
Con paginación:
Al ejecutar el siguiente código se leerán los datos del conjunto de datos especificado. La paginación se logra limitando y compensando los datos a través de las funciones limit()
y offset()
respectivamente. La limitación de datos se refiere al número máximo de puntos de datos que se deben leer, mientras que la compensación se refiere al número de puntos de datos que se deben omitir antes de leer los datos. Si la operación de lectura se ejecuta correctamente, los datos se guardarán como un dataframe de Pandas al que hace referencia la variable df0
.
# R
library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")
DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df0 <- dataset_reader$limit(100L)$offset(10L)$read()
Para escribir en un conjunto de datos en su bloc de notas de JupyterLab, seleccione la pestaña Icono de datos (resaltado abajo) en la navegación izquierda de JupyterLab. Aparecen los directorios Datasets y schemas. Seleccione Datasets y haga clic con el botón derecho y, a continuación, seleccione la opción Escribir datos en el bloc de notas en el menú desplegable del conjunto de datos que desee utilizar. Aparece una entrada de código ejecutable en la parte inferior del bloc de notas.
Como alternativa, puede copiar y pegar la siguiente celda de código:
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')
Para acceder y filtrar un conjunto de datos ExperienceEvent en un bloc de notas R, debe proporcionar el ID del conjunto de datos ({DATASET_ID}
) junto con las reglas de filtro que definen un intervalo de tiempo específico mediante operadores lógicos. Cuando se define un intervalo de tiempo, se ignora cualquier paginación especificada y se considera todo el conjunto de datos.
A continuación se describe una lista de operadores de filtrado:
eq()
: Igual agt()
: Bueno quege()
: Bueno que o igual alt()
: Less thanle()
: Less than or equal toAnd()
: Operador AND lógicoOr()
: Operador OR lógicoLa siguiente celda filtra un conjunto de datos ExperienceEvent a los datos existentes exclusivamente entre el 1 de enero de 2019 y finales del 31 de diciembre de 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 siguiente documentación de PySpark describe los siguientes conceptos:
Todos los Spark blocs de notas 2.4 requieren que inicialice la sesión con el siguiente código repetitivo.
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
Con la introducción de Spark 2.4, %dataset
la magia personalizada se suministra para su uso en portátiles PySpark 3 (Spark 2.4). Para obtener más información sobre los comandos mágicos disponibles en el núcleo IPython, visite la documentación mágica de IPython.
Uso
%dataset {action} --datasetId {id} --dataFrame {df} --mode batch
Descripción
Un comando mágico personalizado Data Science Workspace para leer o escribir un conjunto de datos de un bloc de notas PySpark (Python 3 kernel).
Nombre | Descripción | Requerido |
---|---|---|
{action} |
Tipo de acción que se realizará en el conjunto de datos. Hay dos acciones disponibles: "leer" o "escribir". | Sí |
--datasetId {id} |
Se utiliza para proporcionar el ID del conjunto de datos para leer o escribir. | Sí |
--dataFrame {df} |
Los pandas dataframe.
|
Sí |
--mode |
Un parámetro adicional que cambia la forma en que se leen los datos. Los parámetros permitidos son "por lotes" e "interactivo". De forma predeterminada, el modo está configurado en "batch". Se recomienda el modo "interactivo" para aumentar el rendimiento de la consulta en conjuntos de datos más pequeños. |
Sí |
Revise las tablas PySpark en la sección límites de datos del bloc de notas para determinar si mode
debe establecerse en interactive
o batch
.
Ejemplos
%dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0 --mode batch
%dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0 --mode batch
El almacenamiento en caché de datos mediante df.cache()
antes de escribir datos puede mejorar considerablemente el rendimiento del bloc de notas. Esto puede ayudarle si está recibiendo cualquiera de los siguientes errores:
Consulte la guía de solución de problemas para obtener más información.
Puede generar automáticamente los ejemplos anteriores en JupyterLab buy utilizando el siguiente método:
Seleccione la pestaña Icono de datos (resaltado abajo) en la navegación izquierda de JupyterLab. Aparecen los directorios Datasets y schemas. Seleccione Datasets y haga clic con el botón derecho y, a continuación, seleccione la opción Escribir datos en el bloc de notas en el menú desplegable del conjunto de datos que desee utilizar. Aparece una entrada de código ejecutable en la parte inferior del bloc de notas.
Para crear un dataframe local utilizando PySpark 3, utilice consultas SQL. Por ejemplo:
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)
También puede especificar una muestra de origen opcional, como un booleano con Sustitución, fracción doble o una semilla larga.
El acceso y el filtrado de un conjunto de datos ExperienceEvent en un bloc de notas de PySpark requiere que proporcione la identidad del conjunto de datos ({DATASET_ID}
), la identidad IMS de su organización y las reglas de filtro que definan un intervalo de tiempo específico. Un intervalo de tiempo de filtrado se define mediante la función spark.sql()
, donde el parámetro de función es una cadena de consulta SQL.
Las siguientes celdas filtran un conjunto de datos ExperienceEvent a los datos existentes exclusivamente entre el 1 de enero de 2019 y finales del 31 de diciembre de 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 documentación siguiente contiene ejemplos de los siguientes conceptos:
Todos los blocs de notas Scala requieren que inicialice la sesión con el siguiente código repetitivo:
import org.apache.spark.sql.{ SparkSession }
val spark = SparkSession
.builder()
.master("local")
.getOrCreate()
En Scala, puede importar clientContext
para obtener y devolver valores de Platform, lo que elimina la necesidad de definir variables como var userToken
. En el ejemplo de Scala que se muestra a continuación, clientContext
se utiliza para obtener y devolver todos los valores necesarios para leer un conjunto de datos.
El almacenamiento en caché de datos mediante df.cache()
antes de escribir datos puede mejorar considerablemente el rendimiento del bloc de notas. Esto puede ayudarle si está recibiendo cualquiera de los siguientes errores:
Consulte la guía de solución de problemas para obtener más información.
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 | Descripción |
---|---|
df1 | Variable que representa el dataframe de Pandas utilizado para leer y escribir datos. |
user-token | El token de usuario que se obtiene automáticamente mediante clientContext.getUserToken() . |
service-token | El token de servicio que se obtiene automáticamente mediante clientContext.getServiceToken() . |
ims-org | El ID de organización de IMS que se obtiene automáticamente mediante clientContext.getOrgId() . |
api-key | La clave de API que se obtiene automáticamente mediante clientContext.getApiKey() . |
Revise las tablas Scala de la sección límites de datos del bloc de notas para determinar si mode
debe establecerse en interactive
o batch
.
Puede generar automáticamente el ejemplo anterior en JupyterLab buy utilizando el siguiente método:
Seleccione la pestaña Icono de datos (resaltado abajo) en la navegación izquierda de JupyterLab. Aparecen los directorios Datasets y schemas. Seleccione Datasets y haga clic con el botón derecho y, a continuación, seleccione la opción Explorar datos en el bloc de notas en el menú desplegable del conjunto de datos que desee utilizar. Aparece una entrada de código ejecutable en la parte inferior del bloc de notas.
Y
En Scala, puede importar clientContext
para obtener y devolver valores de Platform, lo que elimina la necesidad de definir variables como var userToken
. En el ejemplo Scala que se muestra a continuación, clientContext
se utiliza para definir y devolver todos los valores necesarios para escribir en un conjunto de datos.
El almacenamiento en caché de datos mediante df.cache()
antes de escribir datos puede mejorar considerablemente el rendimiento del bloc de notas. Esto puede ayudarle si está recibiendo cualquiera de los siguientes errores:
Consulte la guía de solución de problemas para obtener más información.
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()
Elemento | descripción |
---|---|
df1 | Variable que representa el dataframe de Pandas utilizado para leer y escribir datos. |
user-token | El token de usuario que se obtiene automáticamente mediante clientContext.getUserToken() . |
service-token | El token de servicio que se obtiene automáticamente mediante clientContext.getServiceToken() . |
ims-org | El ID de organización de IMS que se obtiene automáticamente mediante clientContext.getOrgId() . |
api-key | La clave de API que se obtiene automáticamente mediante clientContext.getApiKey() . |
Revise las tablas Scala de la sección límites de datos del bloc de notas para determinar si mode
debe establecerse en interactive
o batch
.
Para crear un dataframe local mediante Scala, se requieren consultas SQL. Por ejemplo:
sparkdf.createOrReplaceTempView("sparkdf")
val localdf = spark.sql("SELECT * FROM sparkdf LIMIT 1)
El acceso y el filtrado de un conjunto de datos ExperienceEvent en un bloc de notas Scala requiere que proporcione la identidad del conjunto de datos ({DATASET_ID}
), la identidad IMS de su organización y las reglas de filtro que definan un intervalo de tiempo específico. Un intervalo de tiempo de filtrado se define mediante la función spark.sql()
, donde el parámetro de función es una cadena de consulta SQL.
Las siguientes celdas filtran un conjunto de datos ExperienceEvent a los datos existentes exclusivamente entre el 1 de enero de 2019 y finales del 31 de diciembre de 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()
Este documento abarcaba las directrices generales para acceder a conjuntos de datos mediante blocs de notas de JupyterLab. Para obtener ejemplos más detallados sobre la consulta de conjuntos de datos, visite la documentación Query Service in JupyterLab blocs de notas . Para obtener más información sobre cómo explorar y visualizar sus conjuntos de datos, visite el documento sobre análisis de sus datos mediante blocs de notas.
Esta tabla describe los indicadores SQL opcionales que se pueden utilizar para Query Service.
Indicador | Descripción |
---|---|
-h , --help |
Mostrar el mensaje de ayuda y salir. |
-n , --notify |
Alterne la opción para notificar los resultados de la consulta. |
-a , --async |
El uso de este indicador ejecuta la consulta asincrónicamente y puede liberar el núcleo mientras se ejecuta la consulta. Tenga cuidado al asignar resultados de consulta a variables, ya que puede no estar definido si la consulta no se ha completado. |
-d , --display |
El uso de este indicador evita que se muestren los resultados. |