Cada kernel suportado fornece funcionalidades integradas que permitem ler os dados da plataforma de um conjunto de dados em um notebook. Atualmente, o JupyterLab no Espaço de trabalho de ciência de dados da Adobe Experience Platform oferece suporte a notebooks para Python, R, PySpark e Scala. No entanto, o suporte para dados de paginação está limitado a Python e notebooks R. Este guia tem como foco o uso de notebooks JupyterLab para acessar seus dados.
Antes de ler este guia, consulte o JupyterLab guia do usuário para obter uma introdução geral ao JupyterLab e sua função no Espaço de trabalho de ciência de dados.
Para notebooks PySpark e Scala, se você estiver recebendo um erro com o motivo "Cliente RPC remoto desassociado". Normalmente, isso significa que o driver ou um executor está ficando sem memória. Tente alternar para modo "batch" para resolver esse erro.
As informações a seguir definem a quantidade máxima de dados que podem ser lidos, que tipo de dados foi usado e o período estimado para ler os dados.
Para Python e R, um servidor notebook configurado com 40 GB de RAM foi usado para os benchmarks. Para o PySpark e Scala, um cluster de databricks configurado em 64 GB de RAM, 8 núcleos, 2 DBUs com um máximo de 4 trabalhadores foi usado para os benchmarks descritos abaixo.
Os dados do esquema ExperienceEvent usados variaram em tamanho, começando em mil (1K) linhas, variando até um bilhão (1B) de linhas. Observe que para o PySpark e Spark métricas, um período de 10 dias foi usado para os dados XDM.
Os dados do esquema ad-hoc foram pré-processados usando Query Service Criar Tabela como Seleção (CTAS). Esses dados também variaram em tamanho, começando com mil (1K) linhas variando até um bilhão (1B) de linhas.
Ao ler conjuntos de dados com notebooks PySpark e Scala, você tem a opção de usar o modo interativo ou o modo em lote para ler o conjunto de dados. Interativo é feito para resultados rápidos, enquanto o modo de lote é para conjuntos de dados grandes.
Esquema XDM ExperienceEvent: Você deve ser capaz de ler um máximo de 2 milhões de linhas (aproximadamente 6,1 GB de dados no disco) de dados XDM em menos de 22 minutos. A adição de linhas adicionais pode resultar em erros.
Número de linhas | 1 mil | 10 mil | 100 mil | 1M | 2M |
---|---|---|---|---|---|
Tamanho no disco (MB) | 18.73 | 187.5 | 308 | 3000 | 6050 |
SDK (em segundos) | 20.3 | 86.8 | 63 | 659 | 1315 |
esquema ad-hoc: Você deve ser capaz de ler no máximo 5 milhões de linhas (cerca de 5,6 GB de dados no disco) de dados não XDM (ad-hoc) em menos de 14 minutos. A adição de linhas adicionais pode resultar em erros.
Número de linhas | 1 mil | 10 mil | 100 mil | 1M | 2M | 3M | 5M |
---|---|---|---|---|---|---|---|
Tamanho no disco (em MB) | 1.21 | 11.72 | 115 | 1120 | 2250 | 3380 | 5630 |
SDK (em segundos) | 7.27 | 9.04 | 27.3 | 180 | 346 | 487 | 819 |
Esquema XDM ExperienceEvent: Você deve conseguir ler no máximo 1 milhão de linhas de dados XDM (dados de 3 GB no disco) em menos de 13 minutos.
Número de linhas | 1 mil | 10 mil | 100 mil | 1M |
---|---|---|---|---|
Tamanho no disco (MB) | 18.73 | 187.5 | 308 | 3000 |
R Kernel (em segundos) | 14.03 | 69.6 | 86.8 | 775 |
esquema ad-hoc: Você poderá ler no máximo 3 milhões de linhas de dados ad-hoc (293 MB de dados no disco) em cerca de 10 minutos.
Número de linhas | 1 mil | 10 mil | 100 mil | 1M | 2M | 3M |
---|---|---|---|---|---|---|
Tamanho no disco (em MB) | 0.082 | 0.612 | 9.0 | 91 | 188 | 293 |
R SDK (em segundos) | 7.7 | 4.58 | 35.9 | 233 | 470.5 | 603 |
Esquema XDM ExperienceEvent: No modo interativo, você deve ser capaz de ler um máximo de 5 milhões de linhas (aproximadamente 13,42 GB de dados no disco) de dados XDM em cerca de 20 minutos. O modo interativo suporta apenas até 5 milhões de linhas. Se você quiser ler conjuntos de dados maiores, sugerimos mudar para o modo de lote. No modo de lote, você deve ser capaz de ler um máximo de 500 milhões de linhas (aproximadamente 1,31 TB de dados no disco) de dados XDM em cerca de 14 horas.
Número de linhas | 1 mil | 10 mil | 100 mil | 1M | 2M | 3M | 5M | 10M | 50M | 100M | 500M |
---|---|---|---|---|---|---|---|---|---|---|---|
Tamanho no disco | 2.93MB | 4.38MB | 29.02 | 2.69 GB | 5.39 GB | 8.09 GB | 13.42 GB | 26.82 GB | 134.24 GB | 268.39 GB | 1.31TB |
SDK (Modo interativo) | 33s | 32.4s | 55.1s | 253.5s | 489.2s | 729.6s | 1206.8s | - | - | - | - |
SDK (Modo de lote) | 815.8s | 492.8s | 379.1s | 637.4s | 624.5s | 869.2s | 1104.1s | 1786s | 5387.2s | 10624.6s | 50547s |
esquema ad-hoc: No modo Interativo, você deve ser capaz de ler um máximo de 5 milhões de linhas (aproximadamente 5,36 GB de dados no disco) de dados não XDM em menos de 3 minutos. No modo de Lote, você deve ser capaz de ler no máximo 1 bilhão de linhas (aproximadamente 1,05 TB de dados no disco) de dados não XDM em cerca de 18 minutos.
Número de linhas | 1 mil | 10 mil | 100 mil | 1M | 2M | 3M | 5M | 10M | 50M | 100M | 500M | 1B |
---|---|---|---|---|---|---|---|---|---|---|---|---|
Tamanho no disco | 1.12MB | 11.24MB | 109.48MB | 2.69 GB | 2.14 GB | 3.21 GB | 5.36 GB | 10.71 GB | 53.58 GB | 107.52 GB | 535.88 GB | 1.05TB |
Modo interativo do SDK (em segundos) | 28.2s | 18.6s | 20.8s | 20.9s | 23.8s | 21.7s | 24.7s | - | - | - | - | - |
Modo de lote do SDK (em segundos) | 428.8s | 578.8s | 641.4s | 538.5s | 630.9s | 467.3s | 411s | 675s | 702s | 719.2s | 1022.1s | 1122.3s |
Esquema XDM ExperienceEvent: No modo interativo, você deve ser capaz de ler um máximo de 5 milhões de linhas (aproximadamente 13,42 GB de dados no disco) de dados XDM em cerca de 18 minutos. O modo interativo suporta apenas até 5 milhões de linhas. Se você quiser ler conjuntos de dados maiores, sugerimos mudar para o modo de lote. No modo de lote, você deve ser capaz de ler um máximo de 500 milhões de linhas (aproximadamente 1,31 TB de dados no disco) de dados XDM em cerca de 14 horas.
Número de linhas | 1 mil | 10 mil | 100 mil | 1M | 2M | 3M | 5M | 10M | 50M | 100M | 500M |
---|---|---|---|---|---|---|---|---|---|---|---|
Tamanho no disco | 2.93MB | 4.38MB | 29.02 | 2.69 GB | 5.39 GB | 8.09 GB | 13.42 GB | 26.82 GB | 134.24 GB | 268.39 GB | 1.31TB |
Modo interativo do SDK (em segundos) | 37.9s | 22.7s | 45.6s | 231.7s | 444.7s | 660.6s | 1100s | - | - | - | - |
Modo de lote do SDK (em segundos) | 374.4s | 398.5s | 527s | 487.9s | 588.9s | 829s | 939.1s | 1441s | 5473.2s | 10118.8 | 49207.6 |
esquema ad-hoc: No modo interativo, você deve ser capaz de ler um máximo de 5 milhões de linhas (aproximadamente 5,36 GB de dados no disco) de dados não XDM em menos de 3 minutos. No modo de lote, você deve ser capaz de ler no máximo 1 bilhão de linhas (aproximadamente 1,05 TB de dados no disco) de dados não XDM em cerca de 16 minutos.
Número de linhas | 1 mil | 10 mil | 100 mil | 1M | 2M | 3M | 5M | 10M | 50M | 100M | 500M | 1B |
---|---|---|---|---|---|---|---|---|---|---|---|---|
Tamanho no disco | 1.12MB | 11.24MB | 109.48MB | 2.69 GB | 2.14 GB | 3.21 GB | 5.36 GB | 10.71 GB | 53.58 GB | 107.52 GB | 535.88 GB | 1.05TB |
Modo interativo do SDK (em segundos) | 35.7s | 31s | 19.5s | 25.3s | 23s | 33.2s | 25.5s | - | - | - | - | - |
Modo de lote do SDK (em segundos) | 448.8s | 459.7s | 519s | 475.8s | 599.9s | 347.6s | 407.8s | 397s | 518.8s | 487.9s | 760.2s | 975.4s |
Python Os blocos de anotações permitem paginar dados ao acessar conjuntos de dados. A amostra de código para ler dados com e sem paginação é demonstrada abaixo. Para obter mais informações sobre os notebooks iniciais Python disponíveis, visite o JupyterLab Iniciador seção no guia do usuário do JupyterLab.
A documentação do Python abaixo descreve os seguintes conceitos:
Sem paginação:
A execução do código a seguir lerá todo o conjunto de dados. Se a execução for bem-sucedida, os dados serão salvos como um quadro de dados Pandas referenciado pela variável 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()
Com paginação:
A execução do código a seguir lerá os dados do conjunto de dados especificado. A paginação é alcançada limitando e compensando dados por meio das funções limit()
e offset()
respectivamente. A limitação de dados refere-se ao número máximo de pontos de dados a serem lidos, enquanto a compensação se refere ao número de pontos de dados a serem ignorados antes da leitura dos dados. Se a operação de leitura for executada com êxito, os dados serão salvos como um quadro de dados Pandas referenciado pela variável 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 gravar em um conjunto de dados no notebook JupyterLab, selecione a guia Data icon (destacada abaixo) na navegação à esquerda do JupyterLab. A variável Conjuntos de dados e Esquemas serão exibidos diretórios. Selecionar Conjuntos de dados e clique com o botão direito do mouse, em seguida, selecione a Gravar dados no notebook no menu suspenso do conjunto de dados que você deseja usar. Uma entrada de código executável é exibida na parte inferior do bloco de anotações.
Como alternativa, você pode copiar e colar a seguinte célula de código. Substitua ambos {DATASET_ID}
e {PANDA_DATAFRAME}
.
from platform_sdk.models import Dataset
from platform_sdk.dataset_writer import DatasetWriter
dataset = Dataset(get_platform_sdk_client_context()).get_by_id(dataset_id="{DATASET_ID}")
dataset_writer = DatasetWriter(get_platform_sdk_client_context(), dataset)
write_tracker = dataset_writer.write({PANDA_DATAFRAME}, file_format='json')
JupyterLab em Platform permite usar o SQL em uma Python notebook para acessar os dados por meio de Serviço de consulta Adobe Experience Platform. Acesso aos dados pelo Query Service pode ser útil para lidar com grandes conjuntos de dados devido aos seus tempos de execução superiores. Observe que consultar dados usando Query Service O tem um limite de tempo de processamento de dez minutos.
Antes de usar Query Service in JupyterLab, garanta um entendimento prático das Query Service Sintaxe SQL.
Consulta de dados usando Query Service exige que você forneça o nome do conjunto de dados de destino. Você pode gerar as células de código necessárias localizando o conjunto de dados desejado usando o Data Explorer. Clique com o botão direito na lista do conjunto de dados e clique em Consultar Dados no Notebook para gerar duas células de código no seu notebook. Estas duas células são descritas em mais detalhes abaixo.
Para utilizar Query Service in JupyterLab, você deve primeiro criar uma conexão entre seu Python notebook e Query Service. Isso pode ser feito executando a primeira célula gerada.
qs_connect()
Na segunda célula gerada, a primeira linha deve ser definida antes da consulta SQL. Por padrão, a célula gerada define uma variável (df0
) que salva os resultados da consulta como um quadro de dados Pandas.
A variável -c QS_CONNECTION
argumento é obrigatório e informa ao kernel para executar a consulta SQL em Query Service. Consulte a apêndice para obter uma lista de argumentos adicionais.
%%read_sql df0 -c QS_CONNECTION
SELECT *
FROM name_of_the_dataset
LIMIT 10
/* Querying table "name_of_the_dataset" (datasetId: {DATASET_ID})*/
As variáveis Python podem ser referenciadas diretamente em uma consulta SQL usando sintaxe formatada por string e colocando as variáveis entre chaves ({}
), conforme mostrado no exemplo a seguir:
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 acessar e filtrar um ExperienceEvent conjunto de dados em uma Python , você deve fornecer a ID do conjunto de dados ({DATASET_ID}
) junto com as regras de filtro que definem um intervalo de tempo específico usando operadores lógicos. Quando um intervalo de tempo é definido, qualquer paginação especificada é ignorada e todo o conjunto de dados é considerado.
Uma lista de operadores de filtragem é descrita abaixo:
eq()
: Equal togt()
: Greater thange()
: Maior que ou igual alt()
: Menos quele()
: Less than or equal toAnd()
: operador AND lógicoOr()
: operador OR lógicoA célula a seguir filtra um ExperienceEvent aos dados existentes exclusivamente entre 1 de janeiro de 2019 e o final de 31 de dezembro 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()
Os blocos de anotações R permitem paginar dados ao acessar conjuntos de dados. A amostra de código para ler dados com e sem paginação é demonstrada abaixo. Para obter mais informações sobre os notebooks iniciais R disponíveis, visite a JupyterLab Iniciador seção no guia do usuário do JupyterLab.
A documentação do R abaixo descreve os seguintes conceitos:
Sem paginação:
A execução do código a seguir lerá todo o conjunto de dados. Se a execução for bem-sucedida, os dados serão salvos como um quadro de dados Pandas referenciado pela variável 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)
Com paginação:
A execução do código a seguir lerá os dados do conjunto de dados especificado. A paginação é alcançada limitando e compensando dados por meio das funções limit()
e offset()
respectivamente. A limitação de dados refere-se ao número máximo de pontos de dados a serem lidos, enquanto a compensação se refere ao número de pontos de dados a serem ignorados antes da leitura dos dados. Se a operação de leitura for executada com êxito, os dados serão salvos como um quadro de dados Pandas referenciado pela variável 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 gravar em um conjunto de dados no notebook JupyterLab, selecione a guia Data icon (destacada abaixo) na navegação à esquerda do JupyterLab. A variável Conjuntos de dados e Esquemas serão exibidos diretórios. Selecionar Conjuntos de dados e clique com o botão direito do mouse, em seguida, selecione a Gravar dados no notebook no menu suspenso do conjunto de dados que você deseja usar. Uma entrada de código executável é exibida na parte inferior do bloco de anotações.
Como alternativa, você pode copiar e colar a seguinte célula 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 acessar e filtrar um ExperienceEvent em um bloco de anotações R, você deve fornecer a ID do conjunto de dados ({DATASET_ID}
) junto com as regras de filtro que definem um intervalo de tempo específico usando operadores lógicos. Quando um intervalo de tempo é definido, qualquer paginação especificada é ignorada e todo o conjunto de dados é considerado.
Uma lista de operadores de filtragem é descrita abaixo:
eq()
: Equal togt()
: Greater thange()
: Maior que ou igual alt()
: Menos quele()
: Less than or equal toAnd()
: operador AND lógicoOr()
: operador OR lógicoA célula a seguir filtra um ExperienceEvent aos dados existentes exclusivamente entre 1 de janeiro de 2019 e o final de 31 de dezembro 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()
A documentação do PySpark abaixo descreve os seguintes conceitos:
Todos Spark Os notebooks 2.4 exigem que você inicialize a sessão com o seguinte código padronizado.
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
Com a introdução do Spark 2.4, %dataset
mágica personalizada é fornecida para uso no PySpark 3 (Spark 2.4) notebooks. Para obter mais detalhes sobre comandos mágicos disponíveis no kernel do IPython, visite o Documentação mágica do IPython.
Uso
%dataset {action} --datasetId {id} --dataFrame {df} --mode batch
Descrição
Um personalizado Data Science Workspace comando mágico para ler ou gravar um conjunto de dados de um PySpark bloco de anotações (Python 3 kernel).
Nome | Descrição | Obrigatório |
---|---|---|
{action} |
O tipo de ação a ser executada no conjunto de dados. Duas ações estão disponíveis: "ler" ou "gravar". | Sim |
--datasetId {id} |
Usado para fornecer a ID do conjunto de dados para leitura ou gravação. | Sim |
--dataFrame {df} |
O quadro de dados dos pandas.
|
Sim |
--mode |
Um parâmetro adicional que altera como os dados são lidos. Os parâmetros permitidos são "batch" e "interativo". Por padrão, o modo é definido como "batch". Recomenda-se o modo "interativo" para melhorar o desempenho da consulta em conjuntos de dados menores. |
Sim |
Revise as tabelas do PySpark no limites de dados do notebook seção para determinar se mode
deve ser definido como interactive
ou batch
.
Exemplos
%dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0 --mode batch
%dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0 --mode batch
Armazenamento de dados em cache usando df.cache()
antes de gravar os dados pode melhorar muito o desempenho do notebook. Isso pode ajudar se você estiver recebendo qualquer um dos seguintes erros:
Consulte a guia de solução de problemas para obter mais informações.
Você pode gerar automaticamente os exemplos acima na compra do JupyterLab usando o seguinte método:
Selecione a guia Data icon (destacada abaixo) no menu de navegação esquerdo do JupyterLab. A variável Conjuntos de dados e Esquemas serão exibidos diretórios. Selecionar Conjuntos de dados e clique com o botão direito do mouse, em seguida, selecione a Gravar dados no notebook no menu suspenso do conjunto de dados que você deseja usar. Uma entrada de código executável é exibida na parte inferior do bloco de anotações.
Para criar um quadro de dados local usando o PySpark 3, use queries SQL. Por exemplo:
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)
Você também pode especificar uma amostra de seed opcional, como um booleano com Substituição, fração dupla ou uma seed longa.
Acessar e filtrar um ExperienceEvent conjunto de dados em um notebook PySpark requer que você forneça a identidade do conjunto de dados ({DATASET_ID}
), a identidade IMS de sua organização e as regras de filtro que definem um intervalo de tempo específico. Um intervalo de tempo de filtragem é definido usando a função spark.sql()
, onde o parâmetro da função é uma sequência de consulta SQL.
As seguintes células filtram um ExperienceEvent aos dados existentes exclusivamente entre 1 de janeiro de 2019 e o final de 31 de dezembro 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()
A documentação abaixo contém exemplos dos seguintes conceitos:
Todos os blocos de anotações Scala exigem que você inicialize a sessão com o seguinte código padrão:
import org.apache.spark.sql.{ SparkSession }
val spark = SparkSession
.builder()
.master("local")
.getOrCreate()
No Scala, você pode importar clientContext
para obter e retornar valores da Platform, elimina a necessidade de definir variáveis como var userToken
. No exemplo de Scala abaixo, clientContext
é usado para obter e retornar todos os valores necessários para ler um conjunto de dados.
Armazenamento de dados em cache usando df.cache()
antes de gravar os dados pode melhorar muito o desempenho do notebook. Isso pode ajudar se você estiver recebendo qualquer um dos seguintes erros:
Consulte a guia de solução de problemas para obter mais informações.
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 | Descrição |
---|---|
df1 | Uma variável que representa o quadro de dados Pandas usado para ler e gravar dados. |
user-token | O token do usuário que é buscado automaticamente usando clientContext.getUserToken() . |
service-token | O token de serviço que é buscado automaticamente usando clientContext.getServiceToken() . |
ims-org | A ID da organização que é buscada automaticamente usando o clientContext.getOrgId() . |
api-key | Sua chave de API é buscada automaticamente usando clientContext.getApiKey() . |
Revise as tabelas do Scala no limites de dados do notebook seção para determinar se mode
deve ser definido como interactive
ou batch
.
Você pode gerar automaticamente o exemplo acima na compra do JupyterLab usando o seguinte método:
Selecione a guia Data icon (destacada abaixo) no menu de navegação esquerdo do JupyterLab. A variável Conjuntos de dados e Esquemas serão exibidos diretórios. Selecionar Conjuntos de dados e clique com o botão direito do mouse, em seguida, selecione a Explorar dados no Notebook no menu suspenso do conjunto de dados que você deseja usar. Uma entrada de código executável é exibida na parte inferior do bloco de anotações.
E
No Scala, você pode importar clientContext
para obter e retornar valores da Platform, elimina a necessidade de definir variáveis como var userToken
. No exemplo de Scala abaixo, clientContext
é usado para definir e retornar todos os valores necessários para gravar em um conjunto de dados.
Armazenamento de dados em cache usando df.cache()
antes de gravar os dados pode melhorar muito o desempenho do notebook. Isso pode ajudar se você estiver recebendo qualquer um dos seguintes erros:
Consulte a guia de solução de problemas para obter mais informações.
import org.apache.spark.sql.{Dataset, SparkSession}
import com.adobe.platform.token.ClientContext
val spark = SparkSession.builder().master("local").config("spark.sql.warehouse.dir", "/").getOrCreate()
val clientContext = ClientContext.getClientContext()
df1.write.format("com.adobe.platform.query")
.option("user-token", clientContext.getUserToken())
.option("service-token", clientContext.getServiceToken())
.option("ims-org", clientContext.getOrgId())
.option("api-key", clientContext.getApiKey())
.option("sandbox-name", clientContext.getSandboxName())
.option("mode", "batch")
.option("dataset-id", "5e68141134492718af974844")
.save()
element | descrição |
---|---|
df1 | Uma variável que representa o quadro de dados Pandas usado para ler e gravar dados. |
user-token | O token do usuário que é buscado automaticamente usando clientContext.getUserToken() . |
service-token | O token de serviço que é buscado automaticamente usando clientContext.getServiceToken() . |
ims-org | A ID da organização que é buscada automaticamente usando o clientContext.getOrgId() . |
api-key | Sua chave de API é buscada automaticamente usando clientContext.getApiKey() . |
Revise as tabelas do Scala no limites de dados do notebook seção para determinar se mode
deve ser definido como interactive
ou batch
.
Para criar um quadro de dados local usando o Scala, são necessárias consultas SQL. Por exemplo:
sparkdf.createOrReplaceTempView("sparkdf")
val localdf = spark.sql("SELECT * FROM sparkdf LIMIT 1)
Acessar e filtrar um ExperienceEvent em um notebook Scala exige que você forneça a identidade do conjunto de dados ({DATASET_ID}
), a identidade IMS de sua organização e as regras de filtro que definem um intervalo de tempo específico. Um Intervalo de tempo de filtragem é definido com o uso da função spark.sql()
, onde o parâmetro da função é uma sequência de consulta SQL.
As seguintes células filtram um ExperienceEvent aos dados existentes exclusivamente entre 1 de janeiro de 2019 e o final de 31 de dezembro 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()
Esse documento abordou as diretrizes gerais para acessar conjuntos de dados usando notebooks JupyterLab. Para obter exemplos mais detalhados sobre como consultar conjuntos de dados, visite o Serviço de consulta em notebooks JupyterLab documentação. Para obter mais informações sobre como explorar e visualizar seus conjuntos de dados, visite o documento em analisar seus dados usando blocos de anotações.
Esta tabela descreve os sinalizadores SQL opcionais que podem ser usados para Query Service.
Sinalizador | Descrição |
---|---|
-h , --help |
Mostrar a mensagem de ajuda e sair. |
-n , --notify |
Alternar opção para notificar resultados da consulta. |
-a , --async |
O uso desse sinalizador executa a consulta de forma assíncrona e pode liberar o kernel enquanto a consulta é executada. Tenha cuidado ao atribuir resultados de consulta a variáveis, pois eles podem estar indefinidos se a consulta não estiver concluída. |
-d , --display |
O uso desse sinalizador impede que os resultados sejam exibidos. |