Acesso aos dados em Jupyterlab blocos de anotações

Cada kernel suportado fornece funcionalidades incorporadas que permitem ler dados da plataforma a partir de um conjunto de dados dentro de um notebook. Atualmente, o JupyterLab na Adobe Experience Platform Data Science Workspace suporta notebooks para Python, R, PySpark e Scala. No entanto, o suporte para paginação de dados está limitado aos notebooks Python e R. Este guia foca em como usar notebooks JupyterLab para acessar seus dados.

Introdução

Antes de ler este guia, reveja o JupyterLab guia do usuário para obter uma introdução de alto nível a JupyterLab e sua função na Data Science Workspace.

Limites de dados do notebook

IMPORTANTE

Para notebooks PySpark e Scala se você estiver recebendo um erro com o motivo "Cliente RPC remoto desassociado". Isso normalmente significa que o driver ou um executor está ficando sem memória. Tente alternar para o modo "batch" para resolver este erro.

As informações a seguir definem a quantidade máxima de dados que podem ser lidos, que tipo de dados foram usados e o período estimado de leitura dos dados.

Para Python e R, um servidor notebook configurado com 40 GB de RAM foi usado para os benchmarks. Para PySpark e Scala, um cluster de databricks configurado com 64 GB de RAM, 8 núcleos, 2 DBU com um máximo de 4 trabalhadores foi usado para os benchmarks descritos abaixo.

Os dados do schema ExperienceEvent usados variaram de tamanho, começando em mil (1K) linhas que variam de até um bilhão (1B) de linhas. Observe que para as métricas PySpark e Spark, um período de 10 dias foi usado para os dados XDM.

Os dados do schema ad-hoc foram pré-processados usando Query Service Criar tabela como seleção (CTAS). Esses dados também variaram de tamanho a partir de mil linhas (1.000) de até 1 bilhão (1.000 linhas).

Quando usar o modo de lote vs modo interativo

Ao ler conjuntos de dados com notebooks PySpark e Scala, você tem a opção de usar o modo interativo ou o modo de lote para ler o conjunto de dados. Interativo é feito para resultados rápidos, enquanto o modo de lote é para grandes conjuntos de dados.

  • Para notebooks PySpark e Scala, o modo de lote deve ser usado quando 5 milhões de linhas de dados ou mais estiverem sendo lidas. Para obter mais informações sobre a eficiência de cada modo, consulte as tabelas de limite de dados PySpark ou Scala abaixo.

Python limites de dados do notebook

Schema XDM ExperienceEvent: você deve ser capaz de ler no máximo 2 milhões de linhas (~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 K 10.000 100 K 1 M 2 M
Tamanho no disco (MB) 18,73 187,5 308 3000 6050
SDK (em segundos) 20,3 86,8 63 659 1315

schema ad-hoc: você deve ser capaz de ler no máximo 5 milhões de linhas (~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 K 10.000 100 K 1 M 2 M 3 M 5 M
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

Limites de dados do notebook R

Schema XDM ExperienceEvent: você deve ser capaz de 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 K 10.000 100 K 1 M
Tamanho no disco (MB) 18,73 187,5 308 3000
R Kernel (em segundos) 14,03 69,6 86,8 775

schema ad-hoc: você deve ser capaz de ler no máximo 3 milhões de linhas de dados ad-hoc (dados de 293 MB em disco) em cerca de 10 minutos.

Número de linhas 1 K 10.000 100 K 1 M 2 M 3 M
Tamanho no disco (em MB) 0,082 0,612 9.0 91 188 293
SDK R (em segundos) 7,7 4,58 35,9 233 470,5 603

Limites de dados do bloco de anotações do PySpark (Python kernel):

Schema XDM ExperienceEvent: no modo interativo, você deve ser capaz de ler no máximo 5 milhões de linhas (~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. Caso deseje ler conjuntos de dados maiores, é recomendável alternar para o modo de lote. No modo de lote, você deve ser capaz de ler um máximo de 500 milhões de linhas (~1,31 TB de dados no disco) de dados XDM em cerca de 14 horas.

Número de linhas 1 K 10.000 100 K 1 M 2 M 3 M 5 M 10M 50 M 100 M 500 M
Tamanho no 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 interativo) 33 s 32,4 s 55,1 s 253,5 s 489,2 s 729,6 s 1206,8 s - - - -
SDK (Modo de lote) 815,8 s 492,8 s 379,1 s 637,4 s 624,5 s 869,2 s 1104,1 s 1786 s 5387,2 s 10624,6 s 50547 s

schema ad-hoc: no modo interativo, você deve ser capaz de ler no máximo 5 milhões de linhas (~5,36 GB de dados em disco) de dados não-XDM em menos de 3 minutos. No modo Lote, você deve ser capaz de ler no máximo 1 bilhão de linhas (~1,05 TB de dados no disco) de dados não XDM em cerca de 18 minutos.

Número de linhas 1 K 10.000 100 K 1 M 2 M 3 M 5 M 10M 50 M 100 M 500 M 1B
Tamanho no 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 interativo do SDK (em segundos) 28,2 s 18,6 s 20,8 s 20,9 s 23,8 s 21,7 s 24,7 s - - - - -
Modo de lote do SDK (em segundos) 428,8 s 578,8 s 641,4 s 538,5 s 630,9 s 467,3 s 411 s 675 s 702 s 719,2 s 1022,1 s 1122,3 s

Spark Limites de dados do notebook (kernel Scala):

Schema XDM ExperienceEvent: no modo interativo, você deve ser capaz de ler no máximo 5 milhões de linhas (~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. Caso deseje ler conjuntos de dados maiores, é recomendável alternar para o modo de lote. No modo de lote, você deve ser capaz de ler um máximo de 500 milhões de linhas (~1,31 TB de dados no disco) de dados XDM em cerca de 14 horas.

Número de linhas 1 K 10.000 100 K 1 M 2 M 3 M 5 M 10M 50 M 100 M 500 M
Tamanho no 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 interativo do SDK (em segundos) 37,9 s 22,7 s 45,6 s 231,7 s 444,7 s 660,6 s anos 1100 - - - -
Modo de lote do SDK (em segundos) 374,4 s 398,5 s 527 s 487,9 s 588,9 s 829 s 939,1 s 1441 s 5473,2 s 1018,8 49207,6

schema ad-hoc: no modo interativo, você deve ser capaz de ler no máximo 5 milhões de linhas (~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 (~1,05 TB de dados no disco) de dados não XDM em cerca de 16 minutos.

Número de linhas 1 K 10.000 100 K 1 M 2 M 3 M 5 M 10M 50 M 100 M 500 M 1B
Tamanho no 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 interativo do SDK (em segundos) 35,7 s 31 s 19,5 s 25,3 s 23 s 33,2 s 25,5 s - - - - -
Modo de lote do SDK (em segundos) 448,8 s 459,7 s 519 s 475,8 s 599,9 s 347,6 s 407,8 s 397 s 518,8 s 487,9 s 760,2 s 975,4 s

Notebooks Python

Python os notebooks permitem paginar dados ao acessar os conjuntos de dados. O código de amostra para ler dados com e sem paginação é demonstrado abaixo. Para obter mais informações sobre os notebooks Python iniciais disponíveis, visite a seção JupyterLab Launcher no guia do usuário do JupyterLab.

A documentação do Python abaixo descreve os seguintes conceitos:

Leitura de um conjunto de dados em Python

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 dataframe de 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 pela limitação e compensação de 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 dataframe de 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()

Gravar em um conjunto de dados em Python

Para gravar em um conjunto de dados no seu bloco de notas JupyterLab, selecione a guia ícone Dados (destacada abaixo) na navegação à esquerda de JupyterLab. Os diretórios Datasets e Schemas são exibidos. Selecione Conjuntos de dados e clique com o botão direito do mouse, em seguida, selecione a opção Gravar dados no Bloco de notas no menu suspenso no conjunto de dados que deseja usar. Uma entrada de código executável é exibida na parte inferior do seu notebook.

  • Use Gravar dados no notebook para gerar uma célula de gravação com o conjunto de dados selecionado.
  • Use Explorar dados no notebook para gerar uma célula de leitura com o conjunto de dados selecionado.
  • Use Dados do Query no Notebook para gerar uma célula básica do query com o conjunto de dados selecionado.

Como alternativa, você pode copiar e colar a seguinte célula de código. Substitua {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')

Dados de query usando Query Service em Python

JupyterLab on Platform permite que você use o SQL em um Python notebook para acessar dados pelo Adobe Experience Platform Query Service. O acesso aos dados por meio de Query Service pode ser útil para lidar com grandes conjuntos de dados devido aos seus tempos de execução superiores. Observe que a consulta de dados usando Query Service tem um limite de tempo de processamento de dez minutos.

Antes de usar Query Service em JupyterLab, certifique-se de ter uma compreensão funcional da Query Service sintaxe SQL.

A consulta de dados usando Query Service requer que você forneça o nome do conjunto de dados do público alvo. 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 do mouse na listagem do conjunto de dados e clique em Dados do Query no Bloco de notas para gerar duas células de código no seu bloco de notas. Estas duas células são descritas com mais detalhes abaixo.

Para utilizar Query Service em JupyterLab, você deve primeiro criar uma conexão entre seu notebook de trabalho Python e Query Service. Isso pode ser feito executando-se a primeira célula gerada.

qs_connect()

Na segunda célula gerada, a primeira linha deve ser definida antes do query SQL. Por padrão, a célula gerada define uma variável opcional (df0) que salva os resultados do query como um dataframe de Pandas.
O -c QS_CONNECTION argumento é obrigatório e instrui o kernel a executar o query SQL contra Query Service. Consulte o 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 um query SQL usando uma sintaxe formatada em sequência e vinculando as variáveis entre chaves ({}), como 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}

Filtrar ExperienceEvent dados

Para acessar e filtrar um conjunto de dados ExperienceEvent em um notebook Python, é necessário fornecer a ID do conjunto de dados ({DATASET_ID}) juntamente 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 está descrita abaixo:

  • eq(): Equal to
  • gt(): Greater than
  • ge(): Greater than or equal to
  • lt(): Less than
  • le(): Less than or equal to
  • And(): Operador AND lógico
  • Or(): Operador OR lógico

A seguinte célula filtros um conjunto de dados ExperienceEvent para 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()

R blocos de anotações

Os notebooks R permitem paginar dados ao acessar os conjuntos de dados. O código de amostra para ler dados com e sem paginação é demonstrado abaixo. Para obter mais informações sobre os notebooks R iniciais disponíveis, visite a seção JupyterLab Iniciador no guia do usuário do JupyterLab.

A documentação R abaixo descreve os seguintes conceitos:

Leitura de um conjunto de dados em R

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 dataframe de 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 pela limitação e compensação de 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 dataframe de 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()

Gravar em um conjunto de dados em R

Para gravar em um conjunto de dados no seu bloco de notas JupyterLab, selecione a guia ícone Dados (destacada abaixo) na navegação à esquerda de JupyterLab. Os diretórios Datasets e Schemas são exibidos. Selecione Conjuntos de dados e clique com o botão direito do mouse, em seguida, selecione a opção Gravar dados no Bloco de notas no menu suspenso no conjunto de dados que deseja usar. Uma entrada de código executável é exibida na parte inferior do seu notebook.

  • Use Gravar dados no notebook para gerar uma célula de gravação com o conjunto de dados selecionado.
  • Use Explorar dados no notebook para gerar uma célula de leitura com o conjunto de dados selecionado.

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

Filtrar ExperienceEvent dados

Para acessar e filtrar um conjunto de dados ExperienceEvent em um notebook R, é necessário fornecer a ID do conjunto de dados ({DATASET_ID}) juntamente 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 está descrita abaixo:

  • eq(): Igual a
  • gt(): Maior que
  • ge(): Maior que ou igual a
  • lt(): Menor que
  • le(): Menor que ou igual a
  • And(): Operador AND lógico
  • Or(): Operador OR lógico

A seguinte célula filtros um conjunto de dados ExperienceEvent para 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()

Notebooks PySpark 3

A documentação do PySpark abaixo descreve os seguintes conceitos:

Inicializando sparkSession

Todos os notebooks Spark 2.4 exigem que você inicialize a sessão com o seguinte código estereotipado.

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

Utilização do conjunto de dados %dataset para ler e escrever com um bloco de notas PySpark 3

Com a introdução do Spark 2.4, a mágica personalizada %dataset é fornecida para uso em notebooks PySpark 3 (Spark 2.4). Para obter mais detalhes sobre comandos mágicos disponíveis no kernel IPython, visite a documentação mágica IPython.

Uso

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

Descrição

Um comando mágico personalizado Data Science Workspace para ler ou escrever um conjunto de dados a partir de um bloco de notas PySpark (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 "read" ou "write". Sim
--datasetId {id} Usado para fornecer a ID do conjunto de dados para leitura ou gravação. Sim
--dataFrame {df} Os pandas dataframe.
  • Quando a ação é "lida", {df} é a variável na qual os resultados da operação de leitura do conjunto de dados estão disponíveis.
  • Quando a ação é "write", esse dataframe {df} é gravado no conjunto de dados.
Sim
--mode Um parâmetro adicional que altera como os dados são lidos. Os parâmetros permitidos são "batch" e "interative". Por padrão, o modo é definido como "interativo". Recomenda-se usar o modo "lote" ao ler grandes quantidades de dados. Não
DICA

Revise as tabelas do PySpark na seção limites de dados do bloco de anotações para determinar se mode deve ser definido como interactive ou batch.

Exemplos

  • Exemplo de leitura: %dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0
  • Exemplo de gravação: %dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0

Você pode gerar automaticamente os exemplos acima na compra do JupyterLab usando o seguinte método:

Selecione a guia ícone Dados (realçada abaixo) na navegação à esquerda de JupyterLab. Os diretórios Datasets e Schemas são exibidos. Selecione Conjuntos de dados e clique com o botão direito do mouse, em seguida, selecione a opção Gravar dados no Bloco de notas no menu suspenso no conjunto de dados que deseja usar. Uma entrada de código executável é exibida na parte inferior do seu notebook.

  • Use Explorar dados no notebook para gerar uma célula de leitura.
  • Use Gravar dados no notebook para gerar uma célula de gravação.

Criar um dataframe local

Para criar um dataframe local usando o PySpark 3, use query 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)
DICA

Também é possível especificar uma amostra de semente opcional, como um booleano comReplacement, fração de duplo ou uma semente longa.

Filtrar ExperienceEvent dados

Acessar e filtrar um conjunto de dados ExperienceEvent 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 string de query SQL.

As células a seguir filtram um conjunto de dados ExperienceEvent para 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

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

Notebooks Scala

A documentação abaixo contém exemplos para os seguintes conceitos:

Inicializando SparkSession

Todos os notebooks Scala exigem que você inicialize a sessão com o seguinte código estereotipado:

import org.apache.spark.sql.{ SparkSession }
val spark = SparkSession
  .builder()
  .master("local")
  .getOrCreate()

Ler um conjunto de dados

No Scala, é possível importar clientContext para obter e retornar valores da Plataforma, isso elimina a necessidade de definir variáveis como var userToken. No exemplo Scala abaixo, clientContext é usado para obter e retornar todos os valores necessários para ler um conjunto de dados.

import org.apache.spark.sql.{Dataset, SparkSession}
import com.adobe.platform.token.ClientContext
val spark = SparkSession.builder().master("local").config("spark.sql.warehouse.dir", "/").getOrCreate()

val clientContext = ClientContext.getClientContext()
val df1 = spark.read.format("com.adobe.platform.query")
  .option("user-token", clientContext.getUserToken())
  .option("ims-org", clientContext.getOrgId())
  .option("api-key", clientContext.getApiKey())
  .option("service-token", clientContext.getServiceToken())
  .option("sandbox-name", clientContext.getSandboxName())
  .option("mode", "interactive")
  .option("dataset-id", "5e68141134492718af974844")
  .load()

df1.printSchema()
df1.show(10)
Elemento Descrição
df1 Uma variável que representa o dataframe dos Pandas usado para ler e gravar dados.
user-token Seu token de usuário que é obtido automaticamente usando clientContext.getUserToken().
service-token Seu token de serviço que é obtido automaticamente usando clientContext.getServiceToken().
ims-org Sua ID de organização IMS que é obtida automaticamente usando clientContext.getOrgId().
api-key Sua chave de API que é obtida automaticamente usando clientContext.getApiKey().
DICA

Revise as tabelas Scala na seção limites de dados do bloco de anotações 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 ícone Dados (realçada abaixo) na navegação à esquerda de JupyterLab. Os diretórios Datasets e Schemas são exibidos. Selecione Conjuntos de dados e clique com o botão direito do mouse, em seguida, selecione a opção Explorar dados no notebook no menu suspenso no conjunto de dados que deseja usar. Uma entrada de código executável é exibida na parte inferior do seu notebook.
E

  • Use Explorar dados no notebook para gerar uma célula de leitura.
  • Use Gravar dados no notebook para gerar uma célula de gravação.

Gravar em um conjunto de dados

No Scala, é possível importar clientContext para obter e retornar valores da Plataforma, isso elimina a necessidade de definir variáveis como var userToken. No exemplo Scala abaixo, clientContext é usado para definir e retornar todos os valores necessários para gravar em um conjunto de dados.

import org.apache.spark.sql.{Dataset, SparkSession}
import com.adobe.platform.token.ClientContext
val spark = SparkSession.builder().master("local").config("spark.sql.warehouse.dir", "/").getOrCreate()

val clientContext = ClientContext.getClientContext()
df1.write.format("com.adobe.platform.query")
  .option("user-token", clientContext.getUserToken())
  .option("service-token", clientContext.getServiceToken())
  .option("ims-org", clientContext.getOrgId())
  .option("api-key", clientContext.getApiKey())
  .option("sandbox-name", clientContext.getSandboxName())
  .option("mode", "interactive")
  .option("dataset-id", "5e68141134492718af974844")
  .save()
direcionado descrição
df1 Uma variável que representa o dataframe dos Pandas usado para ler e gravar dados.
user-token Seu token de usuário que é obtido automaticamente usando clientContext.getUserToken().
service-token Seu token de serviço que é obtido automaticamente usando clientContext.getServiceToken().
ims-org Sua ID de organização IMS que é obtida automaticamente usando clientContext.getOrgId().
api-key Sua chave de API que é obtida automaticamente usando clientContext.getApiKey().
DICA

Revise as tabelas Scala na seção limites de dados do bloco de anotações para determinar se mode deve ser definido como interactive ou batch.

criar um dataframe local

Para criar um dataframe local usando Scala, são necessários query SQL. Por exemplo:

sparkdf.createOrReplaceTempView("sparkdf")

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

Filtrar ExperienceEvent dados

Acessar e filtrar um conjunto de dados ExperienceEvent em um notebook Scala 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 string de query SQL.

As células a seguir filtram um conjunto de dados ExperienceEvent para 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()

Próximas etapas

Este documento aborda as diretrizes gerais para acessar conjuntos de dados usando notebooks JupyterLab. Para obter exemplos mais detalhados sobre como consultar conjuntos de dados, visite a documentação Serviço de Query em notebooks JupyterLab. Para obter mais informações sobre como explorar e visualizar seus conjuntos de dados, visite o documento em analisar seus dados usando notebooks.

Sinalizadores SQL opcionais para Query Service

Esta tabela descreve os sinalizadores SQL opcionais que podem ser usados para Query Service.

Sinalizador Descrição
-h, --help Mostre a mensagem de ajuda e saia.
-n, --notify Alternar opção para notificar os resultados do query.
-a, --async O uso desse sinalizador executa o query de forma assíncrona e pode liberar o kernel enquanto o query está sendo executado. Tenha cuidado ao atribuir resultados de query a variáveis, pois eles podem ser indefinidos se o query não estiver concluído.
-d, --display O uso desse sinalizador impede que os resultados sejam exibidos.

Nesta página

Adobe Summit Banner

A virtual event April 27-28.

Expand your skills and get inspired.

Register for free
Adobe Summit Banner

A virtual event April 27-28.

Expand your skills and get inspired.

Register for free
Adobe Maker Awards Banner

Time to shine!

Apply now for the 2021 Adobe Experience Maker Awards.

Apply now
Adobe Maker Awards Banner

Time to shine!

Apply now for the 2021 Adobe Experience Maker Awards.

Apply now