Nenhum resultado encontrado

Sua pesquisa não corresponde a nenhum resultado.

Sugerimos que você tente o seguinte para ajudar a encontrar o que procura:

  • Verifique a ortografia da sua pesquisa por palavra-chave.
  • Use sinônimos para a palavra-chave digitada; por exemplo, tente “aplicativo” em vez de “software.”
  • Tente uma das pesquisas populares mostradas abaixo.
  • Inicie uma nova pesquisa.
Perguntas Frequentes

Oracle Database 12.2: Flashback Pluggable Database

Revisado por Marcelo Pivovar - Solution Architect

Por Deiby Gómez,e Alex Zaballa
Publicado em Novembro 2017

Introdução:

Flashback é uma tecnologia introduzida no Oracle Database 10g. Esta tecnologia nos permite realizar várias operações no banco de dados com a intenção de encontrar soluções para os problemas lógicos, como por exemplo: restaurar uma tabela para um ponto do tempo antes de algum DELETE; restaurar uma tabela que foi removida; consultar dados de uma tabela em um momento específico no passado; voltar o banco de dados para um ponto no tempo; entre outros.

Esta tecnologia não necessita de uma restauração física dos arquivos do banco de dados. O Flashback usa dados de UNDO ou Flashback Logs, dependendo de qual função Flashback está sendo utilizada. O Flashback não é um método de recuperação que substitui ferramentas como RMAN restore/recover, export/import ou outros; mas é um complemento.

Na tabela abaixo você pode ver, para cada função de Flashback, o que é usado para desfazer as mudanças:

Flashback Technology Informação usada Exemplos
Database Flashback logs Desfazer um TRUNCATE TABLE
Drop Recycle Bin Desfazer um DROP TABLE
Table Dados de Undo Desfazer um UPDATE com WHERE errado
Query Dados de Undo Comparar dados de uma tabela entre diversos pontos no tempo.
Version Dados de Undo Comparar versões de uma tabela.
Transaction Dados de Undo Investigar as transações que alteraram uma tabela.

Este artigo irá abordar a função Flashback Database.

Alguns administradores de banco de dados confundem uma recuperação via RMAN com uma operação de Flashback Database, mas há uma grande diferença entre um e outro. RMAN restore/recover, como o próprio nome indica, é uma recuperação de todos os Datafiles para um ponto no tempo e, em seguida, é necessário aplicar os archived redo logs para trazer o banco de dados a um ponto consistente.  Isto significa que para usar RMAN restore/recover é necessário ter um backup feito anteriormente.

Em cada versão as funções de Flashback são melhoradas. Quando o Oracle Database 12cR1 surgiu em 2013, a arquitetura Multitenant foi introduzida. Nesta nova arquitetura foram introduzidos os conceitos de Container Database e Pluggable Database. Nesta versão as operações de Flashback Database eram aplicadas ao Container Database e isso afetava todos as Pluggable Databases. Ou seja, para desfazer um problema lógico em um Pluggable Database em particular, todos os Pluggable Databases eram afetados.
A Oracle está constantemente inovando e melhorando seus produtos. Em Novembro de 2016, quando foi lançado o Oracle Database versão 12cR2 para Cloud (Oracle Public Cloud) foi incluída uma grande melhoria no Flashback Database, permitindo agora executar Flashback a nível de Pluggable Databases.

Cenários em que o Flashback Database pode ser utilizado:

  • Útil para realizar testes em aplicações e depois desfazê-las;
  • Para testar alguma atualização;
  • Desfazer alterações indesejadas;
  • Desfazer um OPEN RESETLOGS;
  • “Levar“ um PDB a diferentes pontos no tempo.

Pré-Requisitos para utilizar o Flashback Pluggable Database

Configurar a Fast Recovery Area:


	  
	  SQL> alter system set db_recovery_file_dest = '/u03/app/oracle/fast_recovery_area' scope=both; 
	  System altered.
	  

Configurar a retenção dos Flashback Logs


SQL> alter system set db_flashback_retention_target = 4320 scope=both;
			System altered.
			

NOTA: Este parâmetro é expresso em minutos.

É importante notar que esta retenção não é a garantia de que os Flashback Logs necessários estarão disponíveis. Este tempo de retenção é um tempo desejado, em que o Oracle vai tentar manter os Flashback Logs, mas se o espaço na Fast Recovery Area não for suficiente para manter este período de tempo, então os Flashback Logs mais antigos serão removidos para abrir espaço para os novos.

Habilitar o Flashback a nível de Container Database:

A partir do Oracle Database 11gR2 o seguinte comando pode ser executado enquanto o banco de dados está aberto em read/write, no entanto, é necessário que o banco de dados esteja em Archive Mode. Esta operação deve ser realizada no CDB$ROOT.


		
		SQL> show con_name
			CON_NAME 
			------------------------------ 
			CDB$ROOT
			SQL> alter database flashback;
			Database altered.
			

No Oracle Database 12.2.0.1.0 Enterprise Edition Extreme Performance (Oracle Public Cloud) ainda não é possível habilitar o Flashback a nível de Pluggable Database como mostrado abaixo. No entanto, a sintaxe já existe e é aceita, então podemos esperar que nas próximas versões esse recurso seja implementado.


			
			SQL> alter session set container=NuvolaPDB1;
			
			Session altered.
			
			SQL> alter database flashback on;
			alter database flashback on  
			* 
			ERROR at line 1:
			ORA-03001: unimplemented feature
			

Verificar se o Container Database está com o Flashback habilitado:


	  SQL> select flashback_on from v$database;
	  
			FLASHBACK_ON 
			------------------ 
			YES
			
			

Como boa prática, recomenda-se utilizar Force Logging na Pluggable Database onde você pretende usar Flashback Pluggable Database. A partir da versão 12.1.0.2 você pode habilitar o Force Logging a nível de Pluggable Database.


			SQL> select pdb_name, force_logging, force_nologging from cdb_pdbs
			
			PDB_NAME   FORCE_LOGGING FORCE_NOLOGGING 
			---------- ------------- ---------------  
			PDB$SEED   NO            NO  
			NUVOLAPDB1 YES           NO  
			NUVOLAPDB2 NO            NO
			
			

Como boa prática, também é recomendado verificar se todas as tablespaces da Pluggable Database estão com Flashback ativado:


	  SQL> show con_name
	  CON_NAME  
	  ------------------------------
	  NUVOLAPDB1
	  SQL> select ts#, flashback_on from v$tablespace;
	  TS# FLASHBACK_ON  
	  ---------- ------------- 
	  0 YES 
	  1 YES  
	  2 YES 
	  3 YES
	  

Selecionar pontos e tempos de recuperação:

Para realizar um Flashback Pluggable Database, são necessários pontos de recuperação. Estes pontos podem ser os seguintes:

SCN: Para verificar o SCN atual:


			SQL> select dbms_flashback.get_system_change_number from dual;
			GET_SYSTEM_CHANGE_NUMBER  
			------------------------ 
			1760506 
			

Para verificar o SCN de um banco de dados fechado:


SQL> select timestamp_to_scn(to_date('11-28-2016 04:52:41','mm-dd-yyyy hh24:mi:ss') ) SCN from dual;
SCN  
------------ 
1761245
			

Uma data específica:


			SQL> select to_char(sysdate,'mm-dd-yyyy hh24:mi:ss') cdate from dual;CDATE 
			------------------- 
			11-28-2016 04:52:41 
		

Um ponto de recuperação:


			SQL> create restore point T3 guarantee flashback database;
			Restore point created. 
			

Um ponto de recuperação garantido:


			SQL> create restore point T3 guarantee flashback database;
			Restore point created.
			

Um ponto de recuperação limpo: Um ponto de recuperação limpo, é um ponto criado com a Pluggable Database fechada e portanto sem transações ativas. Esses pontos de recuperação são criados a partir do CDB$ROOT e só podem ser criados com a utilização de Shared Undo pelo PDB.

Com Shared Undoconfigurado:


			SQL> alter pluggable database NuvolaPDB1 close;
			Pluggable database altered.
			SQL> alter session set container=NuvolaPDB1;
			Session altered.
			SQL> create clean restore point CleanPoint;
			Restore point created.
			SQL> alter pluggable database NuvolaPDB1 open;
			Pluggable database altered.
			

Ambiente utilizado para os exemplos:

Alguns exemplos de Flashback Pluggable Database serão demonstrados a seguir. Iremos utilizar duas Pluggable Databases: NuvolaPDB1 e NuvolaPDB2. Todas as operações serão realizadas na PDB NuvolaPDB1, enquanto a PDB NuvolaPDB2 servirá para demonstrar que depois de uma operação de Flashback Pluggable Database na PDB NuvolaPDB1 não irá afetá-la.

Teremos quatro pontos no tempo:

T0: Existem 4 registros na tabela Nuvola.Country em ambas Pluggable Databases.
T1: O registro “USA” foi eliminado da tabela Nuvola.Country em NuvolaPDB1.
T2: O registro “Canada” foi eliminado da tabela Nuvola.Country em NuvolaPDB1.
T3: O registro “Brazil” foi eliminado da tabela Nuvola.Country em NuvolaPDB1.
T4: O registro “Guatemala” foi eliminado da tabela Nuvola.Country em NuvolaPDB1.

Flashback PDB

Serão realizadas quatro operações de Flashback Pluggable Database e entre cada operação serão mostrados os registros da tabela Nuvola.Country em ambas as Pluggable Databases. A intenção é mostrar que as mudanças serão efetuadas apenas na PDB NuvolaPDB1, sem nenhum impacto na NuvolaPDB2.

Flashback Pluggable Database utilizando Local Undo

Tempo atual (T4):

Atualmente a PDB NuvolaPDB1 está em “T4”, o que significa que não existe nenhum registro na tabela Nuvola.Country. NuvolaPDB2 também está em “T4”, o que significa que existem 4 registros na tabela Nuvola.Country:


			
			SQL> show con_name
			CON_NAME  ------------------------------  NUVOLAPDB1
			SQL> select * from Nuvola.Country;
			no rows selected
			SQL> show con_name
			CON_NAME
			------------------------------  
			NUVOLAPDB2
			
			SQL> select * from Nuvola.Country;
			COUNTRY 
			---------------  
			Guatemala  Brazil  Canada  USA
			

Flashback PDB ao ponto “T3” usando um ponto garantido de recuperação:

Conectar-se utilizando um usuário que possua os privilégios SYSDBA e SYSBACKUP:


			SQL> show user  USER is "SYS"
			Conectar-se ao CDB$ROOT:
			SQL> show con_name
			CON_NAME
			------------------------------ 
			CDB$ROOT
			

Fechar a Pluggable Database:


			SQL> alter pluggable database NuvolaPDB1 close;
			Pluggable database altered.
			

Verificar se a Pluggable Database NuvolaPDB1 está fechada e se a NuvolaPDB2 permanece aberta:


			SQL> select name, open_mode from v$pdbs
			NAME        OPEN_MODE 
			----------- ----------  
			PDB$SEED    READ ONLY  
			NUVOLAPDB1  MOUNTED  
			NUVOLAPDB2  READ WRITE
			

Executar a operação de Flashback Pluggable Database:


			SQL> flashback pluggable database NuvolaPDB1 to restore point T3;
			Flashback complete.
			

Abrir a Pluggable Database com OPEN RESETLOGS:


			SQL> alter pluggable database NuvolaPDB1 open resetlogs;
			Pluggable database altered.
			

Verificar os dados no tempo “T3” na PDB NuvolaPDB1:


			SQL> select * from Nuvola.Country;
			COUNTRY 
			---------------
			Guatemala
			

Verificar os dados no tempo “T3” na PDB NuvolaPDB2:


			SQL> select * from Nuvola.Country;
			COUNTRY  
			---------------
			Guatemala 
			Brazil  
			Canada 
			USA
			

NOTA: Todos os passos mostrados aqui devem ser executados cada vez que se realiza um Flashback Pluggable Database. No entanto, a partir de agora, serão omitidas algumas etapas e apenas os passos relevantes serão mostrados.

Flashback PDB ao ponto “T2” usando um ponto específico do tempo:


			SQL> flashback pluggable database NuvolaPDB1 to timestamp to_timestamp('11-28-2016 04:52:41','mm-dd-yyyy hh24:mi:ss');
			Flashback complete.
			

Verificar os dados no tempo “T2” na PDB NuvolaPDB1:


			SQL> select * from Nuvola.Country;
			COUNTRY 
			--------------- 
			Guatemala
			Brazil
			

Flashback PDB ao ponto “T1” usando um ponto de recuperação: 


SQL> flashback pluggable database NuvolaPDB1 to restore point T1;
Flashback complete.

Verificar os dados no tempo “T1” na PDB NuvolaPDB1:


			SQL> select * from Nuvola.Country;
			COUNTRY 
			---------------
			Guatemala 
			Brazil 
			Canada

Flashback PDB ao ponto “T0” usando SCN:


			SQL> flashback pluggable database NuvolaPDB1 to scn 1760506;
			Flashback complete.
			

Verificar os dados no tempo “T0” na PDB NuvolaPDB1:


			SQL> select * from Nuvola.Country;
			COUNTRY  
			---------------
			Guatemala 
			Brazil  
			Canada  
			USA
			

Flashback Pluggable Database utilizando Shared Undo

Agora mostraremos alguns exemplos utilizando a configuração Shared Undo.

Flashback PDB sem utilizar um ponto de recuperação limpo:

A documentação do Oracle Database 12.2.0.1.0 afirma que é possível realizar Flashback Pluggable Databases sem a necessidade de pontos limpos de recuperação. Isto é, a um SCN, a um ponto de recuperação (não limpo) ou a qualquer ponto no tempo.

Em uma configuração Shared Undo, a Tablespace de Undo do CDB$ROOT é compartilhada. Com isso os dados de Undo de várias Pluggable Databases podem estar misturados inclusive a nível de blocos, onde um bloco pode ter informações de Undo de vários Pluggable Databases. Isto torna o funcionamento do Flashback Pluggable Database extremamente complexo neste cenário.

Para utilizar Flashback Pluggable Database com Shared Undo, o Oracle faz uso de uma instância auxiliar.

Segundo a documentação, os seguintes comandos devem ser executados utilizando o RMAN:


			RMAN> flashback pluggable database NuvolaPDB1 to scn 1768131 auxiliary destination '/u01/auxiliary/';
			
			Starting flashback at 28-NOV-16
			using target database control file instead of recovery catalog  
			allocated channel: ORA_DISK_1 
			channel ORA_DISK_1: SID=370 device type=DISK
			
			using channel ORA_DISK_1 
			RMAN-05026: warning: presuming following set of tablespaces applies to specified point-in-time
			
			List of tablespaces expected to have UNDO segments  
			Tablespace SYSTEM  
			Tablespace UNDOTBS1
			
			Creating automatic instance, with SID='vkin' 
			... 
			... 
			...
			

A necessidade de utilizar uma instância auxiliar desaparece se for utilizado um ponto de recuperação limpo. Neste caso, mesmo com a utilização de Shared Undo a operação de Flashback Pluggable Database não requer a instância auxiliar.

Flashback PDB usando um ponto de recuperação limpo:


SQL> flashback pluggable database NuvolaPDB1 to restore point CleanPoint;

Flashback complete.

Se for utilizado um ponto de recuperação limpo, o Pluggable Database não precisa ser aberto com OPEN RESETLOGS.

SQL> alter pluggable database NuvolaPDB1 open;

Pluggable database altered.

Conclusão

O Oracle Database 12.2.0.1.0 traz diversas melhorias em comparação a sua versão anterior, o 12.1.0.2. A introdução do Flashback Pluggable Database fornece uma independência ainda maior dos Pluggable Databases, permitindo a um PDB “mover-se” no tempo sem impactar os demais PDBs.

Este artigo descreveu os métodos mais conhecidos para executar Flashback Pluggable Databases tanto em uma configuração Local Undo como em Shared Undo.

Na configuração Shared Undo mostramos que o Oracle cria uma instância auxiliar e para Local Undo a operação de Flashback é exatamente igual às versões 10g e 11g.

Vários exemplos foram mostrados e com diferentes formas de recuperação para que o leitor tenha uma visão detalhada e abrangente de como utilizar este novo recurso.

Deiby Gomez é "Oracle ACE Director", "A Oracle Certified Master 11g" e "A Oracle 12c Certified Master". Ele tem sido um orador na Oracle Open World nos EUA e no Brasil; em Colaborar, Las Vegas e OTN Tour em vários países da América Latina. Vencedor do "SELECT Choice Award da revista Editor de 2016". Ele é um membro da "OraWorld-Team" foi "Beta Tester" da versão 12cR2. Deiby é Presidente o Grupo usuários Oracle de Guatemala (GOUG) e atualmente é Consultor bancos de dados Oracle em Nuvola Consulting Group (www.nuvolacg.com). Twitter @hdeiby.

Alex Zaballa, formado em Análise de Sistemas, é especialista em Banco de Dados Oracle com sólidos conhecimentos em Servidores de Aplicação e Sistemas Operacionais; trabalha com Oracle há 16 anos, é Oracle ACE Director, certificado OCM Database 12c/11G/Cloud e conta com mais de 200 outras certificações em produtos da Oracle. Alex também é membro do Groupo de Usuários Oracle do Brasil (GUOB), fundador do Grupo de Usuários Oracle de Angola (GUOA) e membro do time OraWorld.

Este artigo foi revisto pela equipe de produtos Oracle e está em conformidade com as normas e práticas para o uso de produtos Oracle.