Alterando o valor do parâmetro processes no Oracle.



O parâmetro processes especifica o numero máximo de processos do usuário do sistema operacional conectado simultaneamente ao Oracle. No momento em que o consumo de processes chega ao valor máximo definido, novas sessões não poderão logar no banco, até que seja liberado processes para uso.

Para realizar a checagem dos valores setados para o parâmetro executamos o comando abaixo:

show parameter process;




Conforme a imagem acima, o valor setado atualmente para o parâmetro é de 300, vamos realizar a alteração do valor para 400.

Podemos ainda buscar mais informações, como a utilização atual do processes e a utilização máxima, consultando na view Gv$resource_limit.

set lines 200

col RESOURCE_NAME for a20

col LIMIT_VALUE for a20

select RESOURCE_NAME,CURRENT_UTILIZATION,MAX_UTILIZATION,LIMIT_VALUE from Gv$resource_limit where resource_name = 'processes';




Agora, para alterar o parâmetro, vamos utilizar o seguinte comando:

alter system set processes=400 scope=spfile;




Note que após a alteração, não teve alteração no valor, vamos precisar reiniciar o banco para que as alterações sejam aplicadas.


Após reiniciar o banco, as alterações foram aplicadas.

Fontes: https://docs.oracle.com/cd/B19306_01/server.102/b14237/initparams169.htm

A view v$asm_diskgroup não retorna valores.




Após a execução de um select na v$asm_diskgroup não é retornado nenhum valor. 

O select abaixo trás os valores de consumo dos DGs do ASM, consultando na v$asm_diskbgrup.

select group_number, name, state from v$asm_diskgroup;

no rows selected


Vamos efetuar a checagem do status do diskgroup pela v$asm_diskgroup_stat.

select  name, state from v$asm_diskgroup_stat;

 NAME                           STATE
------------------------------ -----------
DG_DATA                         MOUNTED
DG_RECO                         MOUNTED


Na v$asm_diskgorup_stat conseguimos o status dos DiskGroups, então porque não conseguimos os resultados da v$asm_diskgroup? 

Vamos realizar a verificação dos parâmetros do DG.

asmcmd dsget

parameter:                              

profile: /dev/raw/raw,/dev/raw/raw*

O campo "parameter" se encontra vazio, no banco de dados, podemos executar o comando abaixo:

show parameter asm_diskstring;

Agora podemos alterar o parametro setando o valor do asm_diskstring.

alter system set asm_diskstring='/dev/raw/raw*';
Realizando o select novamente, temos agora o resultado da v$asm_diskgroup.

select name, state from v$asm_diskgroup;

  NAME                          STATE
 ------------------------------ -----------
 DG_RECO                        MOUNTED
 DG_DATA                        MOUNTED

Instalando o Oracle 12cR2 no Docker utilizando Linux



Neste post vamos aprender a realizar a instalação do Oracle 12cR2 utilizando Docker.

Para este procedimento é necessário o download de dois arquivos

Acesse https://github.com/oracle/docker-images e na opção Clone or download faça download do docker-images-master.zip



Agora acesse https://www.oracle.com/database/technologies/oracle-database-software-downloads.html e faça o download do Oracle 12c Release 2 para Linux:


Movimente o arquivo docker-images-master.zip para /opt

mv docker-images-master.zip  /opt/


Para garantir que não teremos problemas com permissão, vou dar permissão total para o diretório /opt

chmod -R 777 /opt


Extraia o arquivo docker-images-master.zip

unzip docker-images-master.zip


Agora movimente o segundo arquivo baixado linuxx64_12201_database.zip para o diretório /opt/docker-images-master/OracleDatabase/SingleInstance/dockerfiles/12.2.0.1/
mv linuxx64_12201_database.zip /opt/docker-images-master/OracleDatabase/SingleInstance/dockerfiles/12.2.0.1/

Acessando o diretório /opt/docker-images-master/OracleDatabase/SingleInstance/dockerfiles/ podemos executar o arquivo buildDockerImage.sh informando a versão do database e usando o parâmetro -v junto do parâmetro -e por se tratar da versão enterprise.


./buildDockerImage.sh -v 12.2.0.1 -e

Todo processo de instalação será realizado, no final a seguinte mensagem deve aparace: 


Vamos efetuar a criação do banco de dados: 

docker run --name dbtst12 -p 1521:1521 -p 5500:5500 -v /opt:/opt/oracle/oradata oracle/database:12.2.0.1-ee

Ao final devemos receber esta mensagem, indicando que o banco foi criado com sucesso:



Referências:  https://github.com/oracle/docker-images/blob/master/OracleDatabase/SingleInstance/README.md


Instalando o STATSPACK no Oracle Database.



O STATSPACK é um ferramenta de performance tuning fornecida pela Oracle, o fato de não ser necessário uma licença a parte para o uso faz dela uma ótima opção.

O processo para instalação do Oracle STATSPACK é bem simples, vamos começar criando uma tablespace para armazenar os dados.


create tablespace STATSPACK datafile '/u01/app/oracle/oradata/dbteste/statspack_data01.dbf' size 100m autoextend on next 100m maxsize 5000m force logging;



Conectado como sysdba, vamos executar o script de criação localizado em $ORACLE_HOME/rdbms/admin.

@?/rdbms/admin/spcreate.sql


Após a execução, informamos uma senha para o user, a tablespace default e a tablespace temporária, conforme imagem abaixo:




Agora vamos conectar com o usuário perfstat.

conn perfstat/1234


E executar o script a baixo para criar um job para coleta de snapshoot automaticamente.

@?/rdbms/admin/spauto.sql

Para efetuar a manutenção dos snapshoot, será criada uma procedure para aplicar retenção de 7 dias.

CREATE OR REPLACE PROCEDURE statspackpurge

IS

  var_lo_snap     NUMBER;

  var_hi_snap     NUMBER;

  var_db_id       NUMBER;

  var_instance_no NUMBER;

  noofsnapshot    NUMBER;

  n_count         NUMBER ;

  CURSOR cursor_inst

  IS

    SELECT

      instance_number

    FROM

      gv$instance;

BEGIN

  n_count := 0;

  FOR cur_inst IN cursor_inst

  LOOP

    SELECT

      COUNT(*)

    INTO

      n_count

    FROM

      stats$snapshot

    WHERE

      snap_time        < sysdate-7

    AND instance_number=cur_inst.instance_number;

    IF n_count         > 0 THEN

      SELECT

        MIN(s.snap_id) ,

        MAX(s.snap_id),

        MAX(di.dbid),

        MAX(di.instance_number)

      INTO

        var_lo_snap,

        var_hi_snap,

        var_db_id,

        var_instance_no

      FROM

        stats$snapshot s ,

        stats$database_instance di

      WHERE

        s.dbid              = di.dbid

      AND s.instance_number = di.instance_number

      AND di.startup_time   = s.startup_time

      AND s.instance_number = cur_inst.instance_number

      AND s.snap_time       < sysdate-7;

      noofsnapshot         := statspack.purge( i_begin_snap => var_lo_snap ,

      i_end_snap => var_hi_snap , i_snap_range => true , i_extended_purge =>

      true , i_dbid => var_db_id , i_instance_number => var_instance_no);

      dbms_output.Put_line('snapshot deleted'||TO_CHAR(noofsnapshot));

    END IF;

  END LOOP;

END;


E o job abaixo para executar o processo de limpeza diariamente. 


declare

  my_job number;

begin

  dbms_job.submit(job => my_job,

    what => 'statspackpurge;',

    next_date => trunc(sysdate)+1,

    interval => 'trunc(sysdate)+1');

end;

/

Para conferir se os jobs estão criados e agendados, executamos este select:

set lines 190

set pages 200

col WHAT for a50

col SCHEMA_USER for a15

select job,SCHEMA_USER,WHAT,NEXT_DATE,NEXT_SEC from dba_jobs where SCHEMA_USER = 'PERFSTAT';





Alteração da senha de administrador no Zabbix.



É ideal que sempre que realizamos alguma instalação, anotarmos todos os acessos e mantermos tudo documentado, porém muitas pessoas acabam esquecendo usuários e senhas de acesso, principalmente quando se trata, por exemplo, de um ambiente de teste.

Ao tentar acessar a console do Zabbix podemos nos deparar com esta mensagem




Para efetuarmos a alteração, vamos precisar acessar o banco de dados do Zabbix no Zabbix Server. Estou utilizando neste exemplo o Debin com banco MariaDB.

Ao acessar o servidor, vamos utilizar o comando mysql -u root -p e informar a senha de acesso.



Agora conectamos no banco de dados do Zabbix utilizando o comando use zabbix; caso queira conferir o nome da database pode utilizar o comando show database; para mostrar todas as databases.



Agora executamos o seguinte comando para atualizar a senha.

UPDATE users SET passwd=md5('1234') where alias='Admin';

Note que estou alterando a senha para '1234' para o usuário 'Admin'.



Agora é possível acessar novamente a console do Zabbix com a nova senha.

Importando uma tabela no Oracle com IMPDP.



No último post, aprendemos a realizar um export de uma tabela especifica do banco de dados Oracle, hoje vamos realizar o processo de import desta tabela utilizando o IMPDP.


Antes de prosseguir, sugiro a leitura da publicação anterior:

 https://operacionalti.blogspot.com/2019/03/efetuando-backup-de-uma-tabela-no.html


Vamos realizar o import da tabela que foi exportada anteriormente, será efetuado o import para o mesmo banco, na mesma tabela, sendo assim todos os dados alterados após o export serão perdidos.

impdp mateus/2301@ORCL DIRECTORY=DATA_PUMP_DIR DUMPFILE=ORCL.TABLECLIENTE.dmp TABLE_EXISTS_ACTION=REPLACE REMAP_TABLESPACE=USERS:SYSTEM LOGFILE=ORCL.TABLECLIENTEIMP.log

A sintaxe é muito parecida com a do expdp, vamos informar o usuário e senha que ira conectar no banco para importar a tabela e em DIRECTORY o diretório do datapump no banco.

Em DUMPFILE iremos informar o arquivo onde foi efetuado o expdp, neste caso ORCL.TABLECLIENTE.dmp.

Como vamos efetuar um import onde vou sobrescrever os dados da tabela iremos utilizar o parâmetro TABLE_EXISTS_ACTION=REPLACE, sendo assim, se a tabela existir sera substituido os dados contidos nela.

Utilizamos o REMAP_TABLESPACE para remapear todos os objetos selecionados para importação da tablespace origem para a tablespace destino.


Efetuando backup de uma tabela no Oracle utilizando EXPDP.



Em algum momento podemos nos deparar com a necessidade de fazer backup de uma tabela especifica no banco, podemos fazer isso utilizando o EXPDP, vejamos abaixo.

Para efetuar o backup de uma tabela vamos executar o seguinte script:



expdp USERID=mateus/2301@ORCL DIRECTORY=DATA_PUMP_DIR FLASHBACK_SCN=1455644 VERSION=11.2 TABLES='USER01'.'CLIENTE' DUMPFILE=ORCL.TABLECLIENTE.dmp LOGFILE=ORCL.TABLECLIENTE.log


No USERID vamos informar um usuário que ira conectar no banco para efetuar o backup, em seguida informamos após o @ o nome da base que será conectada.

Para saber o local e o nome do diretório do datapump no banco podemos executar o comando abaixo.

SELECT * FROM DBA_DIRECTORIES WHERE DIRECTORY_NAME LIKE '%PUMP%';



Caso você não possua um diretorio setado o mesmo pode ser criado.

CREATE DIRECTORY DATA_PUMP_DIR AS '/u01/app/oracle/admin/orcl/dpdump/';

Podemos capturar o FLASHBACK_SCN executando o seguinte comando.

SELECT TRIM(TO_CHAR(CURRENT_SCN)) FROM V$DATABASE;




Em VERSION informamos a versão do banco, executamos o comando abaixo para conseguir essa informação.

SELECT BANNER FROM V$VERSION;


Em TABLES vamos informar o owner da tabela e a tabela que queremos copiar.

Em DUMPFILE informamos o caminho em que o backup será gerado e em LOGFILE onde o log do backup será gerado.

Após ter capturado todas estas informações, basta montar como no script apresentado no inicio do post. Executando vamos ter o backup da tabela que foi especificada, caso ocorra algum problema, pode ser verificado no log gerado.

Veremos na próxima postagem como podemos recuperar a tabela o qual foi efetuado o backup utilizando o IMPDP.

Gerenciamento de usuários no Linux.




Hoje vamos conhecer uma lista de comandos utilizados para gerenciamento de usuários no Linux.

Criar um novo usuário:

useradd operacional

Deletar um usuário:

userdel operacional

Criar usuário e adicionar a um grupo:

useradd operacional -g root

Definir uma senha para o usuário: 

passwd operacional

Remover expiração da conta: 

chage -E -1 operacional

Forçar usuário trocar a senha no próximo login:

chage -d 0 operacional

Mostra arquivos abertos pelo usuário:

lsof operacional

Verificar status do usuário:

passwd -S operacional

Definir que a senha do usuário expira em 30 dias:

passwd -x30 operacional

Efetuar lock de um usuário:

passwd -l operacional

Remover o lock do usuário: 

passwd -u operacional

Modificações podem ser efetuadas com o comando usermod, use usermod --help para mais informações.



Quem está logado no momento:

who 

Detalhes dos usuários logados:

who -a 

Histórico de login:

last

Usuários que tentaram logar mas não tiveram sucesso:

last b 

Mostra quando cada usuário no sistema fez login pela última vez:

lastlog 

Esses são alguns comandos utilizados no dia a dia para gerenciamento de usuário, em breve veremos mais sobre controle e permissões de usuários. 

Criando partições no Linux usando o fdisk.



Quando nos deparamos em uma situação em que não possuímos mais espaço para armazenar arquivos nas partições disponíveis, existe a necessidade de adicionar uma nova partição, vamos entender como podemos fazer isso.

Para listar os discos disponíveis, utilizamos o comandos fdisk -l.

Disk /dev/sdc: 20 GiB, 21474836480 bytes, 41943040 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 39F7EB04-5318-429F-A6BC-70BF292DDBC2

Device       Start     End Sectors Size Type
/dev/sdc1     2048 4196351 4194304   2G Linux filesystem
/dev/sdc2  4196352 8390655 4194304   2G Linux filesystem

Ao realizar o comando, encontrei o disco /dev/sdc que possui 20GB, onde podemos criar uma nova partição, vamos efetuar a criação da partição /dev/sdc3.

Para acessar as configurações deste disco utilizamos fdisk /dev/sdc.



Ao digitar m é listado todos os comandos que podemos utilizar no fdisk, vamos utilizar o comando n para criar uma nova partição.



Em partition number vamos informar o número da partição, como já existem duas partições, como default foi selecionada a partição três.

Em first sector vamos informar o primeiro setor do disco e em last sector o último, podemos definir desta forma o tamanho que sera utilizado para partição, deixando como default ele utilizara o primeiro setor e o último disponivel. Desta forma foi criada a partição 3 com 16GB.

Utilizando o comando p será listadas as partições deste disco, agora incluindo a partição 3. 

Disk /dev/sdc: 20 GiB, 21474836480 bytes, 41943040 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 39F7EB04-5318-429F-A6BC-70BF292DDBC2

Device       Start      End  Sectors Size Type
/dev/sdc1     2048  4196351  4194304   2G Linux filesystem
/dev/sdc2  4196352  8390655  4194304   2G Linux filesystem
/dev/sdc3  8390656 41943006 33552351  16G Linux filesystem

Para sair e salvas as alterações efetuadas basta utilizar o comando w, agora vamos formatar a partição no formato ext4. 

root@linux:/# mkfs -t ext4 /dev/sdc3


Você pode escolher o nome da partição que será montada, basta criar no / utilizando o comando mkdir.

root@linux:/# mkdir files
root@linux:/# mount /dev/sdc3 /files

O comando mount é usado para montar a partição dessa forma utilizando mount nome do disco e nome do diretório.
Com df -h listaremos as partições.

root@linux:/# df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1       7,3G  4,8G  2,1G  70% /
/dev/sdc3        16G   44M   15G   1% /files


Sugiro explorar o fdisk e criar novas partições, estas abaixo são comuns no Linux:

/home
/var
/tmp
/boot
/usr

Movimentar Datafiles no Oracle com a Tablespace Offline.



Existem situações em que é necessário efetuar movimentação de datafiles para liberar espaço em uma partição que esta prestes a chegar ao limite, ou até mesmo para distribuir o consumo entre as partições disponíveis no servidor.

Ao efetuar a movimentação de um datafile nenhuma alteração pode ocorrer neste, sendo assim podemos baixar o banco de dados para movimentar ou baixar a tablespace a qual este datafile pertence.

Primeiro, vamos identificar o datafile que iremos mover, neste exemplo vou efetuar a movimentação do datafile tbd_dados2.dbf da partição /u01 para partição /u02.


Antes de efetuar a movimentação, vamos identificar a qual tablespace este datafile pertence, utilizando o script abaixo:

set lines 120;
col file_name format a60
col tablespace_name format a20
SELECT file_name, tablespace_name, ROUND(bytes/1024000) MB FROM dba_data_files where file_name LIKE '%tbd_dados2.dbf%' ORDER BY 1;

Podemos ver que este datafile pertence a tablespace TBS_DADOS;




Vamos alterar agora a tablespace para offline

alter tablespace TBS_DADOS offline;

Em seguida realizar a cópia pelo S.O.

cp /u01/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf /u02/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf

Atualizamos agora o novo local do datafile no banco;

alter database rename file '/u01/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf' to '/u02/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf';

Depois de alterado no banco de dados, colocaremos a tablespace online novamente.

alter tablespace TBS_DADOS online;

Agora podemos apagar no S.O o datafile que da partição /u01.

rm -f /u01/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf


De forma simples efetuamos a movimentação de um datafile entre partições sem a necessidade de baixar o banco de dados.

Fonte: "https://docs.oracle.com/cd/B28359_01/server.111/b28310/dfiles005.htm#ADMIN11430"

Manutenção de logs e traces com ADRCI



É comum encontrar consumo excessivo de disco por conta de alta geração de traces e logs de erros no ambiente Oracle.

O ADRCI  é um repositório baseado em arquivos para dados de diagnóstico de banco de dados, tais como traces, dumps, o alert log, health monitor reports, etc.

Por padrão podemos iniciar o ADRCI acessando $ORACLE_HOME/bin e utilizando o comando ./adrci ou se as variáveis já são exportadas automaticamente ao acessar o usuário oracle, basta somente digitar adrci.





Digitando o comando show homes será apresentado todos os homes do ADR .

ADR Homes:
diag/rdbms/orcl/orcl
diag/tnslsnr/localhost/listener
diag/tnslsnr/SRVORCL/listener

Sabemos agora que estes são os diretórios onde os arquivos que queremos aplicar a retenção se encontram.

Vamos agora utilizar um script para definir a politica de retenção e excluir os arquivos: 

set HOME diag/rdbms/orcl/orcl
set control (SHORTP_POLICY = 240);
set control (LONGP_POLICY = 240);
purge -age 10080 -type ALERT
purge -age 10080 -type TRACE
purge -age 10080 -type incident
purge -age 10080 -type hm
purge -age 10080 -type utscdmp
purge -age 10080 -type cdump

Dentro do set HOME vamos definir os diretórios que foram informado em resultado ao comando show homes. 

SHORTP_POLICY é parâmetro responsável pela retenção dos arquivos de traces e o LONGP_POLICY pela retenção dos arquivos de incidentes. Os valores são definidos em horas.

O purge ira efetuar a a exclusão dos arquivos, os valores nele são definidos em minutos. 



Aprendemos hoje a realizar a retenção de arquivos de logs e traces utilizando o ADRCI, podemos utilizar esta ferramenta para gerenciar os dados de diagnósticos armazenados, vamos abordar mais sobre a ferramenta em breve.

Fonte: https://www.oracle.com/technetwork/pt/articles/database-performance/automatic-diagnostic-repository-2417674-ptb.html

Adição de Datafiles no banco de dados Oracle.


Os datafiles são estruturas físicas do banco, que estão ligados a uma unidade lógica chamada de tablespace. O crescimento dos datafiles pode ser limitado e controlado dentro do banco.

Para listar todas as tablespaces contidas no banco de dados utilizamos o seguinte script: 

set lines 158
set pages 100
column "Tablespace" format A20
column "Usado" format '9,999,990.00'
column "Livre" format '9,999,990.00'
column "Expansivel" format A12
column "Total" format '9,999,990.00'
column "Usado %" format '990.00'
column "Livre %" format '990.00'
column "Tipo Ger." format A12
select t.tablespace_name "Tablespace",
       round(ar.usado, 2) "Usado",
       round(decode(NVL2(cresc.tablespace, 0, sign(ar.Expansivel)),
                    1,
                    (ar.livre + ar.expansivel),
                    ar.livre),
             2) "Livre",
       round(ar.alocado,2) "Alocado Mb",
       NVL2(cresc.limite, 'ILIMITADO', round(ar.expansivel, 2)) "Expansivel",
       round(decode(NVL2(cresc.tablespace, 0, sign(ar.Expansivel)),
                    1,
                    ar.usado / (ar.total + ar.expansivel),
                    (ar.usado / ar.total)) * 100,
             2) "Usado %",
       round(decode(NVL2(cresc.tablespace, 0, sign(ar.Expansivel)),
                    1,
                    (ar.livre + ar.expansivel) / (ar.total + ar.expansivel),
                    (ar.livre / ar.total)) * 100,
             2) "Livre %",
       round(decode(NVL2(cresc.tablespace, 0, sign(ar.Expansivel)),
                    1,
                    (ar.total + ar.expansivel),
                    ar.total),
             2) "Total",
       t.Contents "Conteudo",
       t.Extent_Management "Tipo Ger.",
       FORCE_LOGGING
  from dba_tablespaces t,
       (select df.tablespace_name tablespace,
               sum(nvl(df.user_bytes,0))/1024/1024 Alocado,
               (sum(df.bytes) - sum(NVL(df_fs.bytes, 0))) / 1024 / 1024 Usado,
               sum(NVL(df_fs.bytes, 0)) / 1024 / 1024 Livre,
               sum(decode(df.autoextensible,
                          'YES',
                          decode(sign(df.maxbytes - df.bytes),
                                 1,
                                 df.maxbytes - df.bytes,
                                 0),
                          0)) / 1024 / 1024 Expansivel,
               sum(df.bytes) / 1024 / 1024 Total
          from dba_data_files df,
               (select tablespace_name, file_id, sum(bytes) bytes
                  from dba_free_space
                 group by tablespace_name, file_id) df_fs
         where df.tablespace_name = df_fs.tablespace_name(+)
           and df.file_id = df_fs.file_id(+)
         group by df.tablespace_name
        union
        select tf.tablespace_name tablespace,
               sum(nvl(tf.user_bytes,0))/1024/1024 Alocado,        
               sum(tf_fs.bytes_used) / 1024 / 1024 Usado,
               sum(tf_fs.bytes_free) / 1024 / 1024 Livre,
               sum(decode(tf.autoextensible,
                          'YES',
                          decode(sign(tf.maxbytes - tf.bytes),
                                 1,
                                 tf.maxbytes - tf.bytes,
                                 0),
                          0)) / 1024 / 1024 Expansivel,
               sum(tf.bytes) / 1024 / 1024 Total
          from dba_temp_files tf, V$TEMP_SPACE_HEADER tf_fs
         where tf.tablespace_name = tf_fs.tablespace_name
           and tf.file_id = tf_fs.file_id
         group by tf.tablespace_name) ar,
       (select df.tablespace_name tablespace, 'ILIMITADO' limite
          from dba_data_files df
         where df.maxbytes / 1024 / 1024 / 1024 > 30
           and df.autoextensible = 'YES'
         group by df.tablespace_name
        union
        select tf.tablespace_name tablespace, 'ILIMITADO' limite
          from dba_temp_files tf
         where tf.maxbytes / 1024 / 1024 / 1024 > 30
           and tf.autoextensible = 'YES'
         group by tf.tablespace_name) cresc
where cresc.tablespace(+) = t.tablespace_name
   and ar.tablespace(+) = t.tablespace_name
order by 1 

 /


Após a execução obtive o seguinte resultado: 




Vamos utilizar como exemplo a tablespace "TBS_DADOS". Para verificar os datafiles ligados a está tablespace executaremos o script abaixo: 

set pages 200
set lines 200
col file_name for a70
select file_name, maxbytes/1024/1024 as maxbytes, bytes/1024/1024 as bytes, autoextensible 
from dba_data_files
where tablespace_name='TBS_DADOS'

order by FILE_NAME;



Conforme retorno do script, temos somente um datafile ligado a tablespace TBS_DADOS, este datafile está localizado em /u01/app/oracle/oradata/ORCL/datafile/tbd_dados.dbf e possui 100 megabytes, podendo se estender até 200 megabytes.

Agora iremos adicionar mais um datafile seguindo os padrões do datafile anterior. É importante validar se o disco possui espaço suficiente para alocar o novo datafile.


alter tablespace TBS_DADOS add datafile '/u01/app/oracle/oradata/ORCL/datafile/tbd_dados2.dbf ' size 100m autoextend on next 100m maxsize 200m;


Se executarmos novamente o script para verificação dos datafiles, podemos validar que o novo datafile já se encontra na tablespace:



Vimos de forma bem simples, como podemos adicionar um datafile a uma tablespace, é importante efetuar este procedimento com muita atenção, pois após adicionado para realizar alterações no datafile pode exigir a parada do banco de dados, abordaremos mais sobre datafiles e tablespace nas próximas postagens.


Fonte: https://docs.oracle.com/cd/B19306_01/server.102/b14220/physical.htm

Recentes

O Blog

Bem vindo ao blog AvizDBA

Criei o blog com intuito de ajudar a todos, compartilhando minha experiência, casos do dia a dia e algumas dicas.

Espero que aproveite os posts e fique a vontade para deixar um comentário caso tenha algum dúvida ou sugestão.

Certificações