Exportando dados do EPM para o formato Apache Parquet.

Introdução

O Apache Parquet é um formato de arquivo binário que permite o armazenamento de dados utilizando tipos específicos, como: BOOLEAN, INT32, INT64, INT96, FLOAT, DOUBLE e BYTE_ARRAY.

Os metadados no Parquet, incluindo esquema e estrutura, são incorporados individualmente em cada arquivo, tornando o Apache Parquet um formato de arquivo autodescritivo.

O Parquet possui uma organização interna dos dados semelhante à de uma tabela de um RDBMS (Relational Database Management System, ou Sistema de Gerenciamento de Banco de Dados Relacional), com linhas e colunas. Entretanto, ao contrário dessas tabelas, os dados no Parquet são armazenados em formato colunar (um ao lado do outro).

Devido à sua estrutura colunar, o Parquet oferece melhor compactação e desempenho ao lidar com grandes volumes de dados.

Por conta desses benefícios, muitas soluções de análise de dados oferecem suporte à leitura de arquivos Parquet, especialmente soluções em nuvem.

Poder utilizar ferramentas avançadas de análise e inteligência de dados sobre o conteúdo armazenado pelo EPM pode representar grandes benefícios para a empresa, considerando a vasta oferta de soluções poderosas disponíveis no mercado — além da possibilidade de integrar e relacionar informações do EPM com dados de outros sistemas em lógicas extremamente robustas.

Consultando e exportando os dados

Uma maneira fácil de configurar a consulta é criar um DatasetAnalysis na pasta Server para consultar os dados do EPM. Dessa forma, é possível configurar as variáveis e agregações uma única vez e apenas ajustar o período para consultar, por exemplo, sempre os dados do último dia.

Para executar a consulta e exportar os dados, podemos utilizar o EPM Processor, com um código que será executado uma vez por dia.

Utilizaremos a biblioteca pandas para formatar os dados como um DataFrame e exportá-los para o formato Parquet. Por isso, é necessário instalar essa biblioteca em “Python Libs” no EPM Processor.

O código de exemplo receberá três parâmetros:

  • epmConnection: objeto epmconnection criado na área administrativa do EPM Processor;

  • dsName: nome do Dataset de onde os dados serão obtidos;

  • saveTo: caminho para salvar o arquivo Parquet gerado (pode ser um caminho do OneDrive ou Google Drive, por exemplo). Deve ser informado com barras (“/”) em vez de contrabarras (“”) — por exemplo: C:/MyFolder.


O processo será dividido em três etapas:

  1. Executar o Dataset;

  2. Converter o resultado do Dataset em um DataFrame do Pandas;

  3. Exportar o DataFrame para um arquivo Parquet.


Observe o código abaixo:

  1. #mandatory import
  2. import epmprocessor as epr
  3. import pandas as pd
  4. import datetime as dt
  5. @epr.applicationMethod('Export to Parquet')
  6. def exportparquet(epmConnection, dsName, saveTo = 'C:/'):
  7. dsConfig = epmConnection.loadDatasetServer(dsName)
  8. datavar = dsConfig.execute()
  9. df_list = {}
  10. for var in datavar:
  11. new_Quality = datavar[var] [ : ] ['Quality'].byteswap().newbyteorder()
  12. new_Timestamp = datavar[var] [ : ] ['Timestamp']
  13. new_Value = datavar[var] [ : ] ['Value'].byteswap().newbyteorder()
  14. d = {'VarName': var, 'Value':new_Value, 'Timestamp':new_Timestamp, 'Quality':new_Quality}
  15. df_list[var] = pd.DataFrame(d)
  16. invChar = ['<','>','$','#','.',',',' ','´','@','/','+',':']
  17. pFileName = ''
  18. for letter in 'Dataset_{}_{}'.format(dsName, dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")):
  19. if letter in invChar:
  20. letter = '_'
  21. pFileName += letter
  22. finalData = pd.concat(df_list).reset_index(drop=True)
  23. finalData.to_parquet('{}/{}.parquet'.format(saveTo, pFileName))
#mandatory import
import epmprocessor as epr
import pandas as pd
import datetime as dt

@epr.applicationMethod('Export to Parquet')
def exportparquet(epmConnection, dsName, saveTo = 'C:/'):   
  dsConfig = epmConnection.loadDatasetServer(dsName)
  datavar = dsConfig.execute()
  df_list = {}
 
  for var in datavar:
    new_Quality = datavar[var]  [ : ]  ['Quality'].byteswap().newbyteorder()
    new_Timestamp = datavar[var] [ : ] ['Timestamp']
    new_Value = datavar[var] [ : ] ['Value'].byteswap().newbyteorder()
 
    d = {'VarName': var, 'Value':new_Value, 'Timestamp':new_Timestamp, 'Quality':new_Quality}
    df_list[var] = pd.DataFrame(d)
  invChar = ['<','>','$','#','.',',',' ','´','@','/','+',':']
  pFileName = ''

  for letter in 'Dataset_{}_{}'.format(dsName, dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")):
    if letter in invChar:
      letter = '_'
    pFileName += letter
  finalData = pd.concat(df_list).reset_index(drop=True)
  finalData.to_parquet('{}/{}.parquet'.format(saveTo, pFileName))

Ao executar este código, será criado um arquivo Parquet no local informado, contendo o resultado do Dataset.

Como o nosso Dataset está configurado para retornar os dados do último dia, em seguida faremos o deploy do código criado.

Depois, será necessário criar um evento do tipo Schedule no EPM Studio, configurado para ser disparado todos os dias à meia-noite.

Em seguida, vamos criar uma Application no EPM Processor para configurar a chamada do código que acabamos de desenvolver.

Por fim, vamos criar uma Solution e, nela, inserir a nossa Application recém-criada em “Productions”, para que seja executada automaticamente a partir do evento que configuramos.

A partir dessa configuração, todos os dias, à meia-noite, o código que criamos será executado, com até três tentativas em caso de erro.

Dessa forma, serão gerados arquivos diários que poderão ser utilizados por outras soluções de análise de dados.

Print Friendly, PDF & Email

Este artigo foi útil? Was this helpful?

Classificação média - Average rating 5 / 5. Count: 1

Deixe seu Comentário

Seu endereço de e-mail não será publicado. Campos marcados com asterisco são obrigatórios *