# Importar dados para o Oracle no Amazon RDS
A forma como você importa dados para uma instância de banco de dados do Amazon RDS para Oracle depende do seguinte:
+ A quantidade de dados que você tem
+ O número de objetos em seu banco de dados
+ A variedade de objetos em seu banco de dados
Por exemplo, você pode usar as seguintes ferramentas, dependendo de seus requisitos:
+ Oracle SQL Developer: importe um banco de dados simples de 20 MB.
+ Oracle Data Pump: importar bancos de dados complexos ou bancos de dados com várias centenas de megabytes ou terabytes de tamanho. Por exemplo, você pode transportar espaços de tabela de um banco de dados on-premises para a instância de banco de dados do RDS para Oracle. Você pode usar o Amazon S3 ou o Amazon EFS para transferir os arquivos de dados e os metadados. Para mais informações, consulte [Migrar usando espaços de tabela transportáveis da Oracle](oracle-migrating-tts.md), [Integração do Amazon EFS](oracle-efs-integration.md) e [Integração do Amazon S3](oracle-s3-integration.md).
+ AWS Database Migration Service(AWS DMS): migre bancos de dados sem tempo de inatividade. Para obter mais informações sobre AWS DMS, consulte [O que é o AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) e a publicação de blog [Migrar bancos de dados do Oracle com tempo de inatividade quase zero usando o AWS DMS](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/).
**Importante**
Antes de usar as técnicas de migração anteriores, recomendamos que você faça backup do banco de dados. Após importar os dados, você pode fazer backup de suas instâncias de banco de dados do RDS para Oracle criando snapshots. Mais tarde, você poderá restaurar os snapshots. Para obter mais informações, consulte [Backup, restauração e exportação de dados](CHAP_CommonTasks.BackupRestore.md).
Para vários mecanismos de banco de dados, a replicação contínua pode continuar até que você esteja pronto para migrar para o banco de dados de destino. Você pode usar AWS DMS a fim de migrar para o RDS para Oracle a partir do mesmo mecanismo de banco de dados ou um mecanismo de banco de dados diferente. Se você migrar de um mecanismo de banco de dados diferente, poderá usar a AWS Schema Conversion Tool para migrar objetos de esquema que o AWS DMS não consegue migrar.
**Topics**
+ [Importar usando o Oracle SQL Developer](Oracle.Procedural.Importing.SQLDeveloper.md)
+ [Migrar usando espaços de tabela transportáveis da Oracle](oracle-migrating-tts.md)
+ [Importar usando o Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md)
+ [Importar usando Oracle Export/Import](Oracle.Procedural.Importing.ExportImport.md)
+ [Importar usando o Oracle SQL\$1Loader](Oracle.Procedural.Importing.SQLLoader.md)
+ [Migrar com visualizações materializadas do Oracle](Oracle.Procedural.Importing.Materialized.md)
# Importar usando o Oracle SQL Developer
O Oracle SQL Developer é uma ferramenta gráfica Java distribuída sem custos pela Oracle. O SQL Developer fornece opções para migrar dados entre dois bancos de dados Oracle ou para migrar dados de outros bancos de dados, como o MySQL, para um banco de dados Oracle. Essa ferramenta é a mais adequada para migrar bancos de dados pequenos.
Você pode instalar essa ferramenta no seu computador desktop (Windows, Linux ou Mac) ou em um dos seus servidores. Depois de instalar o SQL Developer, você pode usá-lo para se conectar aos bancos de dados de origem e de destino. Use o comando **Cópia do banco de dados** no menu Ferramentas para copiar seus dados para a instância de banco de dados do RDS para Oracle.
Para baixar o SQL Developer, acesse [http://www.oracle.com/technetwork/developer-tools/sql-developer](http://www.oracle.com/technetwork/developer-tools/sql-developer).
Recomendamos que você leia a documentação do produto Oracle SQL Developer antes de começar a migrar seus dados. A Oracle também possui documentação sobre como migrar de outros bancos de dados, incluindo o MySQL e o SQL Server. Para obter mais informações, consulte [http://www.oracle.com/technetwork/database/migration](http://www.oracle.com/technetwork/database/migration) na documentação da Oracle.
# Migrar usando espaços de tabela transportáveis da Oracle
Você pode usar o atributo de espaços de tabela transportáveis da Oracle para copiar um conjunto de espaços de tabela de um banco de dados Oracle on-premises para uma instância de banco de dados do RDS para Oracle. No nível físico, é necessário transferir os arquivos de dados de origem e os arquivos de metadados para a instância de banco de dados de destino usando o Amazon EFS ou o Amazon S3. O recurso de espaços de tabela transportáveis usa o pacote `rdsadmin.rdsadmin_transport_util`. Consulte a sintaxe e a semântica desse pacote em [Transportar espaços para tabela](rdsadmin_transport_util.md).
Para publicações de blog que explicam como transportar espaços de tabela, consulte [Migrate Oracle Databases to AWS using transportable tablespace](https://aws.amazon.com/blogs/database/migrate-oracle-databases-to-aws-using-transportable-tablespace/) e [Amazon RDS for Oracle Transportable Tablespaces using RMAN](https://aws.amazon.com/blogs/database/amazon-rds-for-oracle-transportable-tablespaces-using-rman/).
**Topics**
+ [Visão geral dos espaços de tabela transportáveis da Oracle](#oracle-migrating-tts.overview)
+ [Fase 1: Configurar o host de origem](#oracle-migrating-tts.setup-phase)
+ [Fase 2: Preparar o backup completo dos espaços de tabela](#oracle-migrating-tts.initial-br-phase)
+ [Fase 3: Criar e transferir backups incrementais](#oracle-migrating-tts.roll-forward-phase)
+ [Fase 4: Transportar os espaços de tabela](#oracle-migrating-tts.final-br-phase)
+ [Fase 5: Validar os espaços de tabela transportados](#oracle-migrating-tts.validate)
+ [Fase 6: Limpar os arquivos restantes](#oracle-migrating-tts.cleanup)
## Visão geral dos espaços de tabela transportáveis da Oracle
Um conjunto de espaços de tabela transportáveis consiste em arquivos de dados para o conjunto de espaços de tabela que está sendo transportado e um arquivo de despejo de exportação que contém metadados do espaço de tabela. Em uma solução de migração física, como os espaços de tabela transportáveis, você transfere arquivos físicos: arquivos de dados, arquivos de configuração e arquivos de despejo do Data Pump.
**Topics**
+ [Vantagens e desvantagens dos espaços de tabela transportáveis](#oracle-migrating-tts.overview.benefits)
+ [Limitações dos espaços de tabela transportáveis](#oracle-migrating-tts.limitations)
+ [Pré-requisitos para espaços de tabela transportáveis](#oracle-migrating-tts.requirements)
### Vantagens e desvantagens dos espaços de tabela transportáveis
Recomendamos que você use espaços de tabela transportáveis quando precisar migrar um ou mais espaços de tabela grandes para o RDS com o mínimo de tempo de inatividade. Os espaços de tabela transportáveis oferecem as seguintes vantagens em relação à migração lógica:
+ O tempo de inatividade é menor do que a maioria das outras soluções de migração da Oracle.
+ Como o atributo de espaço de tabela transportável copia somente arquivos físicos, ele evita os erros de integridade de dados e a corrupção lógica que podem ocorrer na migração lógica.
+ Nenhuma licença adicional é necessária.
+ Você pode migrar um conjunto de espaços de tabela entre diferentes plataformas e tipos de extremidade, por exemplo, de uma plataforma do Oracle Solaris para Linux. No entanto, não há suporte ao transporte de espaços de tabela de e para servidores Windows.
**nota**
O Linux foi totalmente testado e é totalmente compatível. Nem todas as variações do UNIX foram testadas.
Se você usar espaços de tabela transportáveis, poderá transportar dados usando o Amazon S3 ou o Amazon EFS:
+ Ao usar o EFS, seus backups permanecem no sistema de arquivos do EFS durante a importação. Você poderá remover os arquivos posteriormente. Nessa técnica, não é necessário provisionar o armazenamento do EBS para sua instância de banco de dados. Por esse motivo, recomendamos usar o Amazon EFS em vez do S3. Para obter mais informações, consulte [Integração do Amazon EFS](oracle-efs-integration.md).
+ Ao usar o S3, baixe backups do RMAN para o armazenamento do EBS conectado à sua instância de banco de dados. Os arquivos permanecem no armazenamento do EBS durante a importação. Após a importação, você poderá liberar esse espaço, que permanecerá alocado para sua instância de banco de dados.
A principal desvantagem dos espaços de tabela transportáveis é a necessidade de um conhecimento relativamente avançado sobre o Oracle Database. Para obter mais informações, consulte [Transporting Tablespaces Between Databases](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-F7B2B591-AA88-4D16-8DCF-712763923FFB) no *Oracle Database Administrator's Guide*.
### Limitações dos espaços de tabela transportáveis
As limitações do Oracle Database para espaços de tabela transportáveis se aplicam quando você usa esse atributo no RDS para Oracle. Para obter mais informações, consulte [Limitations on Transportable Tablespaces]( https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-DAB51E42-9BBC-4001-B5CB-0ECDBE128787) e [General Limitations on Transporting Data](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173) no *Oracle Database Administrator’s Guide*. Observe as seguintes limitações adicionais para espaços de tabela transportáveis no RDS para Oracle:
+ Nem o banco de dados de origem, nem o de destino podem usar a Standard Edition 2 (SE2). Somente a Enterprise Edition é compatível.
+ Não é possível usar um banco de dados do Oracle Database 11g como fonte. O recurso de espaços de tabela transportáveis multiplataforma do RMAN depende do mecanismo de transporte RMAN, que o Oracle Database 11g não comporta.
+ Não é possível migrar dados de uma instância de banco de dados do RDS para Oracle usando espaços de tabela transportáveis. Só é possível usar os espaços de tabela transportáveis para migrar dados para uma instância de banco de dados do RDS para Oracle.
+ Não há suporte ao sistema operacional Windows.
+ Não é possível transportar espaços de tabela para um banco de dados em um nível de versão inferior. O banco de dados de destino deve estar no mesmo nível de versão, ou posterior, do banco de dados de origem. Por exemplo, não é possível transportar espaços de tabela do Oracle Database 21c para o Oracle Database 19c.
+ Não é possível transportar espaços de tabela administrativos, como `SYSTEM` e `SYSAUX`.
+ Não é possível transportar objetos que não sejam de dados, como pacotes PL/SQL, classes Java, visualizações, gatilhos, sequências, usuários, perfis e tabelas temporárias. Para transportar objetos que não sejam de dados, crie-os manualmente ou use a exportação e importação de metadados do Data Pump. Para ter mais informações, consulte [My Oracle Support Note 1454872.1](https://support.oracle.com/knowledge/Oracle%20Cloud/1454872_1.html).
+ Não é possível transportar espaços de tabela que estão criptografados ou que usam colunas criptografadas.
+ Ao transferir arquivos usando o Amazon S3, o tamanho máximo de arquivo compatível é de 5 TiB.
+ Se o banco de dados de origem usar opções do Oracle como o Spatial, você não poderá transportar espaços de tabela, a menos que as mesmas opções estejam configuradas no banco de dados de destino.
+ Não é possível transportar espaços de tabela para uma instância de banco de dados do RDS para Oracle em uma configuração de réplica do Oracle. Como solução alternativa, você pode excluir todas as réplicas, transportar os espaços de tabela e recriar as réplicas.
### Pré-requisitos para espaços de tabela transportáveis
Antes de começar, conclua as seguintes tarefas:
+ Analise os requisitos para espaços de tabela transportáveis descritos nos seguintes documentos em My Oracle Support:
+ [Reduce Transportable Tablespace Downtime using Cross Platform Incremental Backup (ID 2471245.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1)
+ [Transportable Tablespace (TTS) Restrictions and Limitations: Details, Reference, and Version Where Applicable (ID 1454872.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1454872.1)
+ [Primary Note for Transportable Tablespaces (TTS) -- Common Questions and Issues (ID 1166564.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1166564.1)
+ Planeje a conversão de extremidade. Se você especificar o ID da plataforma de origem, o RDS para Oracle converterá a extremidade automaticamente. Para saber como encontrar IDs de plataforma, consulte [Data Guard Support for Heterogeneous Primary and Physical Standbys in Same Data Guard Configuration (Doc ID 413484.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1).
+ Verifique se o atributo de espaços de tabela transportáveis está habilitado em sua instância de banco de dados de destino. O atributo só estará habilitado se você não receber um erro `ORA-20304` ao executar a seguinte consulta:
```
SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
```
Se o atributo de espaços de tabela transportáveis não estiver habilitado, reinicialize a instância de banco de dados. Para obter mais informações, consulte [Reinicializar uma instância de banco de dados](USER_RebootInstance.md).
+ Verifique se o arquivo de fuso horário é o mesmo nos bancos de dados de origem e de destino.
+ Certifique-se de que os conjuntos de caracteres do banco de dados nos bancos de dados de origem e de destino satisfaçam um dos seguintes requisitos:
+ Os conjuntos de caracteres são os mesmos.
+ Os conjuntos de caracteres são compatíveis. Para obter uma lista dos requisitos de compatibilidade, consulte [Limitações gerais no transporte de dados](https://docs.oracle.com/en/database/oracle/oracle-database/19/spmdu/general-limitations-on-transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173) na documentação do Oracle Database.
+ Se você planeja transferir arquivos usando o Amazon S3, faça o seguinte:
+ Verifique se há um bucket do Amazon S3 disponível para transferências de arquivos e se o bucket do Amazon S3 está na mesma região da AWS que a sua instância de banco de dados. Para obter mais informações, consulte [Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) no *Guia de conceitos básicos do Amazon Simple Storage Service*.
+ Prepare o bucket do Amazon S3 para a integração com o Amazon RDS seguindo as instruções em [Configurar permissões do IAM para a integração do RDS para Oracle com o Amazon S3](oracle-s3-integration.preparing.md).
+ Se você planeja transferir arquivos usando o Amazon EFS, verifique se configurou o EFS de acordo com as instruções em [Integração do Amazon EFS](oracle-efs-integration.md).
+ É altamente recomendável que você ative os backups automáticos na instância de banco de dados de destino. Como a [etapa de importação de metadados](#oracle-migrating-tts.transport.import-dmp) pode falhar, é importante ser capaz de restaurar a instância de banco de dados para o estado anterior à importação, evitando assim a necessidade de fazer backup, transferir e importar os espaços de tabela novamente.
## Fase 1: Configurar o host de origem
Nesta etapa, você copiará os scripts de transporte de espaços de tabela fornecidos em My Oracle Support e definirá os arquivos de configuração necessários. Nas etapas a seguir, o *host de origem* executará o banco de dados que contém os espaços de tabela que serão transportados para a *instância de destino*.
**Como configurar o host de origem**
1. Faça login no host de origem como proprietário do início do Oracle.
1. Certifique-se de que as variáveis de ambiente `ORACLE_HOME` e `ORACLE_SID` apontem para o banco de dados de origem.
1. Faça login em seu banco de dados como administrador e verifique se a versão do fuso horário, o conjunto de caracteres do banco de dados e o conjunto de caracteres nacionais são iguais aos do banco de dados de destino.
```
SELECT * FROM V$TIMEZONE_FILE;
SELECT * FROM NLS_DATABASE_PARAMETERS
WHERE PARAMETER IN ('NLS_CHARACTERSET','NLS_NCHAR_CHARACTERSET');
```
1. Configure o utilitário de espaços de tabela transportáveis conforme descrito em [Oracle Support note 2471245.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1).
A configuração inclui a edição do arquivo `xtt.properties` em seu host de origem. O exemplo de arquivo `xtt.properties` a seguir especifica backups de três espaços de tabela no diretório `/dsk1/backups`. Esses são os espaços de tabela que você pretende transportar para a instância de banco de dados de destino. Também especifica o ID da plataforma de origem para converter a extremidade automaticamente.
**nota**
Para saber como encontrar IDs de plataforma, consulte [Data Guard Support for Heterogeneous Primary and Physical Standbys in Same Data Guard Configuration (Doc ID 413484.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1).
```
#linux system
platformid=13
#list of tablespaces to transport
tablespaces=TBS1,TBS2,TBS3
#location where backup will be generated
src_scratch_location=/dsk1/backups
#RMAN command for performing backup
usermantransport=1
```
## Fase 2: Preparar o backup completo dos espaços de tabela
Nesta fase, você fará backup dos espaços de tabela pela primeira vez, transferirá os backups para o host de destino e restaurará usando o procedimento `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`. Quando essa fase estiver concluída, os backups iniciais dos espaços de tabela vão residir na instância de banco de dados de destino e poderão ser atualizados com backups incrementais.
**Topics**
+ [Etapa 1: Fazer backup dos espaços de tabela no host de origem](#oracle-migrating-tts.backup-full)
+ [Etapa 2: Transferir os arquivos de backup para a instância de banco de dados de destino](#oracle-migrating-tts.transfer-full)
+ [Etapa 3: Importar os espaços de tabela na instância de banco de dados de destino](#oracle-migrating-tts.initial-tts-import)
### Etapa 1: Fazer backup dos espaços de tabela no host de origem
Nesta etapa, use o script `xttdriver.pl` para fazer um backup completo dos espaços de tabela. A saída de `xttdriver.pl` é armazenada na variável de ambiente `TMPDIR`.
**Como fazer backup dos espaços de tabela**
1. Se os espaços de tabela estiverem no modo somente leitura, faça login no banco de dados de origem como um usuário que tem o privilégio `ALTER TABLESPACE` e coloque os espaços de tabela no modo de leitura/gravação. Caso contrário, vá para a próxima etapa.
O exemplo a seguir coloca `tbs1`, `tbs2` e `tbs3` no modo de leitura/gravação.
```
ALTER TABLESPACE tbs1 READ WRITE;
ALTER TABLESPACE tbs2 READ WRITE;
ALTER TABLESPACE tbs3 READ WRITE;
```
1. Faça backup dos espaços de tabela usando o script `xttdriver.pl`. Opcionalmente, você pode especificar `--debug` para executar o script no modo de depuração.
```
export TMPDIR=location_of_log_files
cd location_of_xttdriver.pl
$ORACLE_HOME/perl/bin/perl xttdriver.pl --backup
```
### Etapa 2: Transferir os arquivos de backup para a instância de banco de dados de destino
Nesta etapa, copie os arquivos de backup e configuração do local temporário para a instância de banco de dados de destino. Escolha uma das seguintes opções:
+ Se os hosts de origem e de destino compartilharem um sistema de arquivos do Amazon EFS, use um utilitário de sistema operacional, como `cp`, para copiar os arquivos de backup e o arquivo `res.txt` do local temporário para um diretório compartilhado. Em seguida, vá para [Etapa 3: Importar os espaços de tabela na instância de banco de dados de destino](#oracle-migrating-tts.initial-tts-import).
+ Se você precisar preparar os backups em um bucket do Amazon S3, realize as etapas a seguir.
![\[Transfira os arquivos usando o Amazon S3 ou o Amazon EFS.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/oracle-tts.png)
#### Etapa 2.2: Fazer upload dos backups no bucket do Amazon S3
Faça upload dos backups e do arquivo `res.txt` do diretório temporário para o bucket do Amazon S3. Para obter mais informações, consulte [Fazer upload de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) no *Guia do usuário do Amazon Simple Storage Service*.
#### Etapa 2.3: Fazer download dos backups do bucket do Amazon S3 para a instância de banco de dados de destino
Nesta etapa, use o procedimento `rdsadmin.rdsadmin_s3_tasks.download_from_s3` para fazer download dos backups para a instância de banco de dados do RDS para Oracle.
**Como fazer download dos backups do bucket do Amazon S3**
1. Inicie o SQL\$1Plus ou o Oracle SQL Developer e faça login em sua instância de banco de dados do RDS para Oracle.
1. Faça download dos backups do bucket do Amazon S3 para a instância de banco de dados de destino usando o procedimento `rdsadmin.rdsadmin_s3_tasks.download_from_s3` do Amazon RDS. O exemplo a seguir baixa todos os arquivos de um bucket do Amazon S3 chamado `amzn-s3-demo-bucket` no diretório `DATA_PUMP_DIR`.
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'res.txt');
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
A instrução `SELECT` retorna o ID da tarefa em um tipo de dados `VARCHAR2`. Para obter mais informações, consulte [Baixar arquivos de um bucket do Amazon S3 para uma instância de banco de dados Oracle](oracle-s3-integration.using.md#oracle-s3-integration.using.download).
### Etapa 3: Importar os espaços de tabela na instância de banco de dados de destino
Use o procedimento `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` para restaurar os espaços de tabela na instância de banco de dados de destino. Esse procedimento converte automaticamente os arquivos de dados para o formato endian correto.
Se você importar de uma plataforma diferente do Linux, especifique a plataforma de origem usando o parâmetro `p_platform_id` ao chamar `import_xtts_tablespaces`. O ID da plataforma que você especificou deve corresponder ao que foi especificado no arquivo `xtt.properties` em [Etapa 2: Exportar os metadados dos espaços de tabela no host de origem](#oracle-migrating-tts.transport.export).
**Importar os espaços de tabela na instância de banco de dados de destino**
1. Inicie um cliente Oracle SQL e faça login como usuário principal na instância de banco de dados de destino do RDS para Oracle.
1. Execute o procedimento `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`, especificando os espaços de tabela que serão importados e o diretório que contém os backups.
O exemplo a seguir importa os espaços de tabela *TBS1*, *TBS2* e *TBS3* do diretório *DATA\$1PUMP\$1DIR*. A plataforma de origem é de sistemas baseados em AIX (64 bits), que tem o ID da plataforma de `6`. É possível encontrar os IDs da plataforma consultando `V$TRANSPORTABLE_PLATFORM`.
```
VAR task_id CLOB
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
'TBS1,TBS2,TBS3',
'DATA_PUMP_DIR',
p_platform_id => 6);
END;
/
PRINT task_id
```
1. (Opcional) Monitore o progresso consultando a tabela `rdsadmin.rds_xtts_operation_info`. A coluna `xtts_operation_state` mostra o valor `EXECUTING`, `COMPLETED` ou `FAILED`.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**nota**
Para operações de longa duração, você também pode consultar `V$SESSION_LONGOPS`, `V$RMAN_STATUS` e `V$RMAN_OUTPUT`.
1. Veja o log da importação concluída usando o ID de tarefa da etapa anterior.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
Verifique se importação foi bem-sucedida antes de prosseguir para a próxima etapa.
## Fase 3: Criar e transferir backups incrementais
Nesta fase, você fará e transferirá backups incrementais periodicamente enquanto o banco de dados de origem estiver ativo. Essa técnica reduz o tamanho do backup final de espaços de tabela. Se você criar vários backups incrementais, deverá copiar o arquivo `res.txt` depois do último backup incremental antes de poder aplicá-lo na instância de destino.
As etapas são as mesmas de [Fase 2: Preparar o backup completo dos espaços de tabela](#oracle-migrating-tts.initial-br-phase), exceto que a etapa de importação é opcional.
## Fase 4: Transportar os espaços de tabela
Nesta fase, você fará backup dos espaços de tabela somente leitura e exportará os metadados do Data Pump, transferirá esses arquivos para o host de destino e importará os espaços de tabela e os metadados.
**Topics**
+ [Etapa 1: Fazer backup dos espaços de tabela somente leitura](#oracle-migrating-tts.final-backup)
+ [Etapa 2: Exportar os metadados dos espaços de tabela no host de origem](#oracle-migrating-tts.transport.export)
+ [Etapa 3: (somente Amazon S3) Transferir os arquivos de backup e exportação para a instância de banco de dados de destino](#oracle-migrating-tts.transport)
+ [Etapa 4: Importar os espaços de tabela na instância de banco de dados de destino](#oracle-migrating-tts.restore-full)
+ [Etapa 5: Importar os metadados de espaços de tabela na instância de banco de dados de destino](#oracle-migrating-tts.transport.import-dmp)
### Etapa 1: Fazer backup dos espaços de tabela somente leitura
Esta etapa é idêntica a [Etapa 1: Fazer backup dos espaços de tabela no host de origem](#oracle-migrating-tts.backup-full), com uma única diferença importante: você coloca os espaços de tabela no modo somente leitura antes de fazer backup dos espaços de tabela pela última vez.
O exemplo a seguir coloca `tbs1`, `tbs2` e `tbs3` no modo somente leitura.
```
ALTER TABLESPACE tbs1 READ ONLY;
ALTER TABLESPACE tbs2 READ ONLY;
ALTER TABLESPACE tbs3 READ ONLY;
```
### Etapa 2: Exportar os metadados dos espaços de tabela no host de origem
Exporte os metadados dos espaços de tabela executando o utilitário `expdb` no host de origem. O exemplo a seguir exporta os espaços de tabela *TBS1*, *TBS2* e *TBS3* para o arquivo de despejo *xttdump.dmp* no diretório *DATA\$1PUMP\$1DIR*.
```
expdp username/pwd \
dumpfile=xttdump.dmp \
directory=DATA_PUMP_DIR \
statistics=NONE \
transport_tablespaces=TBS1,TBS2,TBS3 \
transport_full_check=y \
logfile=tts_export.log
```
Se *DATA\$1PUMP\$1DIR* for um diretório compartilhado no Amazon EFS, vá para [Etapa 4: Importar os espaços de tabela na instância de banco de dados de destino](#oracle-migrating-tts.restore-full).
### Etapa 3: (somente Amazon S3) Transferir os arquivos de backup e exportação para a instância de banco de dados de destino
Se você estiver usando o Amazon S3 para preparar os backups de espaços de tabela e o arquivo de exportação do Data Pump, conclua as etapas a seguir.
#### Etapa 3.1: Fazer upload dos backups e do arquivo de despejo do host de origem no bucket do Amazon S3
Faça upload dos arquivos de backup e despejo do host de origem no bucket do Amazon S3. Para obter mais informações, consulte [Fazer upload de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) no *Guia do usuário do Amazon Simple Storage Service*.
#### Etapa 3.2: Fazer download dos backups e do arquivo de despejo do bucket do Amazon S3 para a instância de banco de dados de destino
Nesta etapa, use o procedimento `rdsadmin.rdsadmin_s3_tasks.download_from_s3` para fazer download dos backups e do arquivo de despejo para a instância de banco de dados do RDS para Oracle. Siga as etapas em [Etapa 2.3: Fazer download dos backups do bucket do Amazon S3 para a instância de banco de dados de destino](#oracle-migrating-tts.download-full).
### Etapa 4: Importar os espaços de tabela na instância de banco de dados de destino
Use o procedimento `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` para restaurar os espaços de tabela. Para conhecer a sintaxe e a semântica desse procedimento, consulte [Importar espaços para tabela transportados para a instância de banco de dados](rdsadmin_transport_util_import_xtts_tablespaces.md).
**Importante**
Depois de concluir a importação final de espaços de tabela, a próxima etapa será [importar os metadados do Oracle Data Pump](#oracle-migrating-tts.transport.export). Em caso de falha na importação, é importante restaurar o estado da instância de banco de dados anterior à falha. Portanto, recomendamos que você crie um snapshot de banco de dados da instância de banco de dados seguindo as instruções em [Criar um snapshot de banco de dados para uma instância de banco de dados single-AZ para o Amazon RDS](USER_CreateSnapshot.md). O snapshot conterá todos os espaços de tabela importados, portanto, se a importação falhar, você não precisará repetir o processo de backup e importação.
Se a instância de banco de dados de destino estiver com a opção de backups automáticos ativada e o Amazon RDS não detectar que um snapshot válido foi iniciado antes da importação dos metadados, o RDS tentará criar um snapshot. Dependendo da atividade da instância, esse snapshot pode ou não ser bem-sucedido. Se um snapshot válido não for detectado ou se não for possível iniciar o snapshot, a importação de metadados será encerrada com erros.
**Importar os espaços de tabela na instância de banco de dados de destino**
1. Inicie um cliente Oracle SQL e faça login como usuário principal na instância de banco de dados de destino do RDS para Oracle.
1. Execute o procedimento `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`, especificando os espaços de tabela que serão importados e o diretório que contém os backups.
O exemplo a seguir importa os espaços de tabela *TBS1*, *TBS2* e *TBS3* do diretório *DATA\$1PUMP\$1DIR*.
```
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces('TBS1,TBS2,TBS3','DATA_PUMP_DIR');
END;
/
PRINT task_id
```
1. (Opcional) Monitore o progresso consultando a tabela `rdsadmin.rds_xtts_operation_info`. A coluna `xtts_operation_state` mostra o valor `EXECUTING`, `COMPLETED` ou `FAILED`.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**nota**
Para operações de longa duração, você também pode consultar `V$SESSION_LONGOPS`, `V$RMAN_STATUS` e `V$RMAN_OUTPUT`.
1. Veja o log da importação concluída usando o ID de tarefa da etapa anterior.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
Verifique se importação foi bem-sucedida antes de prosseguir para a próxima etapa.
1. Gere um snapshot manual do banco de dados seguindo as instruções em [Criar um snapshot de banco de dados para uma instância de banco de dados single-AZ para o Amazon RDS](USER_CreateSnapshot.md).
### Etapa 5: Importar os metadados de espaços de tabela na instância de banco de dados de destino
Nesta etapa, importe os metadados de espaços de tabela transportáveis para a instância de banco de dados do RDS para Oracle usando o procedimento `rdsadmin.rdsadmin_transport_util.import_xtts_metadata`. Para conhecer a sintaxe e a semântica desse procedimento, consulte [Importar metadados de espaços para tabela transportáveis para a instância de banco de dados](rdsadmin_transport_util_import_xtts_metadata.md). Durante a operação, o status da importação é mostrado na tabela `rdsadmin.rds_xtts_operation_info`.
**Importante**
Antes de importar metadados, é altamente recomendável que você confirme se um snapshot do banco de dados foi criado com êxito depois da importação dos espaços de tabela. Se a etapa de importação falhar, restaure a instância de banco de dados, resolva os erros de importação e tente importar novamente.
**Importar os metadados do Data Pump para uma instância de banco de dados do RDS para Oracle**
1. Inicie seu cliente Oracle SQL e faça login como usuário principal na instância de banco de dados de destino.
1. Crie os usuários proprietários de esquemas nos espaços de tabela transportados, caso esses usuários ainda não existam.
```
CREATE USER tbs_owner IDENTIFIED BY password;
```
1. Importe os metadados, especificando o nome do arquivo de despejo e sua localização no diretório.
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
1. (Opcional) Consulte a tabela de histórico de espaços de tabela transportáveis para ver o status da importação de metadados.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
Quando a operação for concluída, os espaços de tabela ficarão no modo somente leitura.
1. (Opcional) Veja o arquivo de log.
O exemplo a seguir lista o conteúdo do diretório BDUMP, depois consulta o log de importação.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'BDUMP'));
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-import_xtts_metadata-2023-05-22.01-52-35.560858000.log'));
```
## Fase 5: Validar os espaços de tabela transportados
Nesta etapa opcional, você validará os espaços de tabela transportados usando o procedimento `rdsadmin.rdsadmin_rman_util.validate_tablespace`, depois colocará os espaços de tabela no modo de leitura/gravação.
**Como validar os dados transportados**
1. Inicie o SQL\$1Plus ou o SQL Developer e faça login como usuário principal em sua instância de banco de dados de destino.
1. Valide os espaços de tabela usando o procedimento `rdsadmin.rdsadmin_rman_util.validate_tablespace`.
```
SET SERVEROUTPUT ON
BEGIN
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS1',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS2',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS3',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
END;
/
```
1. Coloque os espaços de tabela no modo de leitura/gravação.
```
ALTER TABLESPACE TBS1 READ WRITE;
ALTER TABLESPACE TBS2 READ WRITE;
ALTER TABLESPACE TBS3 READ WRITE;
```
## Fase 6: Limpar os arquivos restantes
Nesta etapa opcional, você removerá todos os arquivos desnecessários. Use o procedimento `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` para listar arquivos de dados que ficaram órfãos após a importação de um espaço de tabela e, depois, use o procedimento `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` para excluí-los. Para conhecer a sintaxe e a semântica desses procedimentos, consulte [Listar arquivos órfãos após a importação de um espaço para tabela](rdsadmin_transport_util_list_xtts_orphan_files.md) e [Excluir arquivos de dados órfãos após a importação de espaços para tabela](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md).
**Como limpar os arquivos restantes**
1. Remova os backups antigos em *DATA\$1PUMP\$1DIR* da seguinte forma:
1. Liste os arquivos de backup executando `rdsadmin.rdsadmin_file_util.listdir`.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'DATA_PUMP_DIR'));
```
1. Remova os backups um por um chamando `UTL_FILE.FREMOVE`.
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'backup_filename');
```
1. Se você importou espaços de tabela, mas não importou metadados para esses espaços de tabela, poderá excluir os arquivos de dados órfãos da seguinte forma:
1. Liste os arquivos de dados órfãos que você precisa excluir. O exemplo a seguir executa o procedimento `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`.
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
1. Exclua os arquivos órfãos executando o procedimento `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`.
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
A operação de limpeza gera um arquivo de log que usa o formato de nome `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` no diretório `BDUMP`.
1. Leia o arquivo de log gerado na etapa anterior. O exemplo a seguir lê o log `rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log`.
```
SELECT *
FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log'));
TEXT
--------------------------------------------------------------------------------
orphan transported datafile datafile_7.dbf deleted.
orphan transported datafile datafile_8.dbf deleted.
```
1. Se você importou espaços de tabela e importou metadados para esses espaços de tabela, mas encontrou erros de compatibilidade ou outros problemas do Oracle Data Pump, limpe os arquivos de dados parcialmente transportados da seguinte forma:
1. Liste os espaços de tabela que contêm arquivos de dados parcialmente transportados consultando `DBA_TABLESPACES`.
```
SQL> SELECT TABLESPACE_NAME FROM DBA_TABLESPACES WHERE PLUGGED_IN='YES';
TABLESPACE_NAME
--------------------------------------------------------------------------------
TBS_3
```
1. Elimine os espaços de tabela e os arquivos de dados parcialmente transportados.
```
DROP TABLESPACE TBS_3 INCLUDING CONTENTS AND DATAFILES;
```
# Importar usando o Oracle Data Pump
O Oracle Data Pump é um utilitário que permite exportar dados Oracle para um arquivo de despejo e importá-los para outro banco de dados Oracle. Ele é uma substituição a longo prazo para os utilitários de importação/exportação da Oracle. O Oracle Data Pump é a maneira preferida de mover grandes quantidades de dados de um banco de dados Oracle para uma instância de banco de dados do Amazon RDS.
Os exemplos desta seção mostram uma maneira de importar dados para um banco de dados Oracle, o Oracle Data Pump oferece suporte a outras técnicas. Para obter mais informações, consulte a [documentação do Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump.html#GUID-501A9908-BCC5-434C-8853-9A6096766B5A).
Os exemplos desta seção usam o pacote `DBMS_DATAPUMP`. Você pode realizar as mesmas tarefas usando os utilitários da linha de comando do Oracle Data Pump `impdp` e `expdp`. Você pode instalar esses utilitários em um host remoto como parte de uma instalação do Oracle Client, incluindo o Oracle Instant Client. Para obter mais informações, consulte [“Como usar o Oracle Instant Client para executar a importação ou exportação do Data Pump para a minha instância de banco de dados do Amazon RDS para Oracle?”](https://aws.amazon.com/premiumsupport/knowledge-center/rds-oracle-instant-client-datapump/)
**Topics**
+ [Visão geral do Oracle Data Pump](#Oracle.Procedural.Importing.DataPump.Overview)
+ [Importar dados com o Oracle Data Pump e um bucket do Amazon S3](#Oracle.Procedural.Importing.DataPump.S3)
+ [Importar dados com o Oracle Data Pump e um link de banco de dados](#Oracle.Procedural.Importing.DataPump.DBLink)
## Visão geral do Oracle Data Pump
O Oracle Data Pump tem os seguintes componentes:
+ Clientes de linha de comando `expdp` e `impdp`
+ O pacote PL/SQL `DBMS_DATAPUMP`
+ O pacote PL/SQL `DBMS_METADATA`
Você pode usar o Oracle Data Pump nos seguintes cenários:
+ Importar dados de um banco de dados Oracle, on-premises ou em uma instância do Amazon EC2), para uma instância de banco de dados do RDS para Oracle.
+ Importar dados de uma instância de banco de dados do RDS para Oracle para um banco de dados Oracle, on-premises ou em uma instância do Amazon EC2.
+ Importar dados entre instâncias de banco de dados do RDS para Oracle, por exemplo, para migrar dados do EC2-Classic para a VPC.
Para baixar os utilitários do Oracle Data Pump, consulte [“Oracle database software downloads”](http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.html) (Downloads do software Oracle Database) no site da Oracle Technology Network. Para considerações sobre compatibilidade ao migrar entre versões do Oracle Database, consulte [a documentação do Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-BAA3B679-A758-4D55-9820-432D9EB83C68).
### Fluxo de trabalho do Oracle Data Pump
Normalmente, você usa o Oracle Data Pump nos seguintes estágios:
1. Exportar seus dados em um arquivo de despejo no banco de dados de origem.
1. Carregar seu arquivo de despejo em sua instância de destino do RDS para Oracle. Você pode transferir usando um bucket do Amazon S3 ou usando um link de banco de dados entre os dois bancos de dados.
1. Importe os dados de seu arquivo de despejo em sua instância de banco de dados do RDS para Oracle.
### Práticas recomendadas do Oracle Data Pump
Ao usar o Oracle Data Pump para importar dados para uma instância do RDS para Oracle, recomendamos as seguintes práticas:
+ Faça importações no modo `schema` ou `table` para importar esquemas e objetos específicos.
+ Limite os esquemas que você importa àqueles exigidos por sua aplicação.
+ Não importe no modo `full` ou importar esquemas para componentes mantidos pelo sistema.
Como o RDS para Oracle não permite o acesso a usuários administrativos do `SYS` ou `SYSDBA`, essas ações podem danificar o dicionário de dados da Oracle e afetar a estabilidade de seu banco de dados.
+ Ao carregar grandes quantidades de dados, faça o seguinte:
1. Transfira o arquivo de despejo para a instância de banco de dados do RDS para Oracle de destino.
1. Crie um snapshot do banco de dados da instância.
1. Teste a importação para verificar se ela é bem-sucedida.
Se os componentes do banco de dados forem invalidados, você poderá excluir a instância de banco de dados e recriá-la a partir do snapshot. A instância de banco de dados restaurada incluirá qualquer arquivo de despejo preparado na instância de banco de dados quando você criou o snapshot.
+ Não importe arquivos de despejo que foram criados usando os parâmetros de exportação do Oracle Data Pump `TRANSPORT_TABLESPACES`, `TRANSPORTABLE` ou `TRANSPORT_FULL_CHECK`. As instâncias de banco de dados do RDS para Oracle não oferecem suporte à importação desses arquivos de despejo.
+ Não importe arquivos de despejo que contenham objetos do Oracle Scheduler em `SYS`, `SYSTEM`, `RDSADMIN`, `RDSSEC` e `RDS_DATAGUARD` e pertençam às seguintes categorias:
+ Tarefas
+ Programas
+ Schedules
+ Cadeias
+ Regras
+ Contextos de avaliação
+ Conjuntos de regras
As instâncias de banco de dados do RDS para Oracle não oferecem suporte à importação desses arquivos de despejo.
+ Para excluir objetos do Oracle Scheduler não aceitos, use diretivas adicionais durante a exportação do Data Pump. Se usar o `DBMS_DATAPUMP`, você poderá adicionar um `METADATA_FILTER` antes do `DBMS_METADATA.START_JOB`:
```
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM SYS.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
```
Se você usar o `expdp`, crie um arquivo de parâmetro que contenha a diretiva `exclude` mostrada no exemplo a seguir. Em seguida, use `PARFILE=parameter_file` com o comando `expdp`.
```
exclude=procobj:"IN
(SELECT NAME FROM sys.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)"
```
## Importar dados com o Oracle Data Pump e um bucket do Amazon S3
O processo de importação a seguir usa o Oracle Data Pump e um bucket do Amazon S3. As etapas são:
1. Exporte dados no banco de dados de origem usando o pacote[DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html) da Oracle.
1. Coloque o arquivo de despejo em um bucket do Amazon S3.
1. Baixe o arquivo de despejo do bucket do Amazon S3 no diretório `DATA_PUMP_DIR` na instância de destino do banco de dados do RDS para Oracle.
1. Importe os dados do arquivo de despejo copiado para a instância de banco de dados do RDS para Oracle usando o pacote `DBMS_DATAPUMP`.
**Topics**
+ [Requisitos para importar dados com o Oracle Data Pump e um bucket do Amazon S3](#Oracle.Procedural.Importing.DataPumpS3.requirements)
+ [Etapa 1: Conceder privilégios ao usuário do banco de dados na instância de banco de dados de destino do RDS para Oracle](#Oracle.Procedural.Importing.DataPumpS3.Step1)
+ [Etapa 2: Exportar dados para um arquivo de despejo usando DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpS3.Step2)
+ [Etapa 3: Carregar o arquivo de despejo para o seu bucket do Amazon S3](#Oracle.Procedural.Importing.DataPumpS3.Step3)
+ [Etapa 4: Baixe o arquivo no bucket do Amazon S3 para a instância de banco de dados de destino](#Oracle.Procedural.Importing.DataPumpS3.Step4)
+ [Etapa 5: Importar seu arquivo de despejo para sua instância de banco de dados de destino usando DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpS3.Step5)
+ [Etapa 6: Limpeza](#Oracle.Procedural.Importing.DataPumpS3.Step6)
### Requisitos para importar dados com o Oracle Data Pump e um bucket do Amazon S3
O processo tem estes requisitos:
+ Verifique se há um bucket do Amazon S3 disponível para transferências de arquivos e se o bucket do Amazon S3 está na mesma Região da AWS que a instância de banco de dados. Para obter mais informações, consulte [Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) no *Guia de conceitos básicos do Amazon Simple Storage Service*.
+ O objeto carregado no bucket do Amazon S3 deve ter 5 TB ou menos. Para obter mais informações sobre como trabalhar com objetos no Amazon S3, consulte o [Manual do usuário do Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingObjects.html).
**nota**
Se o arquivo de despejo for superior a 5 TB, será possível executar a exportação do Oracle Data Pump com a opção paralela. Essa operação distribui os dados em vários arquivos de despejo para que você não exceda o limite de 5 TB para arquivos individuais.
+ Você deve preparar o bucket do Amazon S3 para a integração com o Amazon RDS seguindo as instruções em [Configurar permissões do IAM para a integração do RDS para Oracle com o Amazon S3](oracle-s3-integration.preparing.md).
+ Você deve ter espaço de armazenamento suficiente para armazenar o arquivo de despejo na instância de origem e na instância de banco de dados de destino.
**nota**
Esse processo importa um arquivo de despejo no diretório `DATA_PUMP_DIR`, um diretório pré-configurado em todas as instâncias de banco de dados Oracle. Esse diretório está localizado no mesmo volume de armazenamento que seus arquivos de dados. Ao importar o arquivo de despejo, os arquivos de dados existes da Oracle usam mais espaço. Dessa forma, você deve verificar se a sua instância de banco de dados pode acomodar o uso de espaço adicional. O arquivo de despejo importado não é excluído ou limpo automaticamente do diretório `DATA_PUMP_DIR`. Para remover o arquivo de despejo importado, use [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), que pode ser encontrado no site da Oracle.
### Etapa 1: Conceder privilégios ao usuário do banco de dados na instância de banco de dados de destino do RDS para Oracle
Nesta etapa, você cria os esquemas nos quais planeja importar dados e concede aos usuários os privilégios necessários.
**Para criar usuários e conceder os privilégios necessários na instância do RDS para Oracle de destino**
1. Use o SQL\$1Plus ou o Oracle SQL Developer para fazer login como usuário mestre na instância de banco de dados do RDS para Oracle para onde os dados serão importados. Para saber mais sobre como se conectar à sua instância de banco de dados, consulte [Conectar-se a uma instância de banco de dados Oracle](USER_ConnectToOracleInstance.md).
1. Crie os espaços de tabela necessários antes de importar os dados. Para obter mais informações, consulte [Criar e usar espaços de tabela no RDS para Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles).
1. Crie a conta de usuário e conceda as permissões e funções necessárias se a conta de usuário na qual os dados serão importados não existir. Se você planeja importar dados para vários esquemas de usuários, crie cada conta de usuário e conceda as funções e os privilégios necessários a ela.
Por exemplo, as instruções SQL a seguir criam um novo usuário e concedem as permissões e funções necessárias para importar os dados para o esquema de propriedade do usuário. Substitua `schema_1` pelo nome de seu schema nesta e nas etapas a seguir.
```
CREATE USER schema_1 IDENTIFIED BY my_password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
As instruções anteriores concedem ao novo usuário o privilégio `CREATE SESSION` e a função `RESOURCE`. Podem ser necessários privilégios e funções adicionais dependendo dos objetos de banco de dados que você importar.
### Etapa 2: Exportar dados para um arquivo de despejo usando DBMS\$1DATAPUMP
Para criar um arquivo de despejo, use o pacote `DBMS_DATAPUMP`.
**Como exportar dados Oracle para um arquivo de despejo**
1. Use o SQL Plus ou o Oracle SQL Developer para se conectar à instância de banco de dados do RDS para Oracle de origem por meio de um usuário administrativo. Se o banco de dados de origem for uma instância de banco de dados do RDS para Oracle, conecte-se com o usuário mestre do Amazon RDS.
1. Exporte os dados chamando procedimentos do `DBMS_DATAPUMP`.
O script a seguir exporta o esquema `SCHEMA_1` em um arquivo de despejo chamado `sample.dmp` no diretório `DATA_PUMP_DIR`. Substitua `SCHEMA_1` pelo nome do esquema que você quer exportar.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'EXPORT',
job_mode => 'SCHEMA',
job_name => null
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl ,
filename => 'sample.dmp' ,
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_exp.log',
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_log_file
);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM SYS.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**nota**
O Data Pump inicia os trabalhos de forma assíncrona. Para obter informações sobre o monitoramento de um trabalho do Data Pump, consulte [Monitoring Job Status](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) (Monitorar status do trabalho) na documentação da Oracle.
1. (Opcional) Você pode visualizar o conteúdo do log de exportação chamando o procedimento `rdsadmin.rds_file_util.read_text_file`. Para obter mais informações, consulte [Leitura de arquivos no diretório de uma instância de banco de dados](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
### Etapa 3: Carregar o arquivo de despejo para o seu bucket do Amazon S3
Use o procedimento `rdsadmin.rdsadmin_s3_tasks.upload_to_s3` do Amazon RDS para copiar o arquivo de despejo no bucket do Amazon S3. O exemplo a seguir faz upload todos os arquivos do diretório `DATA_PUMP_DIR` para um bucket do Amazon S3 chamado `amzn-s3-demo-bucket`.
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
A instrução `SELECT` retorna o ID da tarefa em um tipo de dados `VARCHAR2`. Para obter mais informações, consulte [Carregar arquivos de uma instância de banco de dados do RDS para Oracle para um bucket do Amazon S3](oracle-s3-integration.using.md#oracle-s3-integration.using.upload).
### Etapa 4: Baixe o arquivo no bucket do Amazon S3 para a instância de banco de dados de destino
Execute esta etapa usando o procedimento `rdsadmin.rdsadmin_s3_tasks.download_from_s3` do Amazon RDS. Quando você baixar um arquivo em um diretório, o procedimento `download_from_s3` ignorará o download se um arquivo com nome idêntico já existir no diretório. Para remover um arquivo do diretório de downloads, use [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), que pode ser encontrado no site da Oracle.
**Como baixar seu arquivo de despejo**
1. Inicie o SQL\$1Plus ou o Oracle SQL Developer e faça login como mestre em sua instância de banco de dados Oracle de destino do Amazon RDS
1. Baixe o arquivo de despejo usando o procedimento do Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3`.
O exemplo a seguir baixa todos os arquivos de um bucket do Amazon S3 chamado `amzn-s3-demo-bucket` no diretório `DATA_PUMP_DIR`.
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
A instrução `SELECT` retorna o ID da tarefa em um tipo de dados `VARCHAR2`. Para obter mais informações, consulte [Baixar arquivos de um bucket do Amazon S3 para uma instância de banco de dados Oracle](oracle-s3-integration.using.md#oracle-s3-integration.using.download).
### Etapa 5: Importar seu arquivo de despejo para sua instância de banco de dados de destino usando DBMS\$1DATAPUMP
Use o `DBMS_DATAPUMP` para importar o esquema em sua instância de banco de dados do RDS para Oracle. Opções adicionais, como `METADATA_REMAP`, podem ser necessárias.
**Para importar dados para sua instância de banco de dados de destino**
1. Inicie o SQL\$1Plus ou o SQL Developer e faça login como usuário mestre em sua instância de banco de dados do RDS para Oracle.
1. Importe os dados chamando procedimentos `DBMS_DATAPUMP`.
O exemplo a seguir importa os dados de *SCHEMA\$11* de `sample_copied.dmp` em sua instância de banco de dados de destino.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'SCHEMA',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_copied.dmp',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_imp.log',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**nota**
Os trabalhos do Data Pump são iniciados de forma assíncrona. Para obter informações sobre o monitoramento de um trabalho do Data Pump, consulte [Monitoring Job Status](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) (Monitorar status do trabalho) na documentação da Oracle. Você pode visualizar o conteúdo do log de importação usando o procedimento `rdsadmin.rds_file_util.read_text_file`. Para obter mais informações, consulte [Leitura de arquivos no diretório de uma instância de banco de dados](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
1. Verifique a importação de dados listando as tabelas de esquema na sua instância de banco de dados de destino.
Por exemplo, a consulta a seguir retorna o número de tabelas para o `SCHEMA_1`.
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### Etapa 6: Limpeza
Depois que os dados foram importados, você pode excluir os arquivos que não deseja manter.
**Como remover arquivos desnecessários**
1. Inicie o SQL\$1Plus ou o SQL Developer e faça login como usuário mestre em sua instância de banco de dados do RDS para Oracle.
1. Liste os arquivos no `DATA_PUMP_DIR` usando o comando a seguir.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
1. Para excluir arquivos no `DATA_PUMP_DIR` que não são mais necessários, use o comando a seguir.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','filename');
```
Por exemplo, o seguinte comando exclui o arquivo chamado `sample_copied.dmp`.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
## Importar dados com o Oracle Data Pump e um link de banco de dados
O processo a seguir usa o Oracle Data Pump e o pacote [DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_FILE_TRANSFER.html) do Oracle. As etapas são:
1. Conecte-se a um banco de dados Oracle de origem, que pode ser um banco de dados on-premises, uma instância do Amazon EC2 ou uma instância de banco de dados do RDS para Oracle.
1. Exporte dados usando o pacote [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html).
1. Ele usa `DBMS_FILE_TRANSFER.PUT_FILE` para copiar o arquivo de despejo do banco de dados Oracle para o diretório `DATA_PUMP_DIR` na instância do banco de dados do RDS para Oracle de destino que está conectada por meio de um link de banco de dados.
1. Importe os dados do arquivo de despejo copiado para a instância de banco de dados do RDS para Oracle usando o pacote ` DBMS_DATAPUMP`.
O processo de importação usando o Oracle Data Pump e o pacote `DBMS_FILE_TRANSFER` tem as etapas a seguir.
**Topics**
+ [Requisitos para importar dados com o Oracle Data Pump e um link de banco de dados](#Oracle.Procedural.Importing.DataPumpDBLink.requirements)
+ [Etapa 1: Conceder privilégios ao usuário na instância de destino do RDS para Oracle](#Oracle.Procedural.Importing.DataPumpDBLink.Step1)
+ [Etapa 2: Conceder privilégios ao usuário no banco de dados de origem](#Oracle.Procedural.Importing.DataPumpDBLink.Step2)
+ [Etapa 3: Criar um arquivo de despejo usando DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpDBLink.Step3)
+ [Etapa 4: Criar o vínculo de banco de dados com a instância de banco de dados de destino](#Oracle.Procedural.Importing.DataPumpDBLink.Step4)
+ [Etapa 5: Copiar o arquivo de despejo exportado para a instância de banco de dados de destino usando DBMS\$1FILE\$1TRANSFER](#Oracle.Procedural.Importing.DataPumpDBLink.Step5)
+ [Etapa 6: Importar o arquivo de dados para a instância de banco de dados de destino usando DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpDBLink.Step6)
+ [Etapa 7: Limpeza](#Oracle.Procedural.Importing.DataPumpDBLink.Step7)
### Requisitos para importar dados com o Oracle Data Pump e um link de banco de dados
O processo tem estes requisitos:
+ É necessário ter privilégios de execução nos pacotes `DBMS_FILE_TRANSFER` e `DBMS_DATAPUMP`.
+ É necessário ter privilégios de gravação no diretório `DATA_PUMP_DIR` na instância de banco de dados de origem.
+ Você deve ter espaço de armazenamento suficiente para armazenar o arquivo de despejo na instância de origem e na instância de banco de dados de destino.
**nota**
Esse processo importa um arquivo de despejo no diretório `DATA_PUMP_DIR`, um diretório pré-configurado em todas as instâncias de banco de dados Oracle. Esse diretório está localizado no mesmo volume de armazenamento que seus arquivos de dados. Ao importar o arquivo de despejo, os arquivos de dados existes da Oracle usam mais espaço. Dessa forma, você deve verificar se a sua instância de banco de dados pode acomodar o uso de espaço adicional. O arquivo de despejo importado não é excluído ou limpo automaticamente do diretório `DATA_PUMP_DIR`. Para remover o arquivo de despejo importado, use [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), que pode ser encontrado no site da Oracle.
### Etapa 1: Conceder privilégios ao usuário na instância de destino do RDS para Oracle
Para conceder privilégios ao usuário na instância de banco de dados de destino do RDS para Oracle, sigas estas etapas:
1. Use o SQL Plus ou o Oracle SQL Developer para se conectar à instância de banco de dados do RDS para Oracle para onde você pretende importar os dados. Conecte-se como usuário mestre do Amazon RDS. Para obter informações sobre como se conectar à sua instância de banco de dados, consulte [Conectar-se a uma instância de banco de dados Oracle](USER_ConnectToOracleInstance.md).
1. Crie os espaços de tabela necessários antes de importar os dados. Para obter mais informações, consulte [Criar e usar espaços de tabela no RDS para Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles).
1. Se a conta de usuário na qual os dados serão importados não existir, crie-a e conceda as permissões e funções necessárias a ela. Se você planeja importar dados para vários esquemas de usuários, crie cada conta de usuário e conceda as funções e os privilégios necessários a ela.
Por exemplo, os comandos a seguir criam um novo usuário chamado *schema\$11* e concedem as permissões e funções necessárias para importar os dados para o esquema deste usuário.
```
CREATE USER schema_1 IDENTIFIED BY my-password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
O exemplo anterior concede ao novo usuário o privilégio `CREATE SESSION` e a função `RESOURCE`. Podem ser necessários privilégios e funções adicionais dependendo dos objetos de banco de dados que você importa.
**nota**
Substitua `schema_1` pelo nome de seu schema nesta e nas etapas a seguir.
### Etapa 2: Conceder privilégios ao usuário no banco de dados de origem
Use o SQL\$1Plus ou o Oracle SQL Developer para se conectar à instância de banco de dados do RDS para Oracle que contém os dados a serem importados. Se necessário, crie uma conta de usuário e conceda as permissões necessárias.
**nota**
Se o banco de dados de origem for uma instância do Amazon RDS, você poderá ignorar esta etapa. Use sua conta de usuário mestre do Amazon RDS para executar a exportação.
Os comandos a seguir criam um novo usuário e concedem as permissões necessárias.
```
CREATE USER export_user IDENTIFIED BY my-password;
GRANT CREATE SESSION, CREATE TABLE, CREATE DATABASE LINK TO export_user;
ALTER USER export_user QUOTA 100M ON users;
GRANT READ, WRITE ON DIRECTORY data_pump_dir TO export_user;
GRANT SELECT_CATALOG_ROLE TO export_user;
GRANT EXECUTE ON DBMS_DATAPUMP TO export_user;
GRANT EXECUTE ON DBMS_FILE_TRANSFER TO export_user;
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
### Etapa 3: Criar um arquivo de despejo usando DBMS\$1DATAPUMP
Para criar o arquivo de despejo, faça o seguinte:
1. Use o SQL\$1Plus ou o Oracle SQL Developer para se conectar à instância de origem do Oracle por meio de um usuário administrativo ou o usuário que você criou na etapa 2. Se o banco de dados de origem for uma instância de banco de dados do Amazon RDS para Oracle, conecte-se com o usuário mestre do Amazon RDS.
1. Crie um arquivo de despejo usando o utilitário Oracle Data Pump.
O script a seguir cria um arquivo de despejo chamado *sample.dmp* no diretório `DATA_PUMP_DIR`.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'EXPORT' ,
job_mode => 'SCHEMA' ,
job_name => null
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample.dmp' ,
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_dump_file
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl ,
filename => 'sample_exp.log' ,
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_log_file
);
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl ,
'SCHEMA_EXPR' ,
'IN (''SCHEMA_1'')'
);
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM sys.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**nota**
Os trabalhos do Data Pump são iniciados de forma assíncrona. Para obter informações sobre o monitoramento de um trabalho do Data Pump, consulte [Monitoring Job Status](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) (Monitorar status do trabalho) na documentação da Oracle. É possível visualizar o conteúdo do log de exportação usando o procedimento `rdsadmin.rds_file_util.read_text_file`. Para obter mais informações, consulte [Leitura de arquivos no diretório de uma instância de banco de dados](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
### Etapa 4: Criar o vínculo de banco de dados com a instância de banco de dados de destino
Crie um link de banco de dados entre sua instância de banco de dados de origem e sua instância de banco de dados de destino. Observe que sua instância local do Oracle deve ter conectividade de rede com a instância de banco de dados para criar um link de banco de dados e transferir seu arquivo de despejo.
Realize esta etapa conectado com a mesma conta de usuário da etapa anterior.
Se você estiver criando um link de banco de dados entre duas instâncias de bancos de dados na mesma VPC ou VPCs emparelhadas, as duas instâncias de bancos de dados deverão ter uma rota válida entre elas. O grupo de segurança de cada instância de banco de dados deve permitir a entrada e a saída da outra instância de banco de dados. As regras de entrada e saída do grupo de segurança podem se referir a grupos de segurança da mesma VPC ou de uma VPC emparelhada. Para obter mais informações, consulte [Ajuste de vínculos de banco de dados para uso com instâncias de bancos de dados em uma VPC](Appendix.Oracle.CommonDBATasks.DBLinks.md).
O comando a seguir cria um link de banco de dados chamado `to_rds` que se conecta ao usuário mestre do Amazon RDS na instância de banco de dados de destino.
```
CREATE DATABASE LINK to_rds
CONNECT TO IDENTIFIED BY
USING '(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=)
(PORT=))(CONNECT_DATA=(SID=)))';
```
### Etapa 5: Copiar o arquivo de despejo exportado para a instância de banco de dados de destino usando DBMS\$1FILE\$1TRANSFER
Use `DBMS_FILE_TRANSFER` para copiar o arquivo de despejo da instância do banco de dados de origem para a instância de banco de dados de destino. O script a seguir copia um arquivo de despejo chamado sample.dmp da instância de origem para um link de banco de dados de destino chamado *to\$1rds* (criado na etapa anterior).
```
BEGIN
DBMS_FILE_TRANSFER.PUT_FILE(
source_directory_object => 'DATA_PUMP_DIR',
source_file_name => 'sample.dmp',
destination_directory_object => 'DATA_PUMP_DIR',
destination_file_name => 'sample_copied.dmp',
destination_database => 'to_rds' );
END;
/
```
### Etapa 6: Importar o arquivo de dados para a instância de banco de dados de destino usando DBMS\$1DATAPUMP
Use o Oracle Data Pump para importar o esquema na instância de banco de dados. Opções adicionais, como METADATA\$1REMAP, podem ser necessárias.
Conecte-se à instância de banco de dados com a conta de usuário mestre do Amazon RDS para executar a importação.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'SCHEMA',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_copied.dmp',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file );
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_imp.log',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**nota**
Os trabalhos do Data Pump são iniciados de forma assíncrona. Para obter informações sobre o monitoramento de um trabalho do Data Pump, consulte [Monitoring Job Status (Monitorar status do trabalho)](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) na documentação da Oracle. Você pode visualizar o conteúdo do log de importação usando o procedimento `rdsadmin.rds_file_util.read_text_file`. Para obter mais informações, consulte [Leitura de arquivos no diretório de uma instância de banco de dados](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
Você pode verificar a importação de dados visualizando a tabela do usuário na instância de banco de dados. Por exemplo, a consulta a seguir retorna o número de tabelas para o `schema_1`.
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### Etapa 7: Limpeza
Depois que os dados foram importados, você pode excluir os arquivos que não deseja manter. É possível listar os arquivos `DATA_PUMP_DIR` usando o seguinte comando.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
Para excluir arquivos no `DATA_PUMP_DIR` que não são mais necessários, use o comando a seguir.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','');
```
Por exemplo, o seguinte comando exclui o arquivo chamado `"sample_copied.dmp"`.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
# Importar usando Oracle Export/Import
Pode ser útil considerar os utilitários Oracle Export/Import para migrações nas seguintes condições:
+ O volume dos seus dados é pequeno.
+ Tipos de dados como flutuante binário e duplo não são necessários.
O processo de importação cria os objetos de esquema necessários. Assim, você não precisa executar um script para criar os objetos antecipadamente.
A maneira mais fácil de instalar o Oracle e os utilitários de exportação e importação, é instalar o Oracle Instant Client. Para baixar o software, acesse [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html). Para obter a documentação, consulte [Instant Client for SQL\$1Loader, exportação e importação](https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/instant-client-sql-loader-export-import.html#GUID-FF1B6F75-09F5-4911-9317-9776FAD15965) no manual *Utilitários do banco de dados Oracle*.
**Como exportar e importar tabelas**
1. Exporte as tabelas do banco de dados de origem usando o comando `exp`.
O comando a seguir exporta as tabelas chamadas `tab1`, `tab2` e `tab3`. O arquivo de despejo é `exp_file.dmp`.
```
exp cust_dba@ORCL FILE=exp_file.dmp TABLES=(tab1,tab2,tab3) LOG=exp_file.log
```
A exportação cria um arquivo de despejo binário que contém o esquema e os dados das tabelas especificadas.
1. Importe o esquema e os dados em um banco de dados de destino usando o comando `imp`.
O comando a seguir importa as tabelas `tab1`, `tab2` e `tab3` do arquivo de despejo `exp_file.dmp`.
```
imp cust_dba@targetdb FROMUSER=cust_schema TOUSER=cust_schema \
TABLES=(tab1,tab2,tab3) FILE=exp_file.dmp LOG=imp_file.log
```
A exportação e a importação têm outras variações que podem ser mais adequadas às suas necessidades. Consulte a documentação do Oracle Database para obter detalhes completos.
# Importar usando o Oracle SQL\$1Loader
Você pode usar o Oracle SQL\$1Loader para bancos de dados grandes que contêm um número limitado de objetos. Como o processo de exportação de um banco de dados de origem e carregamento em um banco de dados de destino é específico para o esquema, o exemplo a seguir cria os objetos de esquema de amostra, exporta de uma origem, depois carrega os dados em um banco de dados de destino.
A maneira mais fácil de instalar o Oracle SQL\$1Loader é instalar o Oracle Instant Client. Para baixar o software, acesse [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html). Para obter a documentação, consulte [Instant Client for SQL\$1Loader, exportação e importação](https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/instant-client-sql-loader-export-import.html#GUID-FF1B6F75-09F5-4911-9317-9776FAD15965) no manual *Utilitários do banco de dados Oracle*.
**Para importar dados usando o Oracle SQL\$1Loader**
1. Crie uma tabela de origem de exemplo usando a seguinte instrução SQL.
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
```
1. Na instância de banco de dados de destino do RDS para Oracle, crie uma tabela de destino para carregar os dados. A cláusula `WHERE 1=2` garante que você copie a estrutura do `ALL_OBJECTS`, mas não copie nenhuma linha.
```
CREATE TABLE customer_1 TABLESPACE users
AS (SELECT 0 AS ID, OWNER, OBJECT_NAME, CREATED
FROM ALL_OBJECTS
WHERE 1=2);
```
1. Exporte os dados do banco de dados de origem para um arquivo de texto. O exemplo a seguir usa SQL\$1Plus. Para os seus dados, você provavelmente precisará gerar um script que faça a exportação para todos os objetos no banco de dados.
```
ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY/MM/DD HH24:MI:SS'
SET LINESIZE 800 HEADING OFF FEEDBACK OFF ARRAY 5000 PAGESIZE 0
SPOOL customer_0.out
SET MARKUP HTML PREFORMAT ON
SET COLSEP ','
SELECT id, owner, object_name, created
FROM customer_0;
SPOOL OFF
```
1. Crie um arquivo de controle para descrever os dados. Talvez seja necessário escrever um script para realizar essa etapa.
```
cat << EOF > sqlldr_1.ctl
load data
infile customer_0.out
into table customer_1
APPEND
fields terminated by "," optionally enclosed by '"'
(
id POSITION(01:10) INTEGER EXTERNAL,
owner POSITION(12:41) CHAR,
object_name POSITION(43:72) CHAR,
created POSITION(74:92) date "YYYY/MM/DD HH24:MI:SS"
)
```
Se necessário, copie os arquivos gerados pelo código anterior para uma área de teste, como uma instância do Amazon EC2.
1. Importe os dados usando o SQL\$1Loader com o nome de usuário e a senha apropriados para o banco de dados de destino.
```
sqlldr cust_dba@targetdb CONTROL=sqlldr_1.ctl BINDSIZE=10485760 READSIZE=10485760 ROWS=1000
```
# Migrar com visualizações materializadas do Oracle
Para migrar conjuntos de dados grandes de forma eficiente, use a replicação de visualizações materializadas do Oracle. Com a replicação, você pode manter as tabelas de destino sincronizadas com as tabelas de origem. Assim, você pode mudar para o Amazon RDS posteriormente, se necessário.
Antes de poder migrar usando visualizações materializadas, cumpra os seguintes requisitos:
+ Configure o acesso do banco de dados de destino ao banco de dados de origem. No exemplo a seguir, as regras de acesso foram habilitadas no banco de dados de origem para permitir que o banco de dados de destino do RDS para Oracle se conecte à origem via SQL\$1Net.
+ Crie um link de banco de dados entre a instância de banco de dados do RDS para Oracle e o banco de dados de origem.
**Como migrar dados usando visualizações materializadas**
1. Crie uma conta de usuário na instância de origem e na instância de destino do RDS para Oracle que podem se autenticar com a mesma senha. O exemplo a seguir cria um usuário denominado `dblink_user`.
```
CREATE USER dblink_user IDENTIFIED BY my-password
DEFAULT TABLESPACE users
TEMPORARY TABLESPACE temp;
GRANT CREATE SESSION TO dblink_user;
GRANT SELECT ANY TABLE TO dblink_user;
GRANT SELECT ANY DICTIONARY TO dblink_user;
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
1. Crie um link de banco de dados da instância de destino do RDS para Oracle com a instância de origem usando o usuário recém-criado.
```
CREATE DATABASE LINK remote_site
CONNECT TO dblink_user IDENTIFIED BY my-password
USING '(description=(address=(protocol=tcp) (host=my-host)
(port=my-listener-port)) (connect_data=(sid=my-source-db-sid)))';
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
1. Teste o link:
```
SELECT * FROM V$INSTANCE@remote_site;
```
1. Crie uma tabela de exemplo com uma chave primária e um log de visualização materializada na instância de origem.
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
ALTER TABLE customer_0 ADD CONSTRAINT pk_customer_0 PRIMARY KEY (id) USING INDEX;
CREATE MATERIALIZED VIEW LOG ON customer_0;
```
1. Na instância de banco de dados de destino do RDS para Oracle, crie uma visualização materializada.
```
CREATE MATERIALIZED VIEW customer_0
BUILD IMMEDIATE REFRESH FAST
AS (SELECT *
FROM cust_dba.customer_0@remote_site);
```
1. Na instância de banco de dados de destino do RDS para Oracle, atualize a visualização materializada.
```
EXEC DBMS_MVIEW.REFRESH('CUSTOMER_0', 'f');
```
1. Elimine a visualização materializada e inclua a cláusula `PRESERVE TABLE` para reter a tabela de contêineres de visualização materializada e seus conteúdos.
```
DROP MATERIALIZED VIEW customer_0 PRESERVE TABLE;
```
A tabela retida tem o mesmo nome que a visualização materializada que foi eliminada.