As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Modelo de metadados na conversão do esquema DMS
Quando você trabalha com o DMS Schema Conversion, o serviço representa seus esquemas de banco de dados como uma árvore hierárquica. Essa árvore é chamada de *árvore de metadados* e se aplica aos esquemas de origem e de destino. Cada elemento na árvore, incluindo o elemento raiz (“Servidores”), é um modelo de metadados.
A árvore de metadados contém dois tipos de elementos:
+ **Objetos** — Representam objetos reais do banco de dados, como tabelas, funções, visualizações, sequências e índices. Você pode recuperar a definição SQL de um objeto usando a [DescribeMetadataModel](https://docs.aws.amazon.com/dms/latest/APIReference/API_DescribeMetadataModel.html)solicitação.
+ **Categorias** — Contêineres de agrupamento virtual, como “Esquemas”, “Tabelas”, “Funções” e “Índices”. As categorias organizam objetos na árvore para navegação, mas não têm definições SQL em si.
A árvore de metadados carrega dados somente quando você os solicita. Essa abordagem é chamada de carregamento sob demanda (também conhecido como carregamento lento), o que significa que o DMS Schema Conversion recupera dados do seu banco de dados somente quando necessário. Você usa a operação de importação para carregar metadados, seja atualizando um modelo de metadados específico ou importando uma subárvore inteira de uma vez. Operações como avaliação e conversão também carregam a árvore de metadados automaticamente.
## Como o modelo de metadados funciona
O modelo de metadados no DMS Schema Conversion segue um ciclo de vida de operações. As operações que modificam a árvore de metadados (como importação e conversão) são assíncronas. Você inicia uma solicitação para essas operações e ela é executada em segundo plano. Chame a API de descrição correspondente para verificar o status da solicitação. As operações que lêem a árvore (como descrever filhos ou definições) são síncronas.
**nota**
Na conversão do esquema DMS, os termos *operação* e *solicitação* são usados de forma intercambiável.
O fluxo de trabalho típico inclui as seguintes etapas:
1. **Importar** — Carregue metadados do seu banco de dados de origem ou destino na árvore de metadados. Você pode carregar o modelo de metadados inicial ou recarregar um modelo existente do banco de dados. Para obter mais informações, consulte [Navegue pela árvore](#sc-metadata-model-navigating). Para obter a referência da API, consulte [StartMetadataModelImport](https://docs.aws.amazon.com/dms/latest/APIReference/API_StartMetadataModelImport.html).
1. **Avalie** — analise os modelos de metadados de origem selecionados para identificar a complexidade da conversão e possíveis problemas. Para obter mais informações, consulte [Criar relatórios de avaliação de migração de banco de dados com a DMS Schema Conversion](assessment-reports.md).
1. **Converter — Converta** os modelos de metadados de origem selecionados em um formato compatível com o destino. As definições convertidas são armazenadas como parte da árvore de metadados de destino. Para obter mais informações, consulte [Convertendo esquemas de banco de dados na conversão de esquema DMS: guia passo a passo](schema-conversion-convert.md).
1. **Exportar** — Salve as definições de metadados. Você pode exportar metadados de origem e de destino como scripts SQL para o seu bucket do Amazon S3. Para destinos não virtuais, você também pode aplicar objetos convertidos diretamente ao seu banco de dados de destino. Para obter mais informações sobre alvos virtuais, consulte[Provedor de dados virtual](virtual-data-provider.md). Para obter mais informações sobre como aplicar objetos convertidos, consulte[Aplicar o código convertido](schema-conversion-save-apply.md#schema-conversion-apply).
Depois de avaliar ou converter os modelos de metadados de origem, você pode gerar um relatório de avaliação para analisar os resultados. Para obter mais informações, consulte [Criar relatórios de avaliação de migração de banco de dados com a DMS Schema Conversion](assessment-reports.md).
Para pares de migração compatíveis, você também pode criar modelos de metadados de instruções personalizados a partir de definições de SQL usando o. [StartMetadataModelCreation](https://docs.aws.amazon.com/dms/latest/APIReference/API_StartMetadataModelCreation.html) Para obter mais informações, consulte [Crie modelos de declarações](#sc-metadata-model-creation).
## Navegue pela árvore modelo de metadados
Você pode navegar pela árvore de metadados usando as seguintes solicitações de API:
+ [DescribeMetadataModelChildren](https://docs.aws.amazon.com/dms/latest/APIReference/API_DescribeMetadataModelChildren.html)— Retorna os filhos de um determinado modelo de metadados. Cada criança inclui regras de seleção (filtros que identificam modelos de metadados específicos) que você pode passar para a próxima chamada para se aprofundar.
+ [DescribeMetadataModel](https://docs.aws.amazon.com/dms/latest/APIReference/API_DescribeMetadataModel.html)— Retorna o nome, o tipo e a definição SQL de um modelo de metadados específico.
Ambas as solicitações exigem o `Origin` parâmetro (`SOURCE`ou`TARGET`) e usam regras de seleção para identificar o modelo de metadados. O padrão de navegação é o mesmo para as árvores de origem e de destino. Para obter mais informações sobre o formato das regras de seleção, consulte[Regras de seleção na conversão do esquema DMS](sc-selection-rules.md).
Escolha sua interface preferida para ver as instruções de navegação.
------
#### [ AWS Management Console ]
Depois de abrir seu projeto de conversão de esquema, você pode navegar pelas árvores de metadados de origem e de destino. Para obter mais informações sobre como abrir um projeto, consulte[Convertendo esquemas de banco de dados na conversão de esquema DMS: guia passo a passo](schema-conversion-convert.md).
O console exibe dois painéis de árvore: a árvore de origem à esquerda e a árvore de destino à direita. Cada painel consiste em um cabeçalho que mostra o mecanismo do banco de dados, um menu Ações e a própria árvore de metadados.
O menu Ações depende do contexto. Nem todo modelo de metadados tem todas as ações disponíveis. As árvores de origem e de destino têm listas de ações diferentes.
Para visualizar a definição de SQL e as propriedades de um modelo de metadados, escolha-o na árvore. O painel central exibe as guias SQL de origem e SQL de destino com a definição e uma guia Propriedades com atributos de metadados. Guias adicionais podem aparecer dependendo do tipo de modelo de metadados — por exemplo, Colunas para tabelas e exibições ou Parâmetros para rotinas.
Para expandir os filhos de um modelo de metadados, escolha o ícone de expansão (triângulo preto) ao lado dele. Escolha o ícone de expansão ou o nome do modelo de metadados para carregar seus filhos automaticamente.
Quando você escolhe um modelo de metadados de origem que foi convertido, o modelo de metadados de destino correspondente é selecionado automaticamente no painel da árvore de destino.
O passo a passo a seguir mostra como navegar na árvore de metadados e visualizar a definição de um modelo de metadados.
1. No painel da árvore, escolha o ícone de expansão ao lado do servidor para exibir as categorias de nível superior, como **bancos de dados** ou **esquemas, dependendo do mecanismo** do banco de dados.
1. Continue expandindo as categorias para navegar até o modelo de metadados que você deseja explorar. **Por exemplo, expanda **Bancos de dados**, depois um banco de dados específico, depois **Esquemas**, depois um nome de esquema e, em seguida, uma categoria como **Tabelas**, **Exibições** ou Procedimentos.** Alguns mecanismos de banco de dados não têm o nível **de bancos de dados** — nesse caso, expanda os **esquemas** diretamente.
1. Escolha um modelo de metadados para visualizar sua definição de SQL no painel central. A guia **SQL de origem** mostra a definição de origem e a guia **SQL de destino** mostra a definição convertida se o modelo de metadados tiver sido convertido.
------
#### [ AWS CLI ]
Para navegar pela árvore de metadados, você segue um padrão repetido: importa metadados em um nível e, em seguida, descreve os filhos nesse nível. Repita esse processo para perfurar mais profundamente a árvore.
Comece chamando [start-metadata-model-import](https://docs.aws.amazon.com/cli/latest/reference/dms/start-metadata-model-import.html) com uma regra de seleção que identifica o modelo de metadados de nível superior. Inclua o `server-name` e um nível superior `category-name` (`Databases`ou`Schemas`, dependendo do mecanismo do banco de dados) no`object-locator`. Para obter mais informações sobre a estrutura das regras de seleção, consulte[Regras de seleção na conversão do esquema DMS](sc-selection-rules.md).
```
aws dms start-metadata-model-import \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--refresh \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{"server-name":"{{my-server}}","category-name":"{{top-level-category}}"},"rule-action":"explicit"}]}'
```
As solicitações de importação são assíncronas. Use [describe-metadata-model-imports](https://docs.aws.amazon.com/cli/latest/reference/dms/describe-metadata-model-imports.html) para verificar o status antes de navegar. Use o `request-id` filtro com o `RequestIdentifier` valor retornado por `start-metadata-model-import` para encontrar uma importação específica:
```
aws dms describe-metadata-model-imports \
--migration-project-identifier "{{my-migration-project}}" \
--filters Name=request-id,Values={{request-identifier}}
```
Depois que a importação for concluída, chame [describe-metadata-model-children](https://docs.aws.amazon.com/cli/latest/reference/dms/describe-metadata-model-children.html) para recuperar os filhos nesse nível:
```
aws dms describe-metadata-model-children \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{"server-name":"{{my-server}}"},
"rule-action":"explicit"}]}'
```
Cada criança na resposta inclui um `SelectionRules` campo. Passe essas regras de seleção para a próxima importação e descreva as chamadas para se aprofundar:
```
{
"MetadataModelChildren": [
{
"MetadataModelName": "Schemas",
"SelectionRules": "{\"rules\":[{\"rule-type\":\"selection\",\"rule-id\":\"1\",\"rule-name\":\"1\",\"object-locator\":{\"server-name\":\"src-database-server\",\"category-name\":\"Schemas\"},\"rule-action\":\"explicit\"}]}"
}
]
}
```
Para detalhar o próximo nível, importe nesse nível usando as regras de seleção retornadas da `describe-metadata-model-children` chamada anterior e, em seguida, descreva seus filhos:
```
aws dms start-metadata-model-import \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--refresh \
--selection-rules '{{selection-rules-from-previous-response}}'
```
Antes de descrever os filhos, verifique se a importação foi concluída verificando seu status com`describe-metadata-model-imports`. Então ligue para`describe-metadata-model-children`:
```
aws dms describe-metadata-model-children \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{{selection-rules-from-previous-response}}'
```
A resposta retorna as crianças desse nível, cada uma com suas próprias regras de seleção. Passe essas regras de seleção para a próxima importação e descreva as chamadas para continuar se aprofundando na árvore.
```
{
"MetadataModelChildren": [
{
"MetadataModelName": "{{child-name}}",
"SelectionRules": "{{selection-rules-JSON-string}}"
}
]
}
```
**Usando --refresh em comparação com a importação completa**
Use `--refresh` para recarregar um modelo de metadados específico do banco de dados. Isso também carrega os nomes de seus filhos diretos. Você pode listar esses filhos usando`describe-metadata-model-children`, mas para descrevê-los ou procurá-los mais detalhadamente, você deve executar outra importação no nível do filho.
Para carregar uma subárvore inteira (por exemplo, todos os objetos em um esquema, banco de dados ou uma categoria específica, como tabelas ou procedimentos), omita o `--refresh` sinalizador e altere `rule-action` para `include` nas regras de seleção:
```
aws dms start-metadata-model-import \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{{{...}}},
"rule-action":"include"}]}'
```
O carregamento de uma subárvore completa pode levar minutos ou horas para grandes esquemas e locais de carga em seu banco de dados. Para exploração interativa, use `--refresh` e explore ramificações específicas conforme necessário.
[Para recuperar a definição SQL de um modelo de metadados, use describe-metadata-model.](https://docs.aws.amazon.com/cli/latest/reference/dms/describe-metadata-model.html) Passe as regras de seleção que identificam o modelo de metadados específico de uma `describe-metadata-model-children` resposta anterior:
```
aws dms describe-metadata-model \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{{selection-rules-for-target-object}}'
```
A resposta inclui o nome, o tipo e a definição de SQL do modelo de metadados:
```
{
"MetadataModelName": "employees",
"MetadataModelType": "table",
"Definition": "CREATE TABLE hr.employees(\n id integer NOT NULL,\n name varchar(100),\n department_id integer\n);"
}
```
**nota**
O `Definition` campo pode não estar preenchido para alguns modelos de metadados, como esquemas e categorias.
Depois de converter os modelos de metadados de origem, as definições convertidas ficam disponíveis na árvore de destino. Há três maneiras de recuperá-los.
**Usando regras de seleção de alvos da resposta de origem**
Quando você descreve um modelo de metadados de origem após a conversão, a resposta inclui um `TargetMetadataModels` campo com as regras de seleção de destino:
```
{
"MetadataModelName": "employees",
"MetadataModelType": "table",
"TargetMetadataModels": [
{
"MetadataModelName": "employees",
"SelectionRules": "{\"rules\":[{\"rule-type\":\"selection\",\"rule-id\":\"1\",\"rule-name\":\"1\",\"object-locator\":{\"server-name\":\"tgt-database-server\",\"schema-name\":\"hr\",\"table-name\":\"employees\",\"table-type\":\"table\"},\"rule-action\":\"explicit\"}]}"
}
],
"Definition": "CREATE TABLE hr.employees(\n id integer NOT NULL,\n name varchar(100),\n department_id integer\n);"
}
```
Passe as regras de seleção de `TargetMetadataModels` para `describe-metadata-model` com`--origin TARGET`:
```
aws dms describe-metadata-model \
--migration-project-identifier "{{my-migration-project}}" \
--origin TARGET \
--selection-rules '{{selection-rules-from-TargetMetadataModels}}'
```
A resposta contém a definição de SQL convertida na sintaxe do mecanismo de destino:
```
{
"MetadataModelName": "employees",
"MetadataModelType": "table",
"Definition": "CREATE TABLE hr.employees (\nid INT NOT NULL,\nname VARCHAR(100) DEFAULT NULL,\ndepartment_id INT DEFAULT NULL,\nPRIMARY KEY (id)\n);"
}
```
**Usando get-target-selection-rules**
Você pode usar [get-target-selection-rules para converter as regras](https://docs.aws.amazon.com/cli/latest/reference/dms/get-target-selection-rules.html) de seleção de origem diretamente em suas equivalentes de destino, sem primeiro chamar a fonte: `describe-metadata-model`
```
aws dms get-target-selection-rules \
--migration-project-identifier "{{my-migration-project}}" \
--selection-rules '{{source-selection-rules}}'
```
**Navegando diretamente na árvore de destino**
Você também pode navegar na árvore de destino da mesma forma que na árvore de origem, usando`--origin TARGET`. Isso é útil quando você deseja explorar todos os objetos convertidos sem partir da fonte.
------
## Crie modelos de metadados de declarações
**nota**
Atualmente, a criação de instruções suporta somente as seguintes instruções: do SQL Server para o Aurora PostgreSQL ou do SQL Server para o Amazon RDS for PostgreSQL.
Você pode criar modelos de metadados de instruções a partir de definições de SQL usando o. [StartMetadataModelCreation](https://docs.aws.amazon.com/dms/latest/APIReference/API_StartMetadataModelCreation.html) Isso é útil quando você deseja converter instruções SQL que não existem como objetos no banco de dados de origem — por exemplo, consultas de aplicativos ou código SQL ad-hoc.
------
#### [ AWS Management Console ]
A criação de modelos de metadados de instruções não está disponível no AWS Management Console. Em vez disso, use o AWS CLI ou um AWS SDK.
------
#### [ AWS CLI ]
Para criar um modelo de metadados de declaração, use [start-metadata-model-creation](https://docs.aws.amazon.com/cli/latest/reference/dms/start-metadata-model-creation.html). As regras de seleção devem especificar um esquema que exista no banco de dados de origem. O modelo de metadados criado aparece na `Statements` categoria dentro desse esquema.
```
aws dms start-metadata-model-creation \
--migration-project-identifier "{{my-migration-project}}" \
--metadata-model-name "{{GetAllEmployees}}" \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{"server-name":"{{my-server}}",
"database-name":"{{my_database}}","schema-name":"{{dbo}}"},
"rule-action":"explicit"}]}' \
--properties '{"StatementProperties":{"Definition":"SELECT * FROM dbo.Employees;"}}'
```
Após a criação, você pode encontrar o modelo de metadados na árvore abaixo da `Statements` categoria e descrevê-lo:
```
{
"MetadataModelName": "GetAllEmployees",
"MetadataModelType": "statement",
"Definition": "SELECT * FROM dbo.Employees;"
}
```
Após a criação, você pode executar qualquer operação compatível no modelo de metadados da declaração, como avaliação, conversão ou exportação.
------