# Transformar dados com transformações gerenciadas do AWS Glue
AWS Glue StudioO fornece dois tipos de transformação:
+ **Transformações nativas do AWS Glue**, disponíveis para todos os usuários e gerenciadas pelo AWS Glue.
+ **Transformações visuais personalizadas**, permitem que você carregue suas próprias transformações para usar no AWS Glue Studio
## Nós de transformação de dados gerenciados pelo AWS Glue
AWS Glue StudioO fornece um conjunto de transformações integradas que você pode usar para processar seus dados. Seus dados passam de um nó no diagrama de trabalho para outro em uma estrutura de dados chamada `DynamicFrame`, que é uma extensão para um `DataFrame` do Apache Spark SQL.
No diagrama previamente preenchido de um trabalho, entre os nós de fonte de dados e de destino de dados está o nó de transformação **Change Schema**. Você pode configurar esse nó de transformação para modificar seus dados ou pode usar transformações adicionais.
As transformações integradas a seguir estão disponíveis no AWS Glue Studio:
+ **[ChangeSchema](transforms-configure-applymapping.md)**: mapear chaves de propriedade de dados na fonte de dados para chaves de propriedade de dados no destino dos dados. Você pode renomear chaves, modificar os tipos de dados para chaves e escolher quais chaves remover do conjunto de dados.
+ **[SelectFields](transforms-configure-select-fields.md)** (Selecionar campos): escolha as chaves de propriedade de dados que você deseja manter.
+ **[DropFields](transforms-configure-drop-fields.md)** (Descartar campos): escolha as chaves de propriedade de dados que você deseja descartar.
+ **[RenameField](transforms-configure-rename-field.md)** (Renomear campo): renomeie uma única chave de propriedade de dados.
+ **[Spigot](transforms-configure-spigot.md)** (Torneira): grave amostras dos dados em um bucket do Amazon S3.
+ **[Join](transforms-configure-join.md)** (Unir): una dois conjuntos de dados em um só, usando uma frase de comparação nas chaves de propriedade de dados especificadas. Você pode usar junção inner (interna), outer (externa), left (à esquerda), right (à direita), left semi (semi à esquerda) e left anti (anti à esquerda).
+ **[Union](transforms-configure-union.md)**: combinar linhas de mais de uma fonte de dados que tenham o mesmo esquema.
+ **[SplitFields](transforms-configure-split-fields.md)** (Dividir campos): divida chaves de propriedade de dados em dois `DynamicFrames`. A saída é uma coleção de `DynamicFrames`: um com chaves de propriedade de dados selecionadas e outro com as chaves de propriedade de dados restantes.
+ **[SelectFromCollection](transforms-selectfromcollection-overview.md)** (Selecionar na coleção): escolha um `DynamicFrame` a partir de uma coleção de `DynamicFrames`. A saída é o selecionado. `DynamicFrame`.
+ **[FillMissingValues](transforms-configure-fmv.md)** (Preencher valores ausentes): localize registros no conjunto de dados que têm valores ausentes e adicione um novo campo com um valor determinado por imputação.
+ **[Filter](transforms-filter.md)** (Filtro): divida um conjunto de dados em dois, com base em uma condição de filtro.
+ **[Drop Null Fields](transforms-dropnull-fields.md)** (Descartar campos nulos): remove colunas do conjunto de dados se todos os valores na coluna forem "null" (nulo).
+ ** [Drop Duplicates](transforms-drop-duplicates.md)** (Eliminar duplicatas): remove linhas da sua fonte de dados escolhendo combinar linhas inteiras ou especificar chaves.
+ **[SQL](transforms-sql.md)**: insira o código SparkSQL em um campo de entrada de texto para usar uma consulta SQL para transformar os dados. A saída é um único `DynamicFrame`.
+ **[Agregar](transforms-aggregate-fields.md)**: executa um cálculo (como média, soma, mínimo, máximo) em campos e linhas selecionados, e cria um novo campo com os valores recém-calculados.
+ **[Nivelar](transforms-flatten.md)**: extraia campos dentro de structs para campos de nível superior.
+ **[UUID](transforms-uuid.md)**: adicione uma coluna com um identificador universal exclusivo para cada linha.
+ **[Identificador](transforms-identifier.md)**: adicione uma coluna com um identificador numérico para cada linha.
+ **[Em timestamp](transforms-to-timestamp.md)**: converta uma coluna em tipo timestamp.
+ **[Formatar timestamp](transforms-format-timestamp.md)**: converta uma coluna de timestamp em uma string formatada.
+ **[Transformação de roteador condicional](transforms-conditional-router.md)**: aplique várias condições aos dados de entrada. Cada linha dos dados de entrada avaliada por uma condição de filtro de grupo e processada no grupo correspondente.
+ **[Transformação Concatenate Columns](transforms-concatenate-columns.md)**: Criar uma nova coluna de strings usando os valores de outras colunas com um espaçador opcional.
+ **[Transformação Split String](transforms-split-string.md)**: permite que você divida uma string em uma matriz de tokens usando uma expressão regular para definir como a divisão é feita.
+ **[Transformação Array To Columns](transforms-array-to-columns.md)**: extrair alguns ou todos os elementos de uma coluna do tipo matriz para novas colunas.
+ **[Transformação Add Current Timestamp](transforms-add-current-timestamp.md)**: permite marcar as linhas com a hora em que os dados foram processados. Isso é útil para fins de auditoria ou para rastrear a latência no pipeline de dados.
+ **[Transformação Pivot Rows to Columns](transforms-pivot-rows-to-columns.md)**: agregar uma coluna numérica girando valores únicos nas colunas selecionadas que se tornam novas colunas. Se várias colunas forem selecionadas, os valores serão concatenados para nomear as novas colunas.
+ **[Transformação Unpivot Columns To Rows](transforms-unpivot-columns-to-rows.md)**: converter colunas em valores de novas colunas, gerando uma linha para cada valor único.
+ **[Transformação Autobalance Processing](transforms-autobalance-processing.md)**: redistribuir os dados entre os operadores para melhorar a performance. Isso ajuda nos casos em que os dados estão desbalanceados ou, como vêm da fonte, não permitem processamento paralelo suficiente.
+ **[Transformação Derived Column](transforms-derived-column.md)**: definir uma nova coluna com base em uma fórmula matemática ou expressão SQL na qual você pode usar outras colunas nos dados, além de constantes e literais.
+ **[Transformação Lookup](transforms-lookup.md)**: adicionar colunas de uma tabela de catálogo definida quando as chaves correspondem às colunas de pesquisa nos dados.
+ **[Transformação Explode Array Map Into Rows](transforms-explode-array.md)**: extrair valores de uma estrutura aninhada em linhas individuais que são mais fáceis de manipular.
+ **[Transformação Record matching](transforms-record-matching.md)**: invocar uma transformação de classificação de dados de machine learning Record Matching existente.
+ **[Transformação Remove null rows](transforms-remove-null-rows.md)**: remover do conjunto de dados as linhas que têm todas as colunas nulas ou vazias.
+ **[Transformação Parse JSON comumn](transforms-parse-json-column.md)**: analisar uma coluna de strings contendo dados JSON e a converter em uma estrutura ou coluna de matriz, dependendo se o JSON for um objeto ou uma matriz, respectivamente.
+ **[Transformação Extract JSON path](transforms-extract-json-path.md)**: extrair novas colunas de uma coluna de strings JSON.
+ Essa**[Transformação Extract stringtransformaçãofragmentsextraifrom a regular expression](transforms-regex-extractor.md)**: extrair fragmentos de string usando uma expressão regular e criacriar uma nova coluna a partir dela, ou várias colunas se estiver usando grupos regex.
+ **[Custom transform](transforms-custom.md)** (Transformação personalizada): insira o código em um campo de entrada de texto para usar transformações personalizadas. A saída é uma coleção de `DynamicFrames`.
# Usando uma fórmula de preparação de dados no AWS Glue Studio
A transformação da **fórmula de preparação de dados** permite que você crie uma fórmula de preparação de dados do zero usando uma interface de criação interativa em estilo de grade. Também permite que você importe uma fórmula disponível do AWS Glue DataBrew e depois a edite no AWS Glue Studio.
O nó **Fórmula de preparação de dados** está disponível no painel Recursos. Você pode conectar o nó **Fórmula de preparação de dados** a outro nó no fluxo de trabalho visual, seja ele um nó de fonte de dados ou outro nó de transformação. Depois de escolher uma fórmula e uma versão do AWS Glue DataBrew, as etapas aplicadas na fórmula ficam visíveis na guia de propriedades do nó.
## Pré-requisitos
+ Ao importar uma fórmula do AWS Glue DataBrew, você tem as permissões necessárias do IAM, conforme descrito em [Importar uma fórmula do AWS Glue DataBrew no AWS Glue Studio](glue-studio-data-preparation-import-recipe.md).
+ Uma sessão de pré-visualização de dados deve ser criada.
## Limitações
+ As fórmulas do AWS Glue DataBrew são apenas compatíveis em [regiões comerciais do DataBrew](https://docs.aws.amazon.com/general/latest/gr/databrew.html).
+ Nem todas as fórmulas do AWS Glue DataBrew são compatíveis com o AWS Glue. Algumas fórmulas não poderão ser executadas no AWS Glue Studio.
+ Fórmulas com transformações `UNION` e `JOIN` não são compatíveis, no entanto, o AWS Glue Studio já possui nós de transformação “Join” e “Union” que podem ser usados antes ou depois de um nó de **Fórmula de preparação de dados**.
+ Os nós de **Data Preparation Recipe** são compatíveis com trabalhos a partir do AWS Glue versão 4.0. Essa versão será selecionada automaticamente depois que um nó de **Data Preparation Recipe** for adicionado ao trabalho.
+ Nós **Data Preparation Recipe** exigem o Python. Isso é definido automaticamente quando o nó **Data Preparation Recipe** é adicionado ao trabalho.
+ Adicionar um novo nó de **Fórmula de preparação de dados** ao gráfico visual reiniciará automaticamente sua sessão de pré-visualização de dados com as bibliotecas corretas para usar o nó de **Fórmula de preparação de dados**.
+ As seguintes transformações não são compatíveis para importação ou edição em um nó de **Fórmula de preparação de dados**: `GROUP_BY`, `PIVOT`, `UNPIVOT` e `TRANSPOSE`.
## Recursos adicionais
Depois de selecionar a transformação da **Fórmula de preparação de dados**, será possível executar ações adicionais depois de escolher **Criar fórmula**.
+ Adicionar etapa: você pode adicionar etapas adicionais a uma fórmula, conforme necessário, escolhendo o ícone de adicionar etapa, ou pode usar a barra de ferramentas no painel de pré-visualização e escolher uma ação.
![\[A captura de tela mostra o ícone de adicionar fórmula.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/add-recipe-icon.png)
![\[A captura de tela mostra o ícone de adicionar fórmula.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/author-recipe-toolbar.png)
+ Importar fórmula: escolha **Mais** e depois **Importar fórmula** para usar em seu trabalho do AWS Glue Studio.
![\[A captura de tela mostra o ícone de mais.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-preparation-recipe-node-more-icon.png)
![\[A captura de tela mostra o ícone de mais.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-preparation-recipe-node-more-features.png)
+ Baixar como YAML: escolha **Mais** e depois **Baixar como YAML** para baixar sua fórmula e salvá-la fora do AWS Glue Studio.
+ Baixar como JSON: escolha **Mais** e depois **Baixar como JSON** para baixar sua fórmula e salvá-la fora do AWS Glue Studio.
+ Desfazer e refazer etapas da fórmula: você pode desfazer e refazer etapas da fórmula no painel Pré-visualizar ao trabalhar com dados na grade.
![\[A captura de tela mostra o ícone de mais.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/author-recipe-toolbar-undo-redo.png)
# Criar e executar fórmulas de preparação de dados em um trabalho visual de ETL do AWS Glue
Nesse cenário, você pode criar fórmulas de preparação de dados sem precisar primeiro criá-las no DataBrew. Antes de começar a criar fórmulas, você deve:
+ Ter uma sessão ativa de pré-visualização de dados em execução. Quando a sessão de pré-visualização de dados estiver PRONTA, a **Fórmula do autor** ficará ativa e você poderá começar a criá-la ou editá-la.
![\[A captura de tela mostra a sessão de pré-visualização de dados como concluída.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-preparation-recipe-data-preview-complete.png)
+ Certifique-se de que a opção **Importar bibliotecas do Glue automaticamente** esteja ativada.
![\[A captura de tela mostra a opção Importar bibliotecas do Glue automaticamente ativada.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-preparation-recipe-automatically-import-glue-libraries.png)
Você pode fazer isso escolhendo o ícone de engrenagem no painel Pré-visualização de dados.
![\[A captura de tela mostra a opção Importar bibliotecas do Glue automaticamente ativada.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-preview-preferences.png)
**Para criar uma fórmula de preparação de dados no AWS Glue Studio:**
1. Adicione a transformação da **Fórmula de preparação de dados** à sua tela de trabalho. Sua transformação deve estar conectada a um nó principal da fonte de dados. Ao adicionar o nó da **Fórmula de preparação de dados**, ele será reiniciado com as bibliotecas apropriadas e você verá o dataframe sendo preparado.
![\[A captura de tela mostra o carregamento do dataframe após a adição da fórmula de preparação de dados.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-preparation-preparing-dataframe.png)
1. Quando a sessão de pré-visualização de dados estiver pronta, os dados com todas as etapas aplicadas anteriormente aparecerão na parte inferior da tela.
1. Escolha **Criar fórmula**. Essa opção permitirá que você inicie uma nova fórmula no AWS Glue Studio.
![\[A captura de tela mostra o painel Transformação com os campos principais de Nome e Nó, bem como a opção Criar fórmula.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-preparation-recipe-transform-tab-new.png)
1. No painel **Transformar** à direita da tela de trabalho, insira um nome para sua fórmula de preparação de dados.
1. No lado esquerdo, a tela será substituída por uma visualização em grade dos seus dados. À direita, o painel **Transformar** mudará para mostrar as etapas da fórmula. Escolha **Adicionar etapa** para adicionar a primeira etapa em sua fórmula.
![\[A captura de tela mostra o painel Transformar após escolher Adicionar etapa. Quando você escolhe uma coluna, as opções mudam dinamicamente. Você pode escolher classificar, executar uma ação na coluna e filtrar valores.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/author-recipe-preview-data-transform-panel.png)
1. No painel **Transformar**, escolha classificar, executar uma ação na coluna e filtrar valores. Por exemplo, escolha **Renomear coluna**.
![\[A captura de tela mostra o painel Transformar após escolher Adicionar etapa. Quando você escolhe uma coluna, as opções mudam dinamicamente. Você pode escolher classificar, executar uma ação na coluna e filtrar valores.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/author-recipe-add-step.png)
1. No painel Transformar no lado direito, as opções para renomear uma coluna permitem que você escolha a coluna de origem a ser renomeada e insira o novo nome da coluna. Depois de executar essa ação, escolha **Aplicar**.
Você pode pré-visualizar cada etapa, desfazer uma etapa, reordenar etapas e usar qualquer um dos ícones de ação, como Filtrar, Classificar, Dividir, Mesclar etc. Quando você executa ações na grade de dados, as etapas são adicionadas à fórmula no painel Transformar.
![\[A captura de tela mostra a grade de pré-visualização de dados com a barra de ferramentas destacada. Você pode aplicar uma ação usando qualquer uma das ferramentas, e ela será adicionada à fórmula no painel Transformar à direita.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/author-recipe-preview-data-grid.png)
Caso precise fazer uma alteração, você poderá fazê-lo no painel Pré-visualizar ao pré-visualizar o resultado de cada etapa, desfazer uma etapa e reordenar as etapas. Por exemplo:
+ Etapa de desfazer/refazer: desfaça uma etapa escolhendo o ícone de **desfazer**. Você pode repetir uma etapa escolhendo o ícone de **refazer**.
![\[A captura de tela mostra o ícone de mais.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/author-recipe-toolbar-undo-redo.png)
+ Etapa de reordenação: quando você reordena uma etapa, o AWS Glue Studio valida cada etapa e informa se a etapa é inválida.
1. Depois de aplicar uma etapa, o painel Transformar mostrará todas as etapas da sua fórmula. Você pode limpar todas as etapas para recomeçar, adicionar mais etapas escolhendo o ícone de adicionar ou escolher **Criação de fórmula concluída**.
![\[A captura de tela mostra o painel Transformar com etapas adicionadas à fórmula. Quando concluir, escolha Criação da fórmula concluída, ou escolha o ícone de adicionar para adicionar mais etapas à fórmula.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/author-recipe-done-authoring-recipe.png)
1. Escolha **Salvar** no canto superior direito da tela. As etapas da fórmula não serão salvas até você salvar seu trabalho.
# Importar uma fórmula do AWS Glue DataBrew no AWS Glue Studio
No AWS Glue DataBrew, uma fórmula é um conjunto de etapas de transformação de dados. As fórmulas do AWS Glue DataBrew estabelecem como transformar dados que já foram lidos, mas não descrevem onde e como ler dados nem como e onde gravá-los. Isso é configurado nos nós de origem e de destino no AWS Glue Studio. Para obter mais informações sobre fórmulas, consulte [Creating and using AWS Glue DataBrew recipes](https://docs.aws.amazon.com/databrew/latest/dg/recipes.html).
Para usar fórmulas do AWS Glue DataBrew no AWS Glue Studio, comece criando fórmulas no AWS Glue DataBrew. Se você já tiver fórmulas que deseja usar, pule esta etapa.
## Permissões do IAM para o AWS Glue DataBrew
Este tópico fornece informações para ajudar você a entender as ações e os recursos que você, um administrador de IAM pode usar em uma política do AWS Identity and Access Management (IAM) para a transformação Data Preparation Recipe.
Para obter mais informações sobre segurança no AWS Glue, consulte [Access Management](https://docs.aws.amazon.com/glue/latest/dg/security.html).
**nota**
A tabela a seguir lista as permissões de que um usuário precisa para importar uma fórmula disponível do AWS Glue DataBrew.
**Ações de transformação da fórmula de preparação de dados**
| Ação | Descrição |
| --- | --- |
| databrew:ListRecipes | Concede permissão para recuperar fórmulas do AWS Glue DataBrew. |
| databrew:ListRecipeVersions | Concede permissão para recuperar versões de fórmulas do AWS Glue DataBrew. |
| databrew:DescribeRecipe | Concede permissão para recuperar descrição de fórmula do AWS Glue DataBrew. |
O perfil que você está usando para acessar essa funcionalidade deve ter uma política que permita várias ações AWS Glue DataBrew. Você pode fazer isso usando uma política `AWSGlueConsoleFullAccess` que inclua as ações necessárias ou adicionar a seguinte política em linha ao seu perfil:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"databrew:ListRecipes",
"databrew:ListRecipeVersions",
"databrew:DescribeRecipe"
],
"Resource": [
"*"
]
}
]
}
```
------
Para usar a transformação Data Preparation Recipe, você deve adicionar a ação `IAM:PassRole` à política de permissões.
**Permissões adicionais necessárias**
| Ação | Descrição |
| --- | --- |
| iam:PassRole | Concede permissão ao IAM para permitir que o usuário passe os perfis aprovados. |
Sem essas permissões, ocorre o seguinte erro:
```
"errorCode": "AccessDenied"
"errorMessage": "User: arn:aws:sts::account_id:assumed-role/AWSGlueServiceRole is not
authorized to perform: iam:PassRole on resource: arn:aws:iam::account_id:role/service-role/AWSGlueServiceRole
because no identity-based policy allows the iam:PassRole action"
```
## Importar uma fórmula do AWS Glue DataBrew
**Para importar uma fórmula do AWS Glue DataBrew e usá-la no AWS Glue Studio:**
Caso tenha um nó de **Fórmula de preparação de dados** disponível e queira editar as etapas da fórmula diretamente noAWS Glue Studio, você precisará importar as etapas da fórmula para o seu trabalho do AWS Glue Studio.
1. Comece um trabalho do AWS Glue no AWS Glue Studio com uma origem de dados.
1. Adicione o nó **Fórmula de preparação de dados** à sua tela de trabalho.
![\[A captura de tela mostra o modal Adicionar nó com a fórmula de preparação de dados disponível para seleção.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/glue-add-node-data-preparation-recipe.png)
1. No painel Transformar, insira um nome para a fórmula.
1. Escolha um ou mais nós principais selecionando os nós disponíveis na tela na lista suspensa.
1. Escolha **Criar fórmula**. Se a **Fórmula do autor** estiver cinza, ela não estará disponível até que os pais do nó sejam selecionados e uma sessão de visualização de dados seja concluída.
![\[Author Data Preparation Recipe form with name field and node parents selection dropdown.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/glue-author-data-preparation-recipe.png)
1. O quadro de dados carrega e mostra informações detalhadas sobre os dados de origem.
Selecione o ícone de **mais ações** e escolha **Importar fórmula**.
![\[Data preparation interface showing "Build your Recipe" with an "Add step" button.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/glue-dataframe-import-recipe.png)
1. Use o assistente de importação de fórmulas para concluir as etapas. Na etapa 1, pesquise sua fórmula, selecione-a e escolha **Avançar**.
![\[Import recipe interface showing two recipes, with one selected for import.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/import-recipe-step-1.png)
1. Na etapa 2, escolha as opções de importação. É possível optar por acrescentar uma nova fórmula a uma já existente ou substituir uma fórmula existente. Escolha **Próximo**.
![\[Import recipe interface showing selected recipe, version, and two imported steps.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/import-recipe-step-2.png)
1. Na etapa 3, valide as etapas da fórmula. Depois de importar sua fórmula do AWS Glue DataBrew, você poderá editá-la diretamente no AWS Glue Studio.
![\[Recipe import interface showing two steps and a validation progress indicator.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/import-recipe-step-3.png)
![\[Import recipe interface showing validated steps for sorting and formatting data.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/import-recipe-step-3-validated-2.png)
1. Depois disso, as etapas serão importadas como parte do seu trabalho do AWS Glue. Faça as alterações de configuração necessárias na guia **Detalhes do trabalho**, como nomear seu trabalho e ajustar a capacidade alocada, conforme necessário. Escolha **Salvar** para salvar seu trabalho e a fórmula.
**nota**
JOIN, UNION, GROUP\$1BY, PIVOT, UNPIVOT, TRANSPOSE não são compatíveis com a importação de fórmulas nem estarão disponíveis no modo de criação de fórmulas.
1. Opcionalmente, você pode concluir a criação do trabalho adicionando outros nós de transformações, conforme necessário, e adicionar nós de destino de dados.
Se você reordenar as etapas depois de importar uma fórmula, o AWS Glue executará a validação dessas etapas. Por exemplo, se você renomeou e depois excluiu uma coluna, e se moveu a etapa de exclusão para cima, a etapa de renomeação ficará inválida. Você pode então editar as etapas para corrigir o erro de validação.
# Migração do AWS Glue DataBrew para o AWS Glue Studio
Se você tiver fórmulas no AWS Glue DataBrew, use a lista de verificação a seguir para migrá-las para o AWS Glue Studio.
| Se você deseja… | Então faça isso |
| --- | --- |
| Permita que os usuários recuperem fórmulas do AWS Glue DataBrew, versões e descrições de fórmulas. | Adicione permissões do IAM a uma política que permite que sua função acesse as ações necessárias. Consulte [Permissões do IAM para o AWS Glue DataBrew](glue-studio-data-preparation-import-recipe.md#glue-studio-databrew-permissions). |
| Importe uma fórmula do AWS Glue DataBrew existente para o AWS Glue Studio. | Siga as etapas em [Importar uma fórmula do AWS Glue DataBrew](glue-studio-data-preparation-import-recipe.md#glue-studio-databrew-import-steps). |
| Importe uma fórmula com JOIN e UNION. | Fórmulas com transformações UNION e JOIN não são suportadas. Use as transformações Join and Union no AWS Glue Studio antes ou depois de um nó de fórmula de preparação de dados. |
# Usando Alterar esquema para remapear as chaves de propriedade de dados
Uma transformação *Alterar esquema* remapeia as chaves de propriedade de dados de origem como as chaves desejadas configuradas para os dados de destino. Em um nó de transformação Alterar esquema, você pode:
+ Alterar o nome de várias chaves de propriedade de dados.
+ Alterar o tipo de dados das chaves de propriedade de dados, se o novo tipo de dados for suportado e houver um caminho de transformação entre os dois tipos de dados.
+ Escolher um subconjunto de chaves de propriedade de dados indicando quais chaves de propriedade de dados você deseja descartar.
Conforme necessário, é possível adicionar mais nós *Alterar esquema* ao diagrama de trabalho, por exemplo, para modificar fontes de dados adicionais ou logo após uma transformação *Join*.
## Usar Change Schema com tipo de dado decimal
Ao usar a transformação **Alterar esquema** com tipo de dado decimal, a transformação **Alterar esquema** modifica a precisão para o valor padrão de (10,2). Para modificar isso e definir a precisão do seu caso de uso, use a transformação de **consulta do SQL** e converta as colunas com uma precisão específica.
Por exemplo, se tiver uma coluna de entrada chamada "DecimalCol" do tipo Decimal e quiser remapeá-la para uma coluna de saída chamada "OutputDecimalCol" com uma precisão específica de (18,6), será preciso:
1. Adicionar uma transformação subsequente de **consult do SQL** após a transformação **Alterar esquema**.
1. Na transformação de **consulta do SQL**, use uma consulta do SQL para converter a coluna remapeada na precisão desejada. A consulta do SQL deve ser semelhante a esta:
```
SELECT col1, col2, CAST(DecimalCol AS DECIMAL(18,6)) AS OutputDecimalCol
FROM __THIS__
```
Na consulta do SQL acima:
+ "col1" e "col2" são outras colunas em seus dados que você deseja passar sem modificação.
+ "DecimalCol" é o nome original da coluna dos dados de entrada.
+ "CAST(DecimalCol AS DECIMAL (18,6))" converte o "DecimalCol" em um tipo Decimal com uma precisão de 18 dígitos e 6 casas decimais.
+ "AS OutputDecimalCol" renomeia a coluna convertida para "OutputDecimalCol".
Usando a transformação de **consulta do SQL**, você pode substituir a precisão padrão definida pela transformação **Alterar esquema** e converter explicitamente as colunas decimais com a precisão desejada. **Essa abordagem permite aproveitar a transformação **Alterar esquema** para renomear e reestruturar seus dados e, ao mesmo tempo, lidar com os requisitos de precisão das colunas decimais por meio da transformação subsequente de consulta do SQL.**
## Adicionar uma transformação Alterar esquema ao seu trabalho
**nota**
A transformação **Alterar esquema** não diferencia maiúsculas de minúsculas.
**Para adicionar um nó de transformação Alterar esquema ao diagrama de trabalho**
1. (Opcional) abra o painel Recurso e escolha **Alterar esquema** para adicionar uma nova transformação ao diagrama de trabalho, se necessário.
1. Na guia Propriedades do nó, insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Escolha a guia **Transformar** no painel de detalhes do nó.
1. Modifique o esquema de entrada:
+ Para renomear uma chave de propriedade de dados, insira o novo nome da chave no campo **Target key** (Chave de destino).
+ Para alterar o tipo de dados de uma chave de propriedade de dados, escolha o novo tipo de dados para a chave na lista **Data type** (Tipo de dados).
+ Para remover uma chave de propriedade de dados do esquema de destino, marque a caixa de seleção **Drop** (Descartar) da chave correspondente.
1. (Opcional) depois de configurar as propriedades do nó de transformação, você pode visualizar o esquema modificado dos dados escolhendo a guia **Output schema** (Esquema de saída) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Se você não tiver especificado uma função do IAM na guia **Job details** (Detalhes do trabalho), você receberá uma solicitação para inserir uma função do IAM aqui.
1. (Opcional) depois de configurar as propriedades do nó e da transformação, você pode previsualizar o conjunto de dados modificado escolhendo a guia **Data preview** (Previsualização de dados) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Há um custo associado ao uso desse recurso e o a cobrança começa assim que você fornece uma função do IAM.
# Usando Drop Duplicates
A transformação Drop Duplicates remove linhas da sua fonte de dados, oferecendo duas opções. Você pode optar por remover a linha duplicada que é completamente igual ou escolher os campos a serem correspondentes e remover somente as linhas com base nos campos escolhidos.
Por exemplo, nesse conjunto de dados, você tem linhas duplicadas em que todos os valores em algumas linhas são exatamente iguais aos de outra linha e alguns dos valores nas linhas são iguais ou diferentes.
| Linha | Name | E-mail | Idade | Estado | Observação |
| --- | --- | --- | --- | --- | --- |
| 1 | Joy | joy@gmail | 33 | NY | |
| 2 | Tim | tim@gmail | 45 | OH | |
| 3 | Rose | rose@gmail | 23 | NJ | |
| 4 | Tim | tim@gmail | 42 | OH | |
| 5 | Rose | rose@gmail | 23 | NJ | |
| 6 | Tim | tim@gmail | 42 | OH | esta é uma linha duplicada e corresponde completamente a todos os valores da linha \$14 |
| 7 | Rose | rose@gmail | 23 | NJ | Esta é uma linha duplicada e corresponde completamente a todos os valores da linha \$15 |
Se você optar por combinar linhas inteiras, as linhas 6 e 7 serão removidas do conjunto de dados. O conjunto de dados agora é:
| Linha | Name | E-mail | Idade | Estado |
| --- | --- | --- | --- | --- |
| 1 | Joy | joy@gmail | 33 | NY |
| 2 | Tim | tim@gmail | 45 | OH |
| 3 | Rose | rose@gmail | 23 | NJ |
| 4 | Tim | tim@gmail | 42 | OH |
| 5 | Rose | rose@gmail | 23 | NJ |
Se você optar por especificar as chaves, poderá optar por remover as linhas que coincidem em 'nome' e 'e-mail'. Isso oferece um controle mais preciso do que é uma “linha duplicada” para seu conjunto de dados. Ao especificar 'nome' e 'e-mail', o conjunto de dados agora é:
| Linha | Name | E-mail | Idade | Estado |
| --- | --- | --- | --- | --- |
| 1 | Joy | joy@gmail | 33 | NY |
| 2 | Tim | tim@gmail | 45 | OH |
| 3 | Rose | rose@gmail | 23 | NJ |
Tenha em mente que:
+ Para que as linhas sejam reconhecidas como duplicadas, os valores diferenciam maiúsculas de minúsculas. Todos os valores nas linhas precisam ter a mesma letra maiúscula e minúscula - isso se aplica a qualquer opção escolhida (Combinar linhas inteiras ou Especificar chaves).
+ Todos os valores são lidos como cadeias de caracteres.
+ A transformação **Drop Duplicates** utiliza o comando dropDuplicates do Spark.
+ Ao usar a transformação **Drop Duplicates**, a primeira linha é mantida e as outras linhas são descartadas.
+ A transformação **Drop Duplicates** não altera o esquema do dataframe. Se você optar por especificar as chaves, todos os campos serão mantidos no dataframe resultante.
# Usar SelectFields (Selecionar campos) para remover a maioria das chaves de propriedade de dados
Você pode criar um subconjunto de chaves de propriedade de dados a partir do conjunto de dados usando a transformação *SelectFields* (Selecionar campos). Você indica quais chaves de propriedade de dados deseja manter e o restante é removido do conjunto de dados.
**nota**
A transformação *SelectFields* (Selecionar campos) diferencia maiúsculas de minúsculas. Use *ApplyMapping* (Aplicar mapeamentos) se você precisar de uma maneira de selecionar campos que não diferencie maiúsculas de minúsculas.
**Para adicionar um nó de transformação SelectFields ao diagrama de tarefas**
1. (Opcional) abra o painel Recurso e escolha **SelectFields**) para adicionar uma nova transformação ao diagrama de trabalho, se necessário.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Escolha a guia **Transform** (Transformação) no painel de detalhes do nó.
1. No cabeçalho **SelectFields** (Selecionar campos), escolha as chaves de propriedade de dados no conjunto de dados que você deseja manter. Quaisquer chaves de propriedade de dados não selecionadas são descartadas do conjunto de dados.
Você também pode marcar a caixa de seleção ao lado do cabeçalho de coluna **Field** (Campo) para escolher automaticamente todas as chaves de propriedade de dados do conjunto de dados. Em seguida, você pode desmarcar chaves de propriedade de dados individuais para removê-las do conjunto de dados.
1. (Opcional) depois de configurar as propriedades do nó de transformação, você pode visualizar o esquema modificado dos dados escolhendo a guia **Output schema** (Esquema de saída) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Se você não tiver especificado uma função do IAM na guia **Job details** (Detalhes do trabalho), você receberá uma solicitação para inserir uma função do IAM aqui.
1. (Opcional) depois de configurar as propriedades do nó e da transformação, você pode previsualizar o conjunto de dados modificado escolhendo a guia **Data preview** (Previsualização de dados) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Há um custo associado ao uso desse recurso e o a cobrança começa assim que você fornece uma função do IAM.
# Usar DropFields (Descartar campos) para manter a maioria das chaves de propriedade de dados
Você pode criar um subconjunto de chaves de propriedade de dados a partir do conjunto de dados usando a transformação *DropFields* (Descartar campos). Você indica quais chaves de propriedade de dados deseja remover e o restante é mantido no conjunto de dados.
**nota**
A transformação *DropFields* (Descartar campos) diferencia maiúsculas de minúsculas. Use *ApplyMapping* se você precisar de uma maneira de selecionar campos que não diferencie maiúsculas de minúsculas.
**Para adicionar um nó de transformação DropFields (Descartar campos) ao diagrama de trabalho**
1. (Opcional) abra o painel Recurso e escolha **DropFields**) para adicionar uma nova transformação ao diagrama de trabalho, se necessário.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Escolha a guia **Transform** (Transformação) no painel de detalhes do nó.
1. No cabeçalho **DropFields** (Descartar campos), escolha as chaves de propriedade de dados a serem descartadas da origem dos dados.
Você também pode marcar a caixa de seleção ao lado do cabeçalho de coluna **Field** (Campo) para escolher automaticamente todas as chaves de propriedade de dados do conjunto de dados. Em seguida, você pode cancelar a seleção de chaves de propriedade de dados individuais para que elas sejam mantidas no conjunto de dados.
1. (Opcional) depois de configurar as propriedades do nó de transformação, você pode visualizar o esquema modificado dos dados escolhendo a guia **Output schema** (Esquema de saída) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Se você não tiver especificado uma função do IAM na guia **Job details** (Detalhes do trabalho), você receberá uma solicitação para inserir uma função do IAM aqui.
1. (Opcional) depois de configurar as propriedades do nó e da transformação, você pode previsualizar o conjunto de dados modificado escolhendo a guia **Data preview** (Previsualização de dados) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Há um custo associado ao uso desse recurso e o a cobrança começa assim que você fornece uma função do IAM.
# Renomear um campo no conjunto de dados
Você pode usar a transformação *RenameField* (Renomear campo) para alterar o nome de uma chave de propriedade individual no conjunto de dados.
**nota**
A transformação *RenameField* (Renomear campo) diferencia maiúsculas de minúsculas. Use *ApplyMapping* (Aplicar mapeamento), se você precisar de uma transformação sem distinção entre maiúsculas e minúsculas.
**dica**
Se você usar a transformação *ApplyMapping*, poderá renomear várias chaves de propriedade de dados no conjunto de dados com uma única transformação.
**Para adicionar um nó de transformação RenameField (Renomear campo) ao diagrama de trabalho**
1. (Opcional) abra o painel Recurso e escolha **RenameField** para adicionar uma nova transformação ao diagrama de trabalho, se necessário.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Escolha a guia **Transform** (Transformação).
1. No cabeçalho **Data field** (Campo de dados), escolha uma chave de propriedade nos dados de origem e, em seguida, insira um novo nome no campo **New name field** (Novo nome de campo).
1. (Opcional) depois de configurar as propriedades do nó de transformação, você pode visualizar o esquema modificado dos dados escolhendo a guia **Output schema** (Esquema de saída) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Se você não tiver especificado uma função do IAM na guia **Job details** (Detalhes do trabalho), você receberá uma solicitação para inserir uma função do IAM aqui.
1. (Opcional) depois de configurar as propriedades do nó e da transformação, você pode previsualizar o conjunto de dados modificado escolhendo a guia **Data preview** (Previsualização de dados) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Há um custo associado ao uso desse recurso e o a cobrança começa assim que você fornece uma função do IAM.
# Usar Spigot (Torneira) para fazer uma amostra de seu conjunto de dados
Para testar as transformações executadas pelo trabalho, convém obter uma amostra dos dados para verificar se a transformação funciona como pretendido. A transformação *Spigot* (Torneira) grava um subconjunto de registros do conjunto de dados em um arquivo JSON, em um bucket do Amazon S3. O método de amostragem de dados pode ser um número especificado de registros desde o início do arquivo ou um fator de probabilidade usado para selecionar registros.
**Para adicionar um nó de transformação Spigot (Torneira) ao diagrama de trabalho**
1. (Opcional) abra o painel Recurso e escolha **Spigot** para adicionar uma nova transformação ao diagrama de trabalho, se necessário.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Escolha a guia **Transform** (Transformação) no painel de detalhes do nó.
1. Insira um caminho do Amazon S3 ou escolha **Browse S3** (Procurar no S3) para escolher um local no Amazon S3. Esse é o local onde o trabalho grava o arquivo JSON que contém a amostra de dados.
1. Insira informações para o método de amostragem. É possível especificar um valor em **Number of records** (Número de registros) para gravar a partir do início do conjunto de dados e um **Probability threshold** (Limite de probabilidade, inserido como um valor decimal com um valor máximo de 1) de escolher qualquer registro dado.
Por exemplo, para gravar os primeiros 50 registros do conjunto de dados, você definiria **Number of records** (Número de registros) como 50 e **Probability threshold** (Limite de probabilidade) como 1 (100%).
# Unir conjuntos de dados
A transformação *Join* (Unir) permite combinar dois conjuntos de dados em um. Você especifica os nomes das chaves no esquema de cada conjunto de dados a ser comparado. O `DynamicFrame` de saída contém linhas em que as chaves atendem à condição de união. As linhas em cada conjunto de dados que atendem à condição de união são combinadas em uma única linha no `DynamicFrame` de saída que contém todas as colunas encontradas em qualquer um dos conjuntos de dados.
**Para adicionar um nó de transformação Join (Unir) ao diagrama de trabalho**
1. Se houver apenas uma fonte de dados disponível, você deverá adicionar um novo nó de origem dos dados ao diagrama de trabalho.
1. Escolha um dos nós de origem para a união. Abra o painel Recurso e escolha **Unir** para adicionar uma nova transformação ao diagrama do trabalho.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho.
1. Na guia **Node properties** (Propriedades do nó), no cabeçalho **Node parents** (Nós pais), adicione um nó pai para que haja dois conjuntos de dados fornecendo entradas para a união. O pai pode ser um nó de origem dos dados ou um nó de transformação.
**nota**
Uma união pode ter apenas dois nós pais.
1. Escolha a guia **Transform** (Transformação).
Se você vir uma mensagem indicando que existem nomes de chaves conflitantes, você pode:
+ Escolher **Resolve it** (Resolver) para adicionar automaticamente um nó de transformação *ApplyMapping* (Aplicar mapeamento) em seu diagrama de trabalho. O nó ApplyMapping (Aplicar mapeamento) adiciona um prefixo a todas as chaves no conjunto de dados que tenham o mesmo nome de uma chave do outro conjunto de dados. Por exemplo, se você usar o valor padrão **right**, todas as chaves no conjunto de dados direito que tenham o mesmo nome de uma chave do conjunto de dados esquerdo serão renomeadas para `(right)key name`.
+ Adicionar manualmente um nó de transformação anteriormente no diagrama de trabalho para remover ou renomear as chaves conflitantes.
1. Escolha o tipo de junção na lista **Join type** (Tipo de união).
+ **Inner join** (União interna): retorna uma linha com colunas de ambos os conjuntos de dados para cada correspondência com base na condição de união. As linhas que não satisfazem a condição de união não são retornadas.
+ **Left join** (União à esquerda): todas as linhas do conjunto de dados esquerdo e somente as linhas do conjunto de dados direito que satisfazem a condição de união.
+ **Right join** (União à direita): todas as linhas do conjunto de dados direito e somente as linhas do conjunto de dados esquerdo que satisfazem a condição de união.
+ **Outer join** (União externa): todas as linhas de ambos os conjuntos de dados.
+ **Left semi join** (semi à esquerda): todas as linhas do conjunto de dados esquerdo que têm uma correspondência no conjunto de dados direito com base na condição de união.
+ **Left anti join** (anti à esquerda): todas as linhas do conjunto de dados esquerdo que não têm uma correspondência no conjunto de dados direito com base na condição de união.
1. Na guia **Transform** (Transformação), no cabeçalho **Join conditions** (Condições de união), escolha **Add condition** (Adicionar condição). Escolha uma chave de propriedade de cada conjunto de dados para comparar. As chaves de propriedade no lado esquerdo do operador de comparação são referidas como o conjunto de dados esquerdo e as chaves de propriedade à direita são referidas como o conjunto de dados direito.
Para condições de união mais complexas, você pode adicionar chaves correspondentes adicionais escolhendo **Add condition** (Adicionar condição) mais de uma vez. Se você adicionar uma condição acidentalmente, pode escolher o ícone de exclusão (![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/delete-icon-black.png)) para removê-la.
1. (Opcional) depois de configurar as propriedades do nó de transformação, você pode visualizar o esquema modificado dos dados escolhendo a guia **Output schema** (Esquema de saída) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Se você não tiver especificado uma função do IAM na guia **Job details** (Detalhes do trabalho), você receberá uma solicitação para inserir uma função do IAM aqui.
1. (Opcional) depois de configurar as propriedades do nó e da transformação, você pode previsualizar o conjunto de dados modificado escolhendo a guia **Data preview** (Previsualização de dados) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Há um custo associado ao uso desse recurso e o a cobrança começa assim que você fornece uma função do IAM.
Para obter um exemplo de esquema de saída de união, considere uma união entre dois conjuntos de dados com as seguintes chaves de propriedade:
```
Left: {id, dept, hire_date, salary, employment_status}
Right: {id, first_name, last_name, hire_date, title}
```
A união está configurada para corresponder nas chaves `id` e `hire_date` usando o operador de comparação `=`.
Como ambos os conjuntos de dados contêm as chaves `id` e `hire_date`, você escolhe **Resolve it** (Resolver) para adicionar automaticamente o prefixo **right** às chaves no conjunto de dados direito.
As chaves no esquema de saída seriam:
```
{id, dept, hire_date, salary, employment_status,
(right)id, first_name, last_name, (right)hire_date, title}
```
# Usando Union para combinar linhas
Você usa o nó de transformação Union quando deseja combinar linhas de mais de uma fonte de dados que tenham o mesmo esquema.
Existem dois tipos de transformações Union:
1. ALL - ao aplicar ALL, a união resultante não remove linhas duplicadas.
1. DISTINCT: ao aplicar DISTINCT, a união resultante remove as linhas duplicadas.
**Unions versus Joins**
Você usa Union para combinar linhas. Você usa Join para combinar colunas.
**Usando a transformação Union na tela Visual ETL**
1. Adicione mais de uma fonte de dados para realizar uma transformação de união. Para adicionar uma fonte de dados, abra o painel Recurso e escolha a fonte de dados na guia Fontes. Antes de usar a transformação Union, você deve garantir que todas as fontes de dados envolvidas na união tenham o mesmo esquema e estrutura.
1. Quando você tem pelo menos duas fontes de dados que deseja combinar usando a transformação Union, crie a transformação Union adicionando-a à tela. Abra o painel Recurso na tela e pesquise “Union”. Você também pode escolher a guia Transformações no painel Recursos e rolar para baixo até encontrar a transformação Union e, em seguida, escolher **Union**.
1. Selecione o nó Union na tela de trabalho. Na janela Propriedades do nó, escolha os nós principais para se conectar à transformação Union.
1. O AWS Glue verifica a compatibilidade para garantir que a transformação Union possa ser aplicada a todas as fontes de dados. Se o esquema das fontes de dados for o mesmo, a operação será permitida. Se as fontes de dados não tiverem o mesmo esquema, uma mensagem de erro de inválido será exibida: “Os esquemas de entrada dessa união não são os mesmos. Considere usar o ApplyMapping para combinar os esquemas.” Para corrigir isso, escolha usar **ApplyMapping**.
1. Escolha o tipo de união.
1. All: por padrão, o tipo de Union All é selecionado; isso resultará em linhas duplicadas, se houver alguma na combinação de dados.
1. Distinct: escolha Distinct se quiser que as linhas duplicadas sejam removidas da combinação de dados resultante.
# Usar SplitFields (Dividir campos) para dividir um conjunto de dados em dois
A transformação *SplitFields* (Dividir campos) permite que você escolha algumas das chaves de propriedade de dados no conjunto de dados de entrada, colocando-as em um conjunto de dados e as chaves não selecionadas em um conjunto de dados separado. A saída dessa transformação é uma coleção de `DynamicFrames`.
**nota**
Você deve usar uma transformação *SelectFromCollection* (Selecionar da coleção) para converter a coleção de `DynamicFrames` em um único `DynamicFrame` antes que você possa enviar a saída para um local de destino.
A transformação *SplitFields* (Dividir campos) diferencia maiúsculas de minúsculas. Adicione uma transformação *ApplyMapping* (Aplicar mapeamento) como um nó pai, se você precisar de nomes de chave de propriedade sem distinção entre maiúsculas e minúsculas.
**Para adicionar um nó de transformação SplitFields (Dividir campos) ao diagrama de trabalho**
1. (Opcional) abra o painel Recurso e escolha **Dividir campos** para adicionar uma nova transformação ao diagrama de trabalho, se necessário.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Escolha a guia **Transform** (Transformação).
1. Escolha quais chaves de propriedade você deseja colocar no primeiro conjunto de dados. As chaves que você não escolher serão colocadas no segundo conjunto de dados.
1. (Opcional) depois de configurar as propriedades do nó de transformação, você pode visualizar o esquema modificado dos dados escolhendo a guia **Output schema** (Esquema de saída) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Se você não tiver especificado uma função do IAM na guia **Job details** (Detalhes do trabalho), você receberá uma solicitação para inserir uma função do IAM aqui.
1. (Opcional) depois de configurar as propriedades do nó e da transformação, você pode previsualizar o conjunto de dados modificado escolhendo a guia **Data preview** (Previsualização de dados) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Há um custo associado ao uso desse recurso e o a cobrança começa assim que você fornece uma função do IAM.
1. Configure um nó de transformação *SelectFromCollection* (Selecionar da coleção) para processar os conjuntos de dados resultantes.
# Visão geral da transformação *SelectFromCollection*
Determinadas transformações têm vários conjuntos de dados como saída, em vez de um único conjunto de dados, por exemplo, *SplitFields* (Dividir campos). A transformação *SelectFromCollection* (Selecionar da coleção) seleciona um conjunto de dados (`DynamicFrame`) em uma coleção de conjuntos de dados (uma matriz de `DynamicFrames`). A saída da transformação é o selecionado `DynamicFrame`.
Você deve usá-la após usar uma transformação que cria uma coleção de `DynamicFrames`, tais como:
+ Transformações de código personalizado
+ *SplitFields*
Se você não adicionar um nó de transformação *SelectFromCollection* (Selecionar da coleção) em seu diagrama de trabalho após qualquer uma dessas transformações, você receberá um erro em seu trabalho.
O nó pai para essa transformação deve ser um nó que retorna uma coleção de `DynamicFrames`. Se você escolher um pai para esse nó de transformação que retorne um único `DynamicFrame`, como uma transformação *Join* (Unir), seu trabalho retornará um erro.
Da mesma forma, se você usar um nó *SelectFromCollection* (Selecionar da coleção) em seu diagrama de trabalho como pai para uma transformação que espera um único `DynamicFrame` como entrada, o trabalho retornará um erro.
![\[A captura de tela mostra o campo Node parents (Nós pais) na guia Node properties (Propriedades do nó) do painel de detalhes do nó. O nó pai selecionado é SplitFields e a mensagem de erro exibida diz “Parent node Split Fields outputs a collection, but node Drop Fields does not accept a collection” (O nó pai “Dividir campos” produz uma coleção, mas o nó “Descartar campos” não aceita coleções).\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/screenshot-edit-splitfields-wrong-parent.png)
# Usar SelectFromCollection (Selecionar da coleção) para escolher qual conjunto de dados manter
Use a transformação *SelectFromCollection* (Selecionar da coleção) para converter uma coleção de `DynamicFrames` em um único `DynamicFrame`.
**Para adicionar um nó de transformação SelectFromCollection (Selecionar da coleção) ao diagrama de tarefas**
1. (Opcional) Abra o painel Recurso e escolha **SelectFromCollection**) para adicionar uma nova transformação ao diagrama de trabalho, se necessário.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Escolha a guia **Transform** (Transformação).
1. No cabeçalho **Frame index** (Índice de quadros), escolha o número do índice da matriz que corresponde ao `DynamicFrame` que deseja selecionar na coleção de `DynamicFrames`.
Por exemplo, se o nó pai para essa transformação for uma transformação *SplitFields* (Dividir campos), na guia **Output schema** (Esquema de saída) desse nó, você pode ver o esquema de cada `DynamicFrame`. Se quiser manter o `DynamicFrame` associado ao esquema de **Output 2**, você pode selecionar **1** para o valor de **Frame index** (Índice de quadros), que é o segundo valor na lista.
Somente o `DynamicFrame` que você escolher será incluído na saída.
1. (Opcional) depois de configurar as propriedades do nó de transformação, você pode visualizar o esquema modificado dos dados escolhendo a guia **Output schema** (Esquema de saída) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Se você não tiver especificado uma função do IAM na guia **Job details** (Detalhes do trabalho), você receberá uma solicitação para inserir uma função do IAM aqui.
1. (Opcional) depois de configurar as propriedades do nó e da transformação, você pode previsualizar o conjunto de dados modificado escolhendo a guia **Data preview** (Previsualização de dados) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Há um custo associado ao uso desse recurso e o a cobrança começa assim que você fornece uma função do IAM.
# Localizar e preencher valores ausentes em um conjunto de dados
Você pode usar a transformação *FillMissingValues* (Preencher valores ausentes) para localizar registros no conjunto de dados que têm valores ausentes e adicionar um novo campo com um valor determinado por imputação. O conjunto de dados de entrada é usado para treinar o modelo de machine learning (ML) que determina qual deve ser o valor ausente. Se você usar conjuntos de dados incrementais, cada conjunto incremental será usado como dados de treinamento para o modelo de ML, portanto, os resultados podem não ser tão precisos.
**Para adicionar um nó de transformação FillMissingValues (Preencher valores ausentes) ao diagrama de trabalho**
1. (Opcional) abra o painel Recurso e escolha **FillMissingValues**) para adicionar uma nova transformação ao diagrama de trabalho, se necessário.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Escolha a guia **Transform** (Transformação).
1. Em **Data field** (Campo de dados), escolha o nome da coluna ou do campo nos dados de origem que você deseja analisar quanto a valores ausentes.
1. (Opcional) no campo **New field name** (Nome do novo campo), insira um nome para o campo adicionado a cada registro que manterá o valor estimado de substituição para o campo analisado. Se o campo analisado não tiver um valor ausente, o valor no campo analisado será copiado para o novo campo.
Se você não especificar um nome para o novo campo, o nome padrão será o nome da coluna analisada seguido de `_filled`. Por exemplo, se você inserir **Age** em **Data field** (Campo de dados) e não especificar um valor para **New field name** (Nome do novo campo), um novo campo chamado **Age\$1filled** será adicionado a cada registro.
1. (Opcional) depois de configurar as propriedades do nó de transformação, você pode visualizar o esquema modificado dos dados escolhendo a guia **Output schema** (Esquema de saída) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Se você não tiver especificado uma função do IAM na guia **Job details** (Detalhes do trabalho), você receberá uma solicitação para inserir uma função do IAM aqui.
1. (Opcional) depois de configurar as propriedades do nó e da transformação, você pode previsualizar o conjunto de dados modificado escolhendo a guia **Data preview** (Previsualização de dados) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Há um custo associado ao uso desse recurso e o a cobrança começa assim que você fornece uma função do IAM.
# Filtrar chaves dentro de um conjunto de dados
Use a transformação *Filter* (Filtro) para criar um novo conjunto de dados filtrando registros do conjunto de dados de entrada com base em uma expressão regular. As linhas que não satisfaçam a condição do filtro são removidas da saída.
+ Para tipos de dados de string, você pode filtrar linhas em que o valor da chave corresponde a uma string especificada.
+ Para tipos de dados numéricos, você pode filtrar linhas comparando o valor da chave com um valor especificado usando os operadores de comparação `<`, `>`, `=`, `!=`, `<=` e `>=`.
Se você especificar várias condições de filtro, os resultados serão combinados usando um operador `AND` por padrão, mas você pode escolher `OR` em vez disso.
A transformação *Filter* (Filtro) diferencia maiúsculas de minúsculas. Adicione uma transformação *ApplyMapping* (Aplicar mapeamento) como um nó pai, se você precisar de nomes de chave de propriedade sem distinção entre maiúsculas e minúsculas.
**Para adicionar um nó de transformação Filter (Filtro) ao diagrama de trabalho**
1. (Opcional) Abra o painel Recurso e escolha **Filtro** para adicionar uma nova transformação ao diagrama de trabalho, se necessário.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Escolha a guia **Transform** (Transformação).
1. Escolha **Global AND** ou **Global OR**. Isso determina como várias condições de filtro são combinadas. Todas as condições são combinadas usando os operadores `AND` ou `OR`. Se você tiver apenas uma única condição de filtro, pode escolher qualquer uma.
1. Escolha o botão **Add condition** (Adicionar condição) na seção **Filter condition** (Condição de filtro) para adicionar uma condição de filtro.
No campo **Key** (Chave), escolha um nome de chave de propriedade do conjunto de dados. No campo **Operation** (Operação), escolha o operador de comparação. No campo **Value** (Valor), insira o valor de comparação. Estes são alguns exemplos de configurações de filtro:
+ `year >= 2018`
+ `State matches 'CA*'`
Ao filtrar valores de string, certifique-se de que o valor de comparação usa um formato de expressão regular que corresponda à linguagem de script selecionada nas propriedades do trabalho (Python ou Scala).
1. Adicione mais condições de filtro, conforme necessário.
1. (Opcional) depois de configurar as propriedades do nó de transformação, você pode visualizar o esquema modificado dos dados escolhendo a guia **Output schema** (Esquema de saída) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Se você não tiver especificado uma função do IAM na guia **Job details** (Detalhes do trabalho), você receberá uma solicitação para inserir uma função do IAM aqui.
1. (Opcional) depois de configurar as propriedades do nó e da transformação, você pode previsualizar o conjunto de dados modificado escolhendo a guia **Data preview** (Previsualização de dados) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Há um custo associado ao uso desse recurso e o a cobrança começa assim que você fornece uma função do IAM.
# Usar DropNullFields para remover campos com valores nulos
Use a transformação *DropNullFields* para remover campos do conjunto de dados se todos os valores no campo forem "null". Por padrão, o AWS Glue Studio reconhecerá objetos nulos, mas alguns valores como strings vazias, strings "null", inteiros -1 ou outros espaços reservados, como zeros, não são reconhecidos automaticamente como nulos.
**Para usar DropNullFields**
1. Adicione um nó DropNullFields ao diagrama do trabalho.
1. Na guia **Node properties** (Propriedades do nó), escolha valores adicionais que representem um valor nulo. Você pode optar por selecionar nenhum ou todos os valores:
![\[A captura de tela mostra a guia Transform (Transformação) para o nó DropNullFields.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/DropNullFields-transform-tab.png)
+ String vazia ("" ou ''): os campos que contiverem strings vazias serão removidos
+ "String null": os campos que contiverem a string com a palavra "null" serão removidos
+ Inteiro -1: os campos que contiverem um número inteiro -1 (menos um) serão removidos
1. Se necessário, você também poderá especificar valores nulos personalizados. Esses são valores nulos que podem ser exclusivos do seu conjunto de dados. Para adicionar um valor nulo personalizado, escolha **Add new value** (Adicionar novo valor).
1. Insira o valor nulo personalizado. Por exemplo, ele pode zero ou qualquer valor que esteja sendo usado para representar um nulo no conjunto de dados.
1. Escolha o tipo de dados no campo suspenso. Os tipos de dados podem ser String ou Integer.
**nota**
Os valores nulos personalizados e seus tipos de dados devem corresponder exatamente para que os campos sejam reconhecidos como valores nulos e os campos removidos. Correspondências parciais em que apenas o valor nulo personalizado corresponde, mas o tipo de dados não resultará na remoção dos campos.
# Usar uma consulta SQL para transformar dados
Você pode usar uma transformação **SQL** para escrever sua própria transformação na forma de uma consulta SQL.
Um nó de transformação SQL pode ter vários conjuntos de dados como entradas, mas produz apenas um único conjunto de dados como saída. Ele contém um campo de texto, onde você insere a consulta do Apache SparkSQL. Você pode atribuir aliases a cada conjunto de dados usado como entrada, para ajudar a simplificar a consulta SQL. Para obter mais informações sobre a sintaxe SQL, consulte a [documentação do Spark SQL](https://spark.apache.org/docs/latest/sql-ref.html).
**nota**
Se você usar uma transformação do Spark SQL com uma origem dos dados localizada em uma VPC, adicione um endpoint da VPC do AWS Glue à VPC que contém a origem dos dados. Para obter mais informações sobre como configurar endpoints de desenvolvimento, consulte [Adicionar um endpoint de desenvolvimento](https://docs.aws.amazon.com/glue/latest/dg/add-dev-endpoint.html), [Configurar seu ambiente para endpoints de desenvolvimento](https://docs.aws.amazon.com/glue/latest/dg/start-development-endpoint.html) e [Acessar o endpoint de desenvolvimento](https://docs.aws.amazon.com/glue/latest/dg/dev-endpoint-elastic-ip.html) no *Guia do desenvolvedor do AWS Glue*.
**Para usar um nó de transformação SQL no diagrama de trabalho**
1. (Opcional) adicione um nó de transformação ao diagrama de trabalho, se necessário. Escolha **Consulta SQL** para o tipo de nó.
**nota**
Se você usar uma sessão de visualização de dados e um SQL personalizado ou um nó de código personalizado, a sessão de visualização de dados executará o SQL ou o bloco de código no estado em que se encontra para todo o conjunto de dados.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho. Se um nó pai ainda não estiver selecionado, ou se você quiser várias entradas para a transformação SQL, escolha um nó na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação. Adicione nós pais conforme necessário.
1. Escolha a guia **Transform** (Transformação) no painel de detalhes do nó.
1. Os conjuntos de dados de origem para a consulta SQL são identificados pelos nomes especificados no campo **Name** (Nome) de cada nó. Se você não quiser usar esses nomes, ou se eles não forem adequados para uma consulta SQL, você pode associar um nome a cada conjunto de dados. O console fornece aliases padrão, como `MyDataSource`.
Por exemplo, se um nó pai do nó de transformação SQL for nomeado como `Rename Org PK field`, você poderá associar o nome `org_table` com este conjunto de dados. Esse alias pode ser usado na consulta SQL no lugar do nome do nó.
1. No campo de entrada de texto, no cabeçalho **Code block** (Bloco de código), cole ou insira a consulta SQL. O campo de texto exibe o realce da sintaxe SQL e sugestões de palavra-chave.
1. Com o nó de transformação SQL selecionado, escolha a guia **Output schema** (Esquema de saída) e, em seguida, escolha **Edit** (Editar). Forneça as colunas e os tipos de dados que descrevem os campos de saída da consulta SQL.
Especifique o esquema usando as seguintes ações na seção **Output schema** (Esquema de saída) da página:
+ Para renomear uma coluna, coloque o cursor na caixa de texto **Key** (Chave) da coluna (também conhecida como *field* (campo) ou *property key* [chave de propriedade]) e insira o novo nome.
+ Para alterar o tipo de dados de uma coluna, selecione o novo tipo de dados para a coluna na lista suspensa.
+ Para adicionar uma nova coluna de nível superior ao esquema, escolha o botão Overflow (excedente, ![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/edit-schema-actions-button.png)) e, em seguida, escolha **Add root key** (Adicionar chave raiz). Novas colunas são adicionadas na parte superior do esquema.
+ Para remover uma coluna do esquema, escolha o ícone de exclusão (![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/delete-icon-black.png)) à extrema direita do nome da chave.
1. Quando terminar de especificar o esquema de saída, escolha **Apply** (Aplicar) para salvar suas alterações e saia do editor de esquema. Se não quiser salvar as alterações, escolha **Cancel** (Cancelar) para editar o editor de esquemas.
1. (Opcional) depois de configurar as propriedades do nó e da transformação, você pode previsualizar o conjunto de dados modificado escolhendo a guia **Data preview** (Previsualização de dados) no painel de detalhes do nó. Na primeira vez que você escolher essa guia para qualquer nó em seu trabalho, você receberá uma solicitação para fornecer uma função do IAM para acessar os dados. Há um custo associado ao uso desse recurso e o a cobrança começa assim que você fornece uma função do IAM.
# Usar Aggregate para fazer cálculos resumidos em campos selecionados
**Para usar a transformação Aggregate**
1. Adicione o nó Aggregate ao diagrama do trabalho.
1. Na guia **Node properties** (Propriedades de nó), escolha campos para agrupar selecionando o campo suspenso (opcional). Você pode selecionar mais de um campo por vez ou procurar um nome de campo digitando na barra de pesquisa.
Quando os campos são selecionados, o nome e o tipo de dados são mostrados. Para remover um campo, escolha "X" no campo.
![\[A captura de tela mostra a guia Transform (Transformação) para o nó Aggregate.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/Aggregate-transform-tab.png)
1. Selecione **Aggregate another column** (Agregar outra coluna). É necessário selecionar pelo menos um campo.
![\[A captura de tela mostra os campos quando a opção Aggregate another column (Agregar outra coluna) é escolhida.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/Aggregate-fieldtoaggregate.png)
1. Escolha um campo na lista suspensa **Field to aggregate** (Campo a ser agregado).
1. Escolha a função de agregação a ser aplicada ao campo escolhido:
+ avg: calcula a média
+ CountDistinct: calcula o número de valores não nulos exclusivos
+ count: calcula o número de valores não nulos
+ first: retorna o primeiro valor que satisfaz os critérios "agrupar por"
+ last: retorna o último valor que satisfaz os critérios "agrupar por"
+ kurtosis: calcula a nitidez do pico de uma curva de distribuição de frequência
+ max: retorna o maior valor que satisfaz os critérios "agrupar por"
+ min: retorna o menor valor que satisfaz os critérios "agrupar por"
+ skewness: medida da assimetria da distribuição de probabilidade de uma distribuição normal
+ stddev\$1pop: calcula o desvio padrão da população e retorna a raiz quadrada da variância da população
+ sum: a soma de todos os valores no grupo
+ sumDistinct: a soma dos valores distintos no grupo
+ var\$1samp: a variância da amostra do grupo (ignora nulos)
+ var\$1pop: a variância da população do grupo (ignora nulos)
# Nivelar structs aninhados
*Nivele* os campos de structs aninhados nos dados para transformá-los em campos de nível superior. Os novos campos são nomeados usando o nome do campo prefixado com os nomes dos campos de struct para alcançá-lo, separados por pontos.
Por exemplo, se os dados tiverem um campo do tipo Struct denominado “phone\$1numbers” que, entre outros campos, tenha um do tipo “Struct” denominado “home\$1phone” com dois campos: “country\$1code” e “number”. Depois de nivelados, esses dois campos se tornarão campos de nível superior denominados: “phone\$1numbers.home\$1phone.country\$1code” e “phone\$1numbers.home\$1phone.number”, respectivamente.
**Para adicionar um nó de transformação *Nivelar* ao diagrama do trabalho**
1. Abra o painel Recurso e escolha a guia **Transformações** e escolha **Nivelar** para adicionar uma nova transformação ao diagrama do trabalho. Você também pode usar a barra de pesquisa digitando 'Flatten' e clicando no nó Nivelar. O nó selecionado no momento da adição do nó será o nó superior.
![\[A captura de tela mostra o Painel Recurso e a barra de pesquisa preenchida com a palavra 'Flatten'. O resultado da pesquisa mostra a transformação Flatten.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transform-flatten.png)
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. (Opcional) Na guia **Transformação**, você pode limitar o nível máximo de aninhamento máximo a ser nivelado. Por exemplo, definir esse valor como 1 significa que somente structs de nível superior serão nivelados. Definir o máximo como 2 nivela o nível superior e os structs diretamente abaixo dele.
# Adicionar uma coluna de UUID
Quando você adiciona uma coluna *UUID* (Universally Unique Identified), cada linha recebe uma string exclusiva de 36 caracteres.
**Para adicionar um nó de transformação *UUID* ao diagrama do trabalho**
1. Abra o painel Recurso e escolha **UUID** para adicionar uma nova transformação ao seu diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. (Opcional) Na guia **Transformação**, você pode personalizar o nome da nova coluna. Por padrão, ela será denominada "uuid".
# Adicionar uma coluna de identificadores
Atribua um *identificador* numérico a cada linha no conjunto de dados.
**Para adicionar um nó de transformação *identificador* ao diagrama do trabalho**
1. Abra o painel Recurso e escolha **Identificador** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. (Opcional) Na guia **Transformação**, você pode personalizar o nome da nova coluna. Por padrão, ela será denominada "id".
1. (Opcional) Se o trabalho processar e armazenar dados de forma incremental, será importante evitar que os mesmos IDs sejam reutilizados em diversas execuções do trabalho.
Na guia **Transformação**, marque a opção **exclusivo** da caixa de seleção. Essa opção incluirá o timestamp do trabalho no identificador, tornando-o exclusivo entre as diversas execuções. Para permitir um número maior, a coluna em vez do tipo longo será um decimal.
# Converter uma coluna no tipo timestamp
Você pode usar a transformação *Em timestamp* para alterar o tipo de dados de uma coluna de numérico ou string em timestamp, para que ela possa ser armazenada com esse tipo de dados ou aplicada a outras transformações que exijam um timestamp.
**Para adicionar um nó de transformação *Em timestamp* ao diagrama do trabalho**
1. Abra o painel Recurso e escolha Em **Para timestamp** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformação**, insira o nome da coluna a ser convertida.
1. Na guia **Transformação**, defina como analisar a coluna selecionada escolhendo o tipo.
Se o valor for um número, ele poderá ser expresso em segundos (timestamp do Unix/Python), milissegundos ou microssegundos; escolha a opção correspondente.
Se o valor for uma string formatada, escolha o tipo “iso”, e a string precisará estar conforme com uma das variantes do formato ISO, por exemplo: “2022-11-02T14:40:59.915Z“.
Se não souber o tipo nesse momento ou se linhas diferentes usarem tipos diferentes, você poderá escolher ”detecção automática“ e o sistema fará sua melhor suposição, com um pequeno custo de desempenho.
1. (Opcional) Na guia **Transformação**, em vez de converter a coluna selecionada, você pode criar uma nova e manter a original inserindo um nome para a nova coluna.
# Converter uma coluna de timestamp em uma string formatada
Formate uma coluna do tipo timestamp em uma do tipo string de acordo com um padrão. Você pode usar *Formatar timestamp* para obter a data e a hora como uma string com o formato desejado. Você pode definir o formato usando a [sintaxe de data do Spark](https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html), bem como a maioria dos [códigos de data do Python](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes).
Por exemplo, se você quiser que a string de data seja formatada como “2023-01-01 00:00”, poderá definir esse formato usando a sintaxe do Spark como “aaaa-MM-dd HH:mm” ou os códigos de data equivalentes do Python como “%A-%m-%d %H: %M”
**Para adicionar um nó de transformação *Formatar timestamp* ao diagrama do trabalho**
1. Abra o painel Recurso e escolha **Formatar timestamp** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformação**, insira o nome da coluna a ser convertida.
1. Na guia **Transformação**, insira o padrão de **Formato de timestamp** a ser usado, expresso com a [sintaxe de data do Spark](https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html) ou os [códigos de data do Python](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes).
1. (Opcional) Na guia **Transformação**, em vez de converter a coluna selecionada, você pode criar uma nova e manter a original inserindo um nome para a nova coluna.
# Criar uma transformação de roteador condicional
A transformação de roteador condicional permite que você aplique várias condições aos dados de entrada. Cada linha dos dados de entrada avaliada por uma condição de filtro de grupo e processada no grupo correspondente. Se uma linha atender a mais de uma condição de filtro de grupo, a transformação passará a linha para vários grupos. Se uma linha não atender a nenhuma condição, poderá ser descartada ou roteada para um grupo de saída padrão.
Essa transformação é semelhante à transformação de filtro, mas é útil para usuários que desejem testar os mesmos dados de entrada em várias condições.
**Para adicionar uma transformação condicional de roteador:**
1. Escolha um nó onde você realizará a transformação de roteador condicional. Esse pode ser um nó de origem ou outra transformação.
1. Escolha **Ação** e use a barra de pesquisa para localizar e escolher “Roteador condicional”. Uma transformação de **roteador condicional** é adicionada junto com dois nós de saída. Um único nó de saída, "Grupo padrão", contém os registros que não atendem a nenhuma das condições definidas nos outros nós de saída. O grupo padrão não pode ser editado.
![\[A captura de tela mostra o nó da transformação de roteador condicional conectado a um nó de origem. Os nós de saída são mostrados como ramificações do nó de roteador condicional.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transform-conditional-router-node.png)
Você pode adicionar outros grupos de saída escolhendo **Adicionar grupo**. Para cada grupo de saída, você pode nomear o grupo e adicionar condições de filtro e um operador lógico.
![\[A captura de tela mostra a guia de transformação de roteador condicional com opções para nomear o grupo de saída, o operador lógico e os filtros condicionais.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transform-conditional-router-tab.png)
1. Dê outro nome ao grupo de saída inserindo um novo nome para o grupo. O AWS Glue Studio nomeará automaticamente os grupos para você (por exemplo, "output\$1group\$11").
1. Escolha um operador lógico (**AND**, **OR**) e adicione uma **condição de filtro** especificando **Chave**, **Operação** e **Valor**. Os operadores lógicos permitem que você implemente mais de uma condição de filtro e aplique o operador lógico a cada condição de filtro especificada.
Ao especificar a chave, você pode escolher entre as chaves disponíveis em seu esquema. Em seguida, escolha a operação disponível de acordo com o tipo de chave selecionada. Por exemplo, se o tipo de chave for "string", a operação disponível para você escolher é "matches".
![\[A captura de tela mostra a guia de transformação de roteador condicional com os campos de condição do filtro para chave, operação e valor.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transform-conditional-router-filter-condition.png)
1. Insira o valor no campo **Valor**. Selecione **Adicionar condição** para adicionar mais condições. Para remover condições de filtro, selecione o ícone de lixeira.
# Usando a transformação Concatenate Columns para acrescentar colunas
A transformação Concatenate permite que você crie uma nova coluna de strings usando os valores de outras colunas com um espaçador opcional. Por exemplo, se definirmos uma coluna concatenada “data” como a concatenação de “ano”, “mês” e “dia” (nessa ordem) com “-” como espaçador, obteríamos:
| dia | mês | ano | date |
| --- | --- | --- | --- |
| 01 | 01 | 2020 | 2020-01-01 |
| 02 | 01 | 2020 | 2020-01-02 |
| 03 | 01 | 2020 | 2020-01-03 |
| 04 | 01 | 2020 | 2020-01-04 |
**Para adicionar uma transformação Concatenate:**
1. Abra o painel Recurso. Em seguida, escolha **Concatenate Columns** para adicionar uma nova transformação ao diagrama de trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista Node parents (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, insira o nome da coluna que conterá a string concatenada, bem como as colunas a serem concatenadas. A ordem na qual você marcar as colunas na lista suspensa será a ordem usada.
![\[A captura de tela mostra a guia Transformar para a transformação Concatenate.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transforms-concatenate-transform-tab.png)
1. **Espaçador - opcional** - Insira uma string para colocar entre os campos concatenados. Por padrão, não há espaçador.
1. **Valor nulo - opcional**: insira uma string a ser usada quando o valor de uma coluna for nulo. Por padrão, nos casos em que as colunas têm o valor 'NULL' ou 'NA', é usada uma string vazia.
# Usar a transformação Split String para dividir uma coluna de string
A transformação Split String permite que você divida uma string em uma matriz de tokens usando uma expressão regular para definir como a divisão é feita. Em seguida, você pode manter a coluna como um tipo de matriz ou aplicar uma transformação **Array To Columns** após esta, para extrair os valores da matriz nos campos de nível superior, supondo que cada token tenha um significado que conhecemos de antemão. Além disso, se a ordem dos tokens for irrelevante (por exemplo, um conjunto de categorias), você poderá usar a transformação **Explode** para gerar uma linha separada para cada valor.
Por exemplo, você pode dividir a coluna “categories” usando uma vírgula como padrão para adicionar uma coluna “categories\$1arr”.
| product\$1id | categories | categories\$1arr |
| --- | --- | --- |
| 1 | esportes, inverno | [esportes, inverno] |
| 2 | jardim, ferramentas | [jardim, ferramentas] |
| 3 | videogames | [videogames] |
| 4 | jogo, jogo de tabuleiro, social | [jogo, jogo de tabuleiro, social] |
**Para adicionar uma transformação Split String:**
1. Abra o painel Recurso e escolha Split String para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia Propriedades do nó, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista Node parents (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, escolha a coluna a ser dividida e insira o padrão a ser usado para dividir a string. Na maioria dos casos, você pode simplesmente inserir o(s) caractere(s), a menos que tenha um significado especial como expressão regular e precise de escape. Os caracteres que precisam de escape são: `\.[]{}()<>*+-=!?^$|` adicionando uma barra invertida na frente do caractere. Por exemplo, se você quiser separar por um ponto ('.'), você precisa inserir `\.`. No entanto, uma vírgula não tem um significado especial e só pode ser especificada como está: `,`.
![\[A captura de tela mostra a guia Transformar para a transformação Split String.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transforms-split-string-transform-tab.png)
1. (Opcional) Se você quiser manter a coluna de string original, poderá inserir um nome para uma nova coluna de matriz, mantendo assim a coluna de string original e a nova coluna de matriz tokenizada.
# Usando a transformação Array To Columns para extrair os elementos de uma matriz para colunas de nível superior
A transformação Array To Columns permite extrair alguns ou todos os elementos de uma coluna do tipo matriz para novas colunas. A transformação preencherá as novas colunas o máximo possível se a matriz tiver valores suficientes para extrair, opcionalmente usando os elementos nas posições especificadas.
Por exemplo, se você tiver uma coluna de matriz “sub-rede”, que foi o resultado da aplicação da transformação “Split String” em uma sub-rede ip v4, você pode extrair a primeira e a quarta posições para as novas colunas “primeiro\$1octeto” e “quarto\$1octeto”. A saída da transformação neste exemplo seria (observe que as duas últimas linhas têm matrizes mais curtas do que o esperado):
| sub-rede | primeiro\$1octeto | quarto\$1octeto |
| --- | --- | --- |
| [54, 240, 197, 238] | 54 | 238 |
| [192, 168, 0, 1] | 192 | 1 |
| [192, 168] | 192 | |
| [] | | |
**Para adicionar uma transformação Array To Columns:**
1. Abra o painel Recurso e escolha **Array To Columns** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista Node parents (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, escolha a coluna da matriz a ser extraída e insira a lista de novas colunas para os tokens extraídos.
![\[A captura de tela mostra a guia Transformar para a transformação Array To Columns.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transforms-array-to-columns-transform-tab.png)
1. (Opcional) Se não quiser usar os tokens da matriz para atribuir às colunas, você pode especificar os índices a serem obtidos, que serão atribuídos à lista de colunas na mesma ordem especificada. Por exemplo, se as colunas de saída forem “coluna1, coluna2, coluna3” e os índices “4, 1, 3”, o quarto elemento da matriz irá para a coluna1, o primeiro para a coluna2 e o terceiro para a coluna3 (se a matriz for menor que o número do índice, será atribuído um valor NULL).
# Usar a transformação Add Current Timestamp
A transformação **Add Current Timestamp** permite marcar as linhas com a hora em que os dados foram processados. Isso é útil para fins de auditoria ou para rastrear a latência no pipeline de dados. Você pode adicionar essa nova coluna como um tipo de dados de carimbo de data/hora ou como string formatada.
**Para adicionar uma transformação Add Current Timestamp:**
1. Abra o painel Recurso e escolha **Add Current Timestamp** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista Node parents (Nós pais) para usar como fonte de entrada para a transformação.
![\[A captura de tela mostra a guia Transformar para a transformação Add Current Timestamp.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transforms-add-current-timestamp-transform-tab.png)
1. (Opcional) Na guia **Transformar**, insira um nome personalizado para a nova coluna e um formato se você preferir que a coluna seja uma string de data formatada.
# Usar a transformação Pivot Rows to Columns
A transformação **Pivot Rows to Columns** permite agregar uma coluna numérica girando valores exclusivos nas colunas selecionadas que se tornam novas colunas (se várias colunas forem selecionadas, os valores serão concatenados para nomear as novas colunas). Dessa forma, as linhas são consolidadas e têm mais colunas com agregações parciais para cada valor exclusivo. Por exemplo, se você tiver esse conjunto de dados de vendas por mês e país (classificado para ser mais fácil de ilustrar):
| ano | mês | país | valor |
| --- | --- | --- | --- |
| 2020 | Jan | uk | 32 |
| 2020 | Jan | de | 42 |
| 2020 | Jan | us | 64 |
| 2020 | Fev | uk | 67 |
| 2020 | Fev | de | 4 |
| 2020 | Fev | de | 7 |
| 2020 | Fev | us | 6 |
| 2020 | Fev | us | 12 |
| 2020 | Jan | us | 90 |
Se você utilizar **valor** e **país** como as colunas de agregação, novas colunas serão criadas a partir da coluna **país** original. Na tabela abaixo, você tem novas colunas para **de**, **uk** e **us** em vez da coluna **país**.
| ano | mês | de | uk | us |
| --- | --- | --- | --- | --- |
| 2020 | Jan | 42 | 32 | 64 |
| 2020 | Jan | 11 | 67 | 18 |
| 2021 | Jan | | | 90 |
Se, em vez disso, você quiser dinamizar o mês e o país, obterá uma coluna para cada combinação dos valores dessas colunas:
| ano | Jan\$1de | Jan\$1uk | Jan\$1us | Fev\$1de | Fev\$1uk | Fev\$1us |
| --- | --- | --- | --- | --- | --- | --- |
| 2020 | 42 | 32 | 64 | 11 | 67 | 18 |
| 2021 | | | 90 | | | |
**Para adicionar uma transformação Pivot Rows Ro Columns:**
1. Abra o painel Recurso e escolha **Pivot Rows To Columns** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista Node parents (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, escolha a coluna numérica que será agregada para produzir os valores para as novas colunas, a função de agregação a ser aplicada e a(s) coluna(s) cujos valores exclusivos serão convertidos em novas colunas.
![\[A captura de tela mostra a guia Transform para a transformação Pivot Rows To Columns.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transforms-pivot-rows-to-columns-transform-tab.png)
# Usar a transformação Unpivot Columns To Rows
A transformação **Unpivot** permite converter colunas em valores de novas colunas, gerando uma linha para cada valor exclusivo. É o oposto de pivot, mas observe que não é equivalente, pois não pode separar linhas com valores idênticos que eram agregados ou dividir combinações nas colunas originais (você pode fazer isso posteriormente usando uma transformação Split). Por exemplo, se tiver a seguinte tabela:
| ano | mês | de | uk | us |
| --- | --- | --- | --- | --- |
| 2020 | Jan | 42 | 32 | 64 |
| 2020 | Fev | 11 | 67 | 18 |
| 2021 | Jan | | | 90 |
Você pode despivotar as colunas: “de”, “uk” e “us” em uma coluna “país” com o valor “quantidade” e obter o seguinte (classificado aqui para fins de ilustração):
| ano | mês | país | valor |
| --- | --- | --- | --- |
| 2020 | Jan | uk | 32 |
| 2020 | Jan | de | 42 |
| 2020 | Jan | us | 64 |
| 2020 | Fev | uk | 67 |
| 2020 | Fev | de | 11 |
| 2020 | Fev | us | 18 |
| 2021 | Jan | us | 90 |
Observe que as colunas que têm um valor NULL (“de” e “uk” de jan 2021) não são geradas por padrão. Você pode ativar essa opção para obter:
| ano | mês | país | valor |
| --- | --- | --- | --- |
| 2020 | Jan | uk | 32 |
| 2020 | Jan | de | 42 |
| 2020 | Jan | us | 64 |
| 2020 | Fev | uk | 67 |
| 2020 | Fev | de | 11 |
| 2020 | Fev | us | 18 |
| 2021 | Jan | us | 90 |
| 2021 | Jan | de | |
| 2021 | Jan | uk | |
**Para adicionar uma transformação Unpivot Columns to Rows:**
1. Abra o painel Recurso e escolha **Unpivot Rows To Columns** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista Node parents (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, insira as novas colunas a serem criadas para conter os nomes e valores das colunas escolhidas para despivotar.
![\[A captura de tela mostra a guia Transformar para a transformação Unpivot Columns To Rows.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transforms-unpivot-columns-to-rows-transform-tab.png)
# Usando a transformação Autobalance Processing para otimizar seu runtime
A transformação **Autobalance Processing** redistribui os dados entre os operadores para melhorar a performance. Isso ajuda nos casos em que os dados estão desbalanceados ou, como vêm da fonte, não permitem processamento paralelo suficiente. Isso é comum quando a fonte é compactada com gzip ou é JDBC. A redistribuição de dados tem um custo de performance módico, portanto, a otimização nem sempre compensará esse esforço se os dados já estiverem bem balanceados. Por baixo, a transformação usa a repartição do Apache Spark para reatribuir dados aleatoriamente entre um número de partições ideal para a capacidade do cluster. Para usuários avançados, é possível inserir um número de partições manualmente. Além disso, ele pode ser usado para otimizar a gravação de tabelas particionadas reorganizando os dados com base em colunas especificadas. Isso resulta em arquivos de saída mais consolidados.
****
1. Abra o painel Recurso e escolha **Autobalance Processing** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista Node parents (Nós pais) para usar como fonte de entrada para a transformação.
1. (Opcional) Na guia **Transformação**, você pode inserir um número de partições. Em geral, é recomendável que você deixe o sistema decidir esse valor, mas pode ajustar o multiplicador ou inserir um valor específico se precisar controlar isso. Se você for salvar os dados particionados por colunas, poderá escolher as mesmas colunas que as colunas de repartição. Dessa forma, minimizará o número de arquivos em cada partição e evitará muitos arquivos por partição, o que prejudicaria a performance das ferramentas que consultam esses dados.
![\[A captura de tela mostra a guia Transformar para a transformação Autobalance Processing.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transforms-autobalance-processing-transform-tab.png)
# Usando a transformação Derived Column para combinar outras colunas
A transformação **Derived Column** permite definir uma nova coluna com base em uma fórmula matemática ou expressão SQL na qual você pode usar outras colunas nos dados, além de constantes e literais. Por exemplo, para derivar uma coluna de “porcentagem” das colunas “success” e “count”, você pode inserir a expressão SQL: “success \$1 100/count \$1\$1 '%'”.
Exemplo de resultado:
| success | contagem | percentage |
| --- | --- | --- |
| 14 | 100 | 14% |
| 6 | 20 | 3% |
| 3 | 40 | 7,5% |
**Para adicionar uma transformação Derived Column:**
1. Abra o painel Recurso e escolha **Derived Column** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista Node parents (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transform**, insira o nome da coluna e a expressão do conteúdo.
![\[A captura de tela mostra a guia Transform para a transformação Derived Column.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transforms-dervied-column-transform-tab.png)
# Usar a transformação Lookup para adicionar dados correspondentes de uma tabela de catálogo
A transformação **Lookup** permite adicionar colunas de uma tabela de catálogo definida quando as chaves correspondem às colunas de pesquisa definidas nos dados. Isso equivale a fazer uma junção externa esquerda entre os dados e a tabela de pesquisa usando como condição as colunas correspondentes.
**Para adicionar uma transformação Lookup:**
1. Abra o painel Recurso e escolha **Lookup** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista Node parents (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, insira o nome totalmente qualificado da tabela de catálogo a ser usado para realizar as pesquisas. Por exemplo, se seu banco de dados for “mydb” e sua tabela “mytable”, digite “mydb.mytable”. Em seguida, insira os critérios para encontrar uma correspondência na tabela de pesquisa, se a chave de pesquisa for composta. Insira a lista de colunas de chave separadas por vírgulas. Se uma ou mais das colunas de chave não tiverem o mesmo nome, você precisará definir o mapeamento de correspondência.
Por exemplo, se as colunas de dados forem “user\$1id” e “region” e na tabela de usuários as colunas correspondentes forem denominadas “id” e “region”, no campo **Colunas a serem correspondidas**, digite: "user\$1id=id, region". Você poderia fazer region=region, mas não é necessário, pois são iguais.
1. Por fim, insira as colunas a serem extraídas da linha correspondente na tabela de pesquisa para incorporá-las aos dados. Se nenhuma correspondência for encontrada, essas colunas serão definidas como NULL.
**nota**
Abaixo da transformação **Lookup**, está sendo usada uma junção à esquerda para ser eficiente. Se a tabela de pesquisa tiver uma chave composta, certifique-se de que as colunas correspondentes estejam configuradas para corresponder a todas as colunas-chave, de forma que somente uma correspondência possa ocorrer. Caso contrário, várias linhas de pesquisa corresponderão e isso resultará na adição de linhas extras para cada uma dessas correspondências.
![\[A captura de tela mostra a guia Transformar para a transformação Lookup.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transforms-lookup-transform-tab.png)
# Usando a transformação Explode Array ou Map Into Rows
A transformação **Explode** permite extrair valores de uma estrutura aninhada em linhas individuais que são mais fáceis de manipular. No caso de uma matriz, a transformação gerará uma linha para cada valor da matriz, replicando os valores para as outras colunas na linha. No caso de um mapa, a transformação gerará uma linha para cada entrada com a chave e o valor como colunas, além de quaisquer outras colunas na linha.
Por exemplo, se tivermos esse conjunto de dados que tem uma coluna de matriz “categoria” com vários valores.
| product\$1id | categoria |
| --- | --- |
| 1 | [esportes, inverno] |
| 2 | [jardim, ferramentas] |
| 3 | [videogames] |
| 4 | [jogo, jogo de tabuleiro, social] |
| 5 | [] |
Se você explodir a coluna “categoria” em uma coluna com o mesmo nome, você substituirá a coluna. Você pode selecionar que deseja que os NULLs sejam incluídos para obter o seguinte (ordenado para fins ilustrativos):
| product\$1id | categoria |
| --- | --- |
| 1 | esportes |
| 1 | inverno |
| 2 | jardim |
| 2 | ferramenta |
| 3 | videogames |
| 4 | jogo |
| 4 | jogo de tabuleiro |
| 4 | social |
| 5 | |
**Para adicionar uma transformação Explode Array ou Map Into Rows:**
1. Abra o painel Recurso e escolha **Explode Array Or Map Into Rows** para adicionar uma nova transformação ao diagrama do seu trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. (Opcional) Na guia **Propriedades do nó**, insira um nome para o nó no diagrama do trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista Node parents (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, escolha a coluna a ser explodida (ela deve ser um tipo de matriz ou mapa). Em seguida, insira um nome para a coluna para os itens da matriz ou os nomes das colunas para as chaves e valores se você estiver explodindo um mapa.
1. (Opcional) Na guia **Transformar**, por padrão, se a coluna a ser explodida for NULL ou tiver uma estrutura vazia, ela será omitida no conjunto de dados explodido. Se você quiser manter a linha (com as novas colunas como NULL), marque “Incluir NULLs”.
![\[A captura de tela mostra a guia Transformar para a transformação Explode Array ou Map Into Rows.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/transforms-explode-array-transform-tab.png)
# Usar a transformação Record Matching para invocar uma transformação de classificação de dados existentes
Usar a transformação invoca uma transformação de classificação de dados de machine learning Record Matching existente.
A transformação avalia os dados atuais em relação ao modelo treinado com base em rótulos. Uma coluna “match\$1id” é adicionada para atribuir cada linha a um grupo de itens considerados equivalentes com base no treinamento do algoritmo. Para obter mais informações, consulte [Correspondência de registros com Lake Formation FindMatches](https://docs.aws.amazon.com/glue/latest/dg/machine-learning.html).
**nota**
A versão do AWS Glue usada pelo trabalho visual deve corresponder à versão que o AWS Glue usou para criar a transformação Record Matching.
![\[A captura de tela mostra uma visualização dos dados para a transformação.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/recording-matching-transform-1.png)
**Para adicionar um nó de transformação Record Matching ao diagrama de trabalho**
1. Abra o painel Recurso e escolha **Record Matching** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. No painel propriedades do nó, insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, insira a ID retirada da página **Transformações de machine learning**:
![\[A captura de tela mostra a ID da página Transformações de machine learning.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/recording-matching-transform-2.png)
1. (Opcional) Na guia **Transformação**, você pode marcar a opção de adicionar as pontuações de confiança. Ao custo de computação extra, o modelo estimará uma pontuação de confiança para cada correspondência como uma coluna adicional.
# Remoção de linhas nulas
Essa transformação remove do conjunto de dados as linhas que têm todas as colunas como nulas. Além disso, você pode estender esses critérios para incluir campos vazios, de modo a manter as linhas em que pelo menos uma coluna não esteja vazia.
**Para adicionar um nó de transformação Remove Null Rows ao diagrama de trabalho**
1. Abra o painel Recurso e escolha **Remove Null Rows** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. No painel propriedades do nó, insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. (Opcional) Na guia **Transformar**, marque a opção **Estendido** se quiser exigir que as linhas não apenas não sejam nulas, mas também não estejam vazias. Dessa forma, cadeias de caracteres, matrizes ou mapas vazios serão considerados nulos para o propósito dessa transformação.
# Analisar uma coluna de string contendo dados JSON
Essa transformação analisa uma coluna de string contendo dados JSON e a converte em uma estrutura ou coluna de matriz, dependendo se o JSON é um objeto ou uma matriz, respectivamente. Opcionalmente, você pode manter a coluna analisada e a original.
O esquema JSON pode ser fornecido ou inferido (no caso de objetos JSON), com amostragem opcional.
**Para adicionar um nó de transformação de Parse JSON Column ao diagrama de trabalho**
1. Abra o painel Recurso e escolha **Parse JSON Column** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. No painel propriedades do nó, insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, selecione a coluna que contém a string JSON.
1. (Opcional) Na guia **Transformar**, insira o esquema que os dados JSON seguem usando a sintaxe SQL, por exemplo: “campo1 STRING, campo2 INT” no caso de um objeto ou “ARRAY” no caso de uma matriz.
No caso de uma matriz, o esquema é obrigatório, mas no caso de um objeto, se o esquema não for especificado, ele será inferido usando os dados. Para reduzir o impacto da inferência do esquema (especialmente em um conjunto de dados grande), você pode evitar ler os dados inteiros duas vezes inserindo uma **proporção de amostras a serem usadas para inferir o esquema**. Se o valor for menor que 1, a proporção correspondente de amostras aleatórias será usada para inferir o esquema. Se os dados forem confiáveis e o objeto for consistente entre as linhas, você poderá usar uma proporção pequena, como 0,1, para melhorar a performance.
1. (Opcional) Na guia **Transformar**, você pode inserir um novo nome de coluna se quiser manter a coluna de string original e a coluna analisada.
# Extraindo um caminho JSON
Essa transformação extrai novas colunas de uma coluna de string JSON. Essa transformação é útil quando você precisa apenas de alguns elementos de dados e não quer importar todo o conteúdo do JSON para o esquema da tabela.
**Para adicionar um nó de transformação Extract JSON Path ao diagrama do trabalho**
1. Abra o painel Recurso e escolha **Extract JSON Path** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. No painel propriedades do nó, insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, selecione a coluna que contém a string JSON. Insira uma ou mais expressões de caminho JSON separadas por vírgulas, cada uma fazendo referência a como extrair um valor da matriz ou objeto JSON. Por exemplo, se a coluna JSON contivesse objetos com as propriedades “prop\$11" e “prop2", você poderia extrair ambas especificando seus nomes “prop\$11, prop\$12".
Se o campo JSON tiver caracteres especiais, por exemplo, para extrair a propriedade desse JSON `{"a. a": 1}` você poderá usar o caminho `$['a. a']`. A exceção é a vírgula porque ela é reservada para caminhos separados. Em seguida, insira os nomes das colunas correspondentes para cada caminho, separados por vírgulas.
1. (Opcional) Na guia **Transformar**, você pode marcar a opção de descartar a coluna JSON depois de extraída. Isso faz sentido quando você não precisa do restante dos dados JSON depois de extrair as partes necessárias.
# Extrair fragmentos de string usando uma expressão regular
Essa transformação extrai fragmentos de string usando uma expressão regular e cria uma nova coluna a partir dela, ou várias colunas se estiver usando grupos regex.
**Para adicionar um nó de transformação Regex Extractor ao diagrama de trabalho**
1. Abra o painel Recurso e escolha **Regex Extractor** para adicionar uma nova transformação ao diagrama do trabalho. O nó selecionado no momento da adição do nó será o nó superior.
1. No painel propriedades do nó, insira um nome para o nó no diagrama de trabalho. Se ainda não houver um nó pai selecionado, escolha um na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
1. Na guia **Transformar**, insira a expressão regular e a coluna na qual ela precisa ser aplicada. Em seguida, insira o nome da nova coluna na qual armazenar a string correspondente. A nova coluna será nula somente se a coluna de origem for nula; se a regex não corresponder, a coluna ficará vazia.
Se a regex usar grupos, haverá um nome de coluna correspondente separado por vírgula, mas você pode pular grupos deixando o nome da coluna vazio.
Por exemplo, se você tiver uma coluna “purchase\$1date” com uma string usando formatos de data ISO longo e curto, convém extrair o ano, mês, dia e hora, quando disponível. Observe que o grupo de horas é opcional, caso contrário, nas linhas em que não estiverem disponíveis, todos os grupos extraídos seriam strings vazias (porque o regex não correspondia). Nesse caso, não queremos que o grupo torne a hora opcional, mas a interna, então deixamos o nome vazio e ele não é extraído (esse grupo incluiria o caractere T).
![\[A captura de tela mostra a configuração de uma expressão regular para o extrator Regex.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/regex-extractor-1.png)
Resultando na visualização prévia dos dados:
![\[A captura de tela mostra a configuração de uma visualização prévia de dados para o extrator Regex.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/regex-extractor-2.png)
# Criar uma transformação personalizada
Se precisar executar transformações mais complicadas em seus dados ou quiser adicionar chaves de propriedade de dados ao conjunto de dados, você pode adicionar uma transformação **Custom code** (Código personalizado) em seu diagrama de trabalho. O nó Custom code (Código personalizado) permite inserir um script que executa a transformação.
Ao usar código personalizado, você deve usar um editor de esquema para indicar as alterações feitas na saída por meio do código personalizado. Ao editar o esquema, você pode executar as seguintes ações:
+ Adicionar ou remover chaves de propriedade de dados
+ Alterar o tipo de dados das chaves de propriedade de dados
+ Alterar o nome das chaves de propriedade de dados
+ Reestruturar uma chave de propriedade aninhada
Você deve usar uma transformação *SelectFromCollection* (Selecionar da coleção) para escolher um único `DynamicFrame` do resultado do nó de transformação personalizada antes de enviar a saída para um local de destino.
Use as seguintes tarefas para adicionar um nó de transformação personalizada ao diagrama de trabalho.
## Adicionar um nó de transformação de código personalizado ao diagrama de trabalho
**Para adicionar um nó de transformação personalizado ao diagrama de trabalho**
1. (Opcional) abra o painel Recurso e escolha **Transformação personalizada** para adicionar uma nova transformação ao diagrama de trabalho.
1. Na guia **Node properties** (Propriedades do nó), insira um nome para o nó no diagrama de trabalho. Se um nó pai ainda não estiver selecionado, ou se você quiser várias entradas para a transformação personalizada, escolha um nó na lista **Node parents** (Nós pais) para usar como fonte de entrada para a transformação.
## Inserir código para o nó de transformação personalizada
Você pode digitar ou copiar código em um campo de entrada. O trabalho usa esse código para executar a transformação de dados. Você pode fornecer um trecho de código em Python ou Scala. O código deve aceitar um ou mais `DynamicFrames` como entrada e retornar uma coleção de `DynamicFrames`.
**Para inserir o script para um nó de transformação personalizada**
1. Com o nó de transformação personalizada selecionado no diagrama de trabalho, escolha a guia **Transform** (Transformação).
1. No campo de entrada de texto, no cabeçalho **Code block** (Bloco de código), cole ou insira o código da transformação. O código que você usa deve corresponder à linguagem especificada para o trabalho na guia **Job details** (Detalhes do trabalho).
Ao fazer referência aos nós de entrada em seu código, o AWS Glue Studio nomeia o `DynamicFrames` retornado pelos nós do diagrama de trabalho sequencialmente com base na ordem de criação. Use um dos seguintes métodos de atribuição de nomes no código:
+ Geração de código clássico: use nomes funcionais para se referir aos nós no diagrama do trabalho.
+ Nós da origem dos dados: `DataSource0`, `DataSource1`, `DataSource2` e assim por diante.
+ Nós de transformação: `Transform0`, `Transform1`, `Transform2` e assim por diante.
+ Geração de novo código: use o nome especificado na guia **Node properties** (Propriedades do nó), seguida por um "`_node1`", "`_node2`" anexao e assim por diante. Por exemplo, `S3bucket_node1`, `ApplyMapping_node2`, `S3bucket_node2`, `MyCustomNodeName_node1`.
Para obter mais informações sobre o gerador de novo código, consulte [Geração de código de script](job-editor-features.md#code-gen).
Os exemplos a seguir mostram o formato do código a ser inserido na caixa de código:
------
#### [ Python ]
O exemplo a seguir pega o primeiro `DynamicFrame` recebido, converte-o em um `DataFrame` para aplicar o método de filtro nativo (mantendo somente registros que têm mais de 1.000 votos) e, em seguida, converte-o novamente em um `DynamicFrame` antes de devolvê-lo.
```
def FilterHighVoteCounts (glueContext, dfc) -> DynamicFrameCollection:
df = dfc.select(list(dfc.keys())[0]).toDF()
df_filtered = df.filter(df["vote_count"] > 1000)
dyf_filtered = DynamicFrame.fromDF(df_filtered, glueContext, "filter_votes")
return(DynamicFrameCollection({"CustomTransform0": dyf_filtered}, glueContext))
```
------
#### [ Scala ]
O exemplo a seguir pega o primeiro `DynamicFrame` recebido, converte-o em um `DataFrame` para aplicar o método de filtro nativo (mantendo somente registros que têm mais de 1.000 votos) e, em seguida, converte-o novamente em um `DynamicFrame` antes de devolvê-lo.
```
object FilterHighVoteCounts {
def execute(glueContext : GlueContext, input : Seq[DynamicFrame]) : Seq[DynamicFrame] = {
val frame = input(0).toDF()
val filtered = DynamicFrame(frame.filter(frame("vote_count") > 1000), glueContext)
Seq(filtered)
}
}
```
------
## Editar o esquema de um nó de transformação personalizada
Quando você usa um nó de transformação personalizada, o AWS Glue Studio não pode inferir automaticamente os esquemas de saída criados pela transformação. Use o editor de esquema para descrever as alterações de esquema implantadas pelo código de transformação personalizada.
Um nó de código personalizado pode ter qualquer número de nós pais, cada um fornecendo um `DynamicFrame` como entrada para o seu código personalizado. Um nó de código personalizado retorna uma coleção de `DynamicFrames`. Cada `DynamicFrame` usado como entrada tem um esquema associado. Você deve adicionar um esquema que descreva cada `DynamicFrame` retornado pelo nó de código personalizado.
**nota**
Quando você define seu próprio esquema em uma transformação personalizada, o AWS Glue Studio não herda esquemas de nós anteriores. Para atualizar o esquema, selecione o nó Custom transform (Transformação personalizada) e escolha a guia Data preview (Visualização de dados). Depois que a visualização for gerada, escolha “Use Preview Schema” (Usar esquema de visualização). O esquema será substituído pelo esquema usando os dados de visualização.
**Para editar os esquemas de um nó de transformação personalizada**
1. Com o nó de transformação personalizada selecionado no diagrama de trabalho, no painel de detalhes do nó, escolha a guia **Outpu schema** (Esquema de saída).
1. Escolha **Edit** (Editar) para fazer alterações no esquema.
Se você tiver chaves de propriedade de dados aninhadas, como uma matriz ou objeto, pode escolher o ícone **Expand-Rows** (Expandir linhas, ![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/expand-rows-icon.png)) no canto superior direito de cada painel de esquema, para expandir a lista de chaves de propriedade de dados filhas. Depois de escolher esse ícone, ele muda para o ícone **Collapse-Rows** (Recolher linhas, ![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/collapse-rows-icon.png)), que você pode usar para recolher a lista de chaves de propriedade filhas.
1. Modifique o esquema usando as seguintes ações na seção no lado direito da página:
+ Para renomear uma chave de propriedade, coloque o cursor na caixa de texto **Key** (Chave) da chave de propriedade e insira o novo nome.
+ Para alterar o tipo de dados de uma chave de propriedade de dados, use a lista para escolher o novo tipo de dados da chave de propriedade.
+ Para adicionar uma nova propriedade de nível superior ao esquema, escolha o botão **Overflow** (excedente, ![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/edit-schema-actions-button.png)) à esquerda do botão **Cancel** (Cancelar) e, em seguida, escolha **Add root key** (Adicionar chave raiz).
+ Para adicionar uma chave de propriedade filha ao esquema, escolha o ícone **Add-Key** (Adicionar chave, ![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/filter-add-icon.png)) associado à chave pai. Insira um nome para a chave filha e escolha o tipo de dados.
+ Para remover uma chave de propriedade do esquema, escolha o ícone **Remove** (Excluir, ![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/delete-icon-black.png)) à extrema direita do nome da chave.
1. Se o código de transformação personalizada usar vários `DynamicFrames`, você poderá adicionar esquemas de saída adicionais.
+ Para adicionar um esquema novo e vazio, escolha o ícone **Overflow** (Excedente, ![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/edit-schema-actions-button.png)) e, em seguida, escolha **Add output schema** (Adicionar esquema de saída).
+ Para copiar um esquema existente em um novo esquema de saída, certifique-se de que aquele que você deseja copiar seja exibido no seletor de esquemas. Selecione o ícone **Overflow** (Excedente, ![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/edit-schema-actions-button.png)) e, em seguida, escolha **Duplicate** (Duplicar).
Se você quiser remover um esquema de saída, certifique-se de que o esquema que deseja copiar seja exibido no seletor de esquemas. Escolha o ícone **Overflow** (Excedente, ![\[\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/edit-schema-actions-button.png)) e, em seguida, escolha **Delete** (Excluir).
1. Adicione novas chaves raiz ao novo esquema ou edite as chaves duplicadas.
1. Quando estiver modificando os esquemas de saída, escolha o botão **Apply** (Aplicar) para salvar suas alterações e saia do editor de esquemas.
Se não quiser salvar as alterações, escolha o botão **Cancel** (Cancelar).
## Configurar a saída da transformação personalizada
Uma transformação de código personalizado retorna uma coleção de `DynamicFrames`, mesmo que haja somente um `DynamicFrame` no conjunto de resultados.
**Para processar a saída de um nó de transformação personalizada**
1. Adicione um nó de transformação *SelectFromCollection* (Selecionar da coleção) que tem o nó de transformação personalizada como nó pai. Atualize esta transformação para indicar qual conjunto de dados você deseja usar. Consulte [Usar SelectFromCollection (Selecionar da coleção) para escolher qual conjunto de dados manter](transforms-configure-select-collection.md) para obter mais informações.
1. Adicione mais transformações *SelectFromCollection* (Selecionar da coleção) para o diagrama de trabalho se você quiser usar `DynamicFrames` adionais produzidos pelo nó de transformação personalizada.
Considere um cenário no qual você adiciona um nó de transformação personalizada para dividir um conjunto de dados de voo em vários conjuntos de dados, mas duplica algumas das chaves de propriedade de identificação em cada esquema de saída, como a data ou o número do voo. Adicione um nó de transformação *SelectFromCollection* (Selecionar da coleção) para cada esquema de saída, com o nó de transformação personalizada como nó pai.
1. (Opcional) em seguida, você pode usar cada nó de transformação *SelectFromCollection* (Selecionar da coleção) como entrada para outros nós no trabalho ou como pai para um nó de destino de dados.