Bom, eu bem sei que não ando postando novos artigos por aqui. Mas, enquanto os longos artigos não voltam, vamos mexendo numa coisa aqui e outra ali. Dei uma boa melhorada na galeria de imagens:

[Show as slideshow]

[View with PicLens]

Agora resolvi brincar com as enquetes. Não sei se vai vingar. Depende mesmo do número de pessoas que vão votar. Se tiver um número razoável, prometo ir atualizando por aqui.

Segue a primeira, que não poderia ser muito diferente. Em breve, algumas mais polêmicas devem se seguir. Aguardo os votos do pessoal.

 Loading ...

Sim, após a brincadeira infame de 1º de abril que postei aqui sobre a compra do MySQL… não é que vem a Oracle e faz uma oferta pela Sun? As coisas parecem que não andam muito bem para a gigante IBM. No ano passado a HP comprou a EDS por 14 BI esquentando a concorrência no setor de serviços, e agora é a Oracle que compra a Sun pela ninharia de 7BI. Para se ter uma idéia de como isso é pouco, a Oracle pagou no começo do ano passado 8,5 BI pela BEA e a Sun pagou 1 BI pela MySQL AB. Em tempos de crise quem tem dinheiro em caixa é rei…

E assim como o Yahoo se negou a ser comprado pela Microsoft (por cifras astronômicas em tempos pré crise), a Sun parece ter não gostado muito da oferta da IBM e aceitou uma oferta ligeiramente superior da Oracle. E zilhões de dúvidas vem a cabeça. E agora o que serão dos projetos livres da Sun? Java, OpenOfficce, MySQL, Solaris e por aí vai. Ninguém sabe… mas a primeira coisa que percebemos é que o mercado corporativo de TI vai se afunilando entre gigantes como IBM, Microsoft, HP, Dell e Oracle. Mas seria bom dar uma olhada na Oracle um pouco mais de perto.

• A Oracle surgiu como um dos primeiros SGDBs relacionais do mercado, logo depois do DB2 da IBM. Se é verdade que o DB2 ainda dita a maior parte do padrão ISO SQL, a Oracle já lidera claramente este mercado há alguns anos;
• Se é verdade que até a década de 90 a Oracle se firmou no mercado como desenvolvedora do maior banco de dados do mercado, também é verdade que ela virou a mesa e tem hoje uma suite completa de soluções de grande porte:
  • SO com o clone o Red Hat, o Unbreakable Linux,
  • Banco de dados com o Oracle Database, e também o InnoDB,  o Berkeley DB, Times Ten
  • Middleware com o Oracle Application Server, SOA Suite, Weblogic, Content Management, etc;
  • ERP com o JD Edwards, People Soft, Siebel, E-Business Suite, etc;
  • Monitoramento com o Oracle Enterprise Manager;
• Se por um lado a Oracle tem uma política de licenciamento que lhe cobra por uma base de testes, um stand by e possui inúmeras funcionalidades e parâmetros não documentados nos seus produtos, oferece o download livre para qualquer um baixar e testar seus produtos e uma enorme biblioteca de documentação pronta para baixar e imprimir, em versão PDF ou HTML.
• Sim, a Oracle investe em Software Livre sim. Tem inclusive um portal para isso, o http://oss.oracle.com/ com projetos como o OCFS2 e o Btrfs, dois poderosos sistemas de arquivos. Além disso, a Oracle tem uma contribuição intensa no kernel do Linux já faz um bom tempo.
• Sim, a Oracle tem uma política monopolista e compra tudo que está a sua frente. Mas ao contrário de querer dominar a Internet, como a Microsoft e o Google, o foco da Oracle é bem claro: soluções corporativas para grandes empresas. E diga-se de passagem, ela tem crecido numa velocidade incrível neste segmento. Porém, se a excelência de suas soluções em banco de dados deram uma fama de competência e confiabilidade em seus produtos, o mesmo não se pode dizer sobre as suas demais aplicações que rodam sobre o seu banco de dados. O Oracle Aplication Server é uma colcha de tecnologias livres empacotadas como um monstro de várias patas e nenhum cérebro. E vai a Oracle já avisando que depois de abandonar o terrível Forms e Reports, vai abandonar o fiasco do OAS também em função de uma plataforma Java melhor… é esperar para ver. Os seus ERPs também não são a oitava maravilha em termos de tecnologia (ALGUM É)???? O PeopleSoft por exemplo não tem uma única chave estrangeira no banco de dados, fazendo toda a integridade referencial dentro da aplicação. Não é bem o que a Oracle sempre pregou nos seus manuais.
• O suporte da Oracle é muito eficiente, funciona 24/7 de verdade. Podem lhe atender no Brasil, EUA, Japão, Índia ou onde quer que seja necessário para atendê-lo em qualquer horário. Mas veja: o nível básico de suporte (independente no nome bonito que se dê)  por e-mail, dá um trabalhão para abrir um chamado. Uma das coisas mais irritantes no site de suporte da Oracle é que eles utilizam tecnologia da Oracle para montar o portal web. É horrível, quem está acostumado com o Gmail e outras interfaces cheias de Ajax como o WordPress sabe o quão terrível é o metalink da Oracle. Fizeram uma versão nova com uso de Flash… piorou!

Então se por um lado a Oracle tem tradição com Software Livre, não tem foco em produtos na linha do MySQL e do OpenOffice. É claro que se é para minar a concorrência com a Microsoft pelo mercado de médio porte, pode não ser má idéia investir um pouco neles, mas não acredito que será o foco principal deles. É claro que podem surgir estratégias inovadoras junto ao MySQL… ele pode se tornar mais aberto ao Oracle e virar um novo Times Ten, mas não acho que vai perdes suas características atuais. Manter o Marketshare do MySQL, apesar de não trazer muito lucro será muito bom para a Oracle que pegará duas pontas do mercado. Já o Solaris o Java são com certeza algo de interesse por parte da Oracle. Veja que o Btrfs que a Oracle criou é baseado no ZFS que por problemas de licenças da Sun, não pode ser agregado ao Linux que usa GPL. Daí se vê a preocupação da Oracle com algumas boas tecnologias encontradas no Solaris. O Java então… toda a suite que roda sobre os bancos de dados Oracle usa Java. Isso sim é um tiro certeiro. Já os servidores SPARC são bons competidores para os servidores da HP e IBM. São caros, mas tem um mercado cativo ainda bem definido em soluções de grande e médio porte.

Mas temos um perdedor claro aqui: o PostgreSQL que vinha sido apoiado pela Sun está certamente fadado a perder esta condição. É claro que existem outras e muitas outras empresas apoiando. Mas a ausência da Sun será sentida, com certeza.

OBS: O artigo do Peter Eisentraut é bem interessante. Acho que concordo com quase tudo que ele diz. Vale a pena dar uma olhada lá.

Ontem fui no mega evento da Oracle Open World. Sim, a empresa onde eu trablaho pagou a minha inscrição. E não é qualquer um que pode bancar cerca de R$1500 para entrar num evento desses. É claro que a Oracle e os patrocinadores do evento distribuem muitos convites para seus clientes. Foi assim que eu consegui entrar em outros eventos da Oracle ou mesmo no Linux World que ocorreu por aqui em 2006. Em suma, eventos corporativos são caros e são para poucos.

Isto já era notável na diferença entre a FENASOFT e a CONDEX na década de 90. Menos gente é sinônimo de platéia mais selecionada e mais Whiskey nos estandes. De qualquer forma, o recém adquirido hábito de utilizar gravata parece ter me beneficiado ontem.

Apesar de ter encontrado alguns conhecidos, foi sozinho que eu consegui aproveitar mais o evento. Só pude ir em um dia, cheguei cedo, saí tarde, assisti palestras e passei um bom tempo nos estandes conversando com o pessoal. Já que estão pagando para mim, melhor aproveitar ao máximo.

Os estandes estavam distribuidos mais ou menos assim:

• Grandes marcas como IBM, SUN, HP e Dell
• Prestadores de serviço como DBAs
• Consultorias para implantar sistemas ERP, CRM, etc;
• Fornecedores de soluções que rodam em ambiente oracle (banco de dados, servidor de aplicação, etc);

Bom a primeira coisa notável é que não haviam estandes enormes. A SUN e a HP estavam quase escondidas e stands modestos, por exemplo. A segunda coisa é que se Oracle era sinônimo de banco de dados para você, esqueça. O banco de dados é apenas a ponta do iceberg na cadeia de produtos e serviços da Oracle. A Oracle tem se notabilizado por uma agressiva estratégia de aquisição de empresas e tem soluções de todo tipo: SGDB, ERP, BI, SO, CRM, SOA e mais uma tonelada de letrinhas e buzzwords. E o banco de dados é apenas uma dentre os vários produtos e isto tinha reflexo também na ocupação da grade do evento do espaço de exposições dos estandes. Sobre os diversos produtos e camadas que a Oracle tem para rodar, acima do banco de dados eu só tenho uma coisa a dizer: eu gostaria muito delas se elas seguissem as recomendações da própria Oracle nas suas documentações.

Bom, fora isso vi algumas coisas bacanas. Algumas coisas que me chamaram a atenção:

• Palestra sobre backup/recovery mostrando inclusive o novo assistente para recuperação de desastres. Nota: cada vez mais eles querem empurrar o ASM e o RMAN. Eu sei que estas tecnologias são interessantes, mas são todas no estilo ame-o ou deixe-o.
• O Oracle TimesTen é uma tecnologia muito interessante, que mostra como a Oracle consegue ser inteligente e por isso mesmo cruél. A tecnologia funciona como um banco que guarda tabelas de um banco tradicional em memória e fica como uma camada na frente aceitando consultas da aplicação. Muito rápida a solução, aceita SQL92 e funciona com vários fornecedores de SGDB. A Oracle comprou a empresa que desenvolveu isso. Agora o TimesTen é orientado apenas para o SGDB da Oracle, custa muito mais caro do que antes e só funciona com a versão Enterprise. É mole?
• A HP e a Oracle mostraram um rack 44U com várias gavetas de storage, 4 servidores em RAC ligados por vários canais Infiniband. A novidade era um software da Oracle que filtrava os dados pelos  predicados (leia-se aqui como clausula WHERE ) da consulta em nível de hardware, diminuindo o fluxo de dados. Um monstrinho otimizado para BI. O detalhe é que o software da Oracle só funciona com aqueles discos, aquelas controladoras, aqueles switches infiniband, aqueles servidores HP e montados naquele rack.

Depois disso eles ainda chamam isso de Open World?

Em tempo, fui olhar um poco das tecnologias de Storage por lá… algumas novidades na área sim. Mas isto fica para outro dia.

Bom, todo DBA que se prese deve acompanhar o crescimento da base conforme o tempo. Prever o espaço em disco necessário nos próximos meses, saber qual época ocorre maior crescimento da base. Acompanhar de perto objetos críticos que ocupam mais espeço, etc. É claro que a própria Oracle e outros fornecedores possuem ferramentas bastente sofisticadas para fazer algumas destas coisas. É bem verdade que boa parte delas faz em maior ou menor grau algo bem semelhante ao que vou mostrar adiante. No entanto, eu gosto da minha solução, pois eu consigo entendê-la facilmente e modificar para necessidades específicas. No mínimo é um bom exercício de aprendizado.

Vejamos alguns requisitos que eu montei:

• Ser compatível com pelo menos o Oracle 8 em diante;
• Armazenar todas informações num tablespace separado, para que a coleta de dados não influencie nos demais tablespaces;
• Utilizar um esquema separado para a criação de todos os objetos envolvidos. O usuário em questão deverá ser bloqueado e ter o mínimo de privilégios necessários;
• Criar uma tabela para registrar a data de duração no disparo de cada script e outra para os erros que por ventura venham a ocorrer;
• Coletar as seguintes informações com as respectivas periodicidades:
  • Dados sobre o tamanho dos tablespaces uma vez por mês;
  • Dados sobre a quantidade e tipo de objetos por esquema uma vez por dia, atualizando apenas as mudanças ocorridas;
  • Nome dos objetos inválidos auma vez por dia, atualizando apenas as mudanças ocorridas;
  • Tamanhode objetos que ocupem mais de 64MB ou tenham mais de 50 extents ou mais de um milhão de registros uma vez por semana, atualizando apenas as mudanças ocorridas;

Objetos

CREATE TABLESPACE 'DBA_LOG_DADOS'
  DATAFILE '/u01/oradata/nome_da_base/dba_log_dados_01.dbf'
  SIZE 100M LOGGING EXTENT MANAGEMENT LOCAL SEGMENT SPACE MANAGEMENT AUTO;
 
CREATE USER dba_log IDENTIFIED BY dba
    DEFAULT TABLESPACE dba_log_dados
    QUOTA UNLIMITED ON dba_log_dados
    ACCOUNT LOCK;
 
GRANT CREATE PROCEDURE TO dba_log;
GRANT CREATE TABLE TO dba_log;
 
-- Executar como SYSDBA
GRANT SELECT ON dba_objects TO dba_log;
GRANT SELECT ON dba_segments TO dba_log;
GRANT SELECT ON dba_data_files TO dba_log;
GRANT SELECT ON dba_free_space TO dba_log;
GRANT SELECT ON dba_tables TO dba_log;
 
CREATE SEQUENCE dba_log.log_seq;
 
CREATE TABLE dba_log.log(
    id_log      number(10),
    rotina      varchar2(100),
    usuario     varchar2(30) DEFAULT USER,
    inicio      date DEFAULT SYSDATE,
    fim         date,
    CONSTRAINT  log_pk PRIMARY KEY(id_log)
);
 
CREATE TABLE dba_log.erros (
    id_log      number(10),
    cod_erro    number(10),
    mensagem     varchar2(64),
    DATA        TIMESTAMP DEFAULT SYSTIMESTAMP
);
 
CREATE TABLE dba_log.tablespace (
    nome        varchar2(30),
    maximo      number(8) NOT NULL,
    alocado     number(8) NOT NULL,
    utilizado   number(8) NOT NULL,
    livre       number(8) NOT NULL,
    DATA        date DEFAULT SYSDATE,
    CONSTRAINT tablespaces_pk PRIMARY KEY (nome,DATA)
);
 
CREATE OR REPLACE PROCEDURE dba_log.tablespace_load AS
  v_log_seq number(10);
  v_code number(10);
  v_errm varchar2(64);
BEGIN
 
  SELECT dba_log.log_seq.NEXTVAL INTO v_log_seq FROM dual;
  INSERT INTO dba_log.log (id_log, rotina) VALUES (v_log_seq,'tablespace_load');
 
  INSERT INTO dba_log.tablespace (nome, maximo, alocado, utilizado, livre)
    SELECT
      u.tablespace_name,
      m.maximo,
      m.alocado,
      u.utilizado,
      l.livre
      FROM
        (SELECT tablespace_name, CEIL (SUM (bytes) / 1048576) utilizado
           FROM dba_segments
           GROUP BY tablespace_name) u,
        (SELECT
           tablespace_name,
           CEIL (SUM (bytes) / 1048576) alocado,
           CEIL (SUM (DECODE (autoextensible, 'NO', bytes, maxbytes)) / 1048576) maximo
           FROM dba_data_files
           GROUP BY tablespace_name) m,
        (SELECT
           tablespace_name,
           CEIL (SUM (bytes) / 1048576) livre
           FROM dba_free_space
           GROUP BY tablespace_name) l
      WHERE
        l.tablespace_name = u.tablespace_name AND
        l.tablespace_name = m.tablespace_name
    ;
  UPDATE dba_log.log SET fim = SYSDATE WHERE id_log = v_log_seq;
  COMMIT;
 
  EXCEPTION
    WHEN OTHERS THEN
      v_code := SQLCODE;
      v_errm := SUBSTR(SQLERRM, 1 , 64);
      INSERT INTO dba_log.erros (id_log, cod_erro, mensagem) VALUES (v_log_seq, v_code, v_errm);
END;
/
 
CREATE TABLE dba_log.objeto_qt (
    tipo        varchar2(19),
    esquema     varchar2(30),
    STATUS      varchar2(7),
    qt          number(5) NOT NULL,
    DATA        date DEFAULT SYSDATE,
    CONSTRAINT objeto_qt_pk PRIMARY KEY (tipo, esquema, STATUS, DATA)
);
 
CREATE OR REPLACE PROCEDURE dba_log.objeto_qt_load AS
  v_log_seq number(10);
  v_code number(10);
  v_errm varchar2(64);
BEGIN
  SELECT dba_log.log_seq.NEXTVAL INTO v_log_seq FROM dual;
  INSERT INTO dba_log.log (id_log, rotina) VALUES (v_log_seq,'objeto_qt_load');
 
  INSERT INTO dba_log.objeto_qt (tipo, esquema, STATUS, qt)
    SELECT b.tipo, b.esquema, b.STATUS, b.qt
      FROM
        (SELECT object_type tipo, owner esquema, STATUS FROM dba_objects
           MINUS
           SELECT tipo, esquema, STATUS FROM dba_log.objeto_qt) a,
        (SELECT object_type tipo, owner esquema, STATUS, count(*) qt
           FROM dba_objects
           GROUP BY owner, object_type, STATUS) b
      WHERE
        a.tipo = b.tipo AND
        a.esquema = b.esquema AND
        a.STATUS = b.STATUS
      ORDER BY esquema, tipo, STATUS
   ;
 
  INSERT INTO dba_log.objeto_qt (tipo, esquema, STATUS, qt)
    SELECT o.tipo, o.esquema, o.STATUS, o.qt
      FROM
        dba_log.objeto_qt q,
        (SELECT object_type tipo, owner esquema, STATUS, count(*) qt
           FROM dba_objects
           GROUP BY owner, object_type, STATUS) o,
        (SELECT tipo, esquema, STATUS, max(DATA) DATA
           FROM dba_log.objeto_qt
           GROUP BY tipo, esquema, STATUS) d
      WHERE
        o.tipo = q.tipo AND
        o.tipo = d.tipo AND
        o.esquema = q.esquema AND
        o.esquema = d.esquema AND
        o.STATUS = q.STATUS AND
        o.STATUS = d.STATUS AND
        q.DATA = d.DATA AND
        o.qt != q.qt
        ORDER BY o.esquema, o.tipo, o.STATUS
  ;
  UPDATE dba_log.log SET fim = SYSDATE WHERE id_log = v_log_seq;
  COMMIT;
 
  EXCEPTION
    WHEN OTHERS THEN
      v_code := SQLCODE;
      v_errm := SUBSTR(SQLERRM, 1 , 64);
      INSERT INTO erros (id_log, cod_erro, mensagem) VALUES (v_log_seq, v_code, v_errm);
END;
/
 
CREATE TABLE dba_log.objeto_invalido (
    tipo        varchar2(19),
    esquema     varchar2(30),
    nome        varchar2(128),
    DATA        date DEFAULT SYSDATE,
    CONSTRAINT objeto_invalido_pk PRIMARY KEY (tipo, esquema, nome, DATA)
);
 
CREATE OR REPLACE PROCEDURE dba_log.objeto_invalido_load AS
  v_log_seq number(10);
  v_code number(10);
  v_errm varchar2(64);
 
BEGIN
  SELECT dba_log.log_seq.NEXTVAL INTO v_log_seq FROM dual;
  INSERT INTO dba_log.log (id_log, rotina) VALUES (v_log_seq,'objeto_invalido_load');
  INSERT INTO dba_log.objeto_invalido (tipo, esquema, nome)
    SELECT object_type tipo, owner esquema, object_name nome
      FROM dba_objects
      WHERE STATUS != 'VALID'
    MINUS
    SELECT tipo, esquema, nome FROM dba_log.objeto_invalido
  ;
  UPDATE dba_log.log SET fim = SYSDATE WHERE id_log = v_log_seq;
  COMMIT;
 
  EXCEPTION
    WHEN OTHERS THEN
      v_code := SQLCODE;
      v_errm := SUBSTR(SQLERRM, 1 , 64);
      INSERT INTO dba_log.erros (id_log, cod_erro, mensagem) VALUES (v_log_seq, v_code, v_errm);
END;
/
 
CREATE TABLE dba_log.objeto_tamanho (
    tipo        varchar2(19),
    tablespace  varchar2(30),
    esquema     varchar2(30),
    nome_part   varchar2(112),
    tamanho     number(8),
    extents     number(5),
    num_reg     number(10),
    DATA        date DEFAULT SYSDATE,
    CONSTRAINT objetos_tamanho_pk PRIMARY KEY (tipo, esquema, nome_part, DATA)
);
 
CREATE OR REPLACE PROCEDURE dba_log.objeto_tamanho_load AS
  v_log_seq number(10);
  v_code number(10);
  v_errm varchar2(64);
 
BEGIN
 
  SELECT dba_log.log_seq.NEXTVAL INTO v_log_seq FROM dual;
  INSERT INTO dba_log.log (id_log, rotina) VALUES (v_log_seq,'objeto_tamanho_load');
 
  INSERT INTO dba_log.objeto_tamanho 
    (tipo, tablespace, esquema, nome_part, tamanho, extents, num_reg)
    SELECT b.tipo, b.tablespace, b.esquema, b.nome_part, b.tamanho, b.extents, b.num_reg
    FROM
      (SELECT
         segment_type tipo,
         owner esquema,
         NVL2(partition_name, segment_name || '/' || partition_name, segment_name) nome_part
         FROM dba_segments
      MINUS
      SELECT tipo, esquema, nome_part FROM dba_log.objeto_tamanho) a,
      (SELECT
        s.segment_type tipo,
        s.tablespace_name tablespace,
        s.owner esquema,
        NVL2(s.partition_name, s.segment_name || '/' || s.partition_name, s.segment_name) nome_part,
        CEIL(s.bytes/1048576) tamanho,
        s.extents,
        t.num_rows num_reg
        FROM
          dba_segments s,
          dba_tables t
       WHERE
         (s.bytes > 67108864 OR s.extents > 50 OR t.num_rows > 1000000) AND
          s.owner = t.owner (+)AND
          s.segment_name = t.table_name (+)) b
    WHERE
      a.tipo = b.tipo AND
      a.esquema = b.esquema AND
      a.nome_part = b.nome_part
  ;    
 
  INSERT INTO dba_log.objeto_tamanho 
    (tipo, tablespace, esquema, nome_part, tamanho, extents, num_reg)
    SELECT o.tipo, o.tablespace, o.esquema, o.nome_part, o.tamanho, o.extents, o.num_reg
      FROM
        dba_log.objeto_tamanho l,
        (SELECT tipo, esquema, nome_part, max(DATA) DATA
          FROM dba_log.objeto_tamanho
          GROUP BY tipo, esquema, nome_part) d,
        (SELECT
          s.segment_type tipo,
          s.tablespace_name tablespace,
          s.owner esquema,
          NVL2(s.partition_name, s.segment_name || '/' || s.partition_name, s.segment_name) nome_part,
          CEIL(s.bytes/1048576) tamanho,
          s.extents,
          t.num_rows num_reg
          FROM
            dba_segments s,
            dba_tables t
          WHERE
            (s.bytes > 67108864 OR s.extents > 50 OR t.num_rows > 1000000) AND
            s.owner = t.owner (+)AND
            s.segment_name = t.table_name (+)) o
      WHERE
        l.tipo = d.tipo AND
        l.tipo = o.tipo AND
        l.esquema = d.esquema AND
        l.esquema = o.esquema AND
        l.nome_part = d.nome_part AND
        l.nome_part = o.nome_part AND
        l.DATA = d.DATA AND
        (o.tamanho != CEIL(l.tamanho) OR l.extents != o.extents OR l.num_reg != o.num_reg)
      ORDER BY o.esquema, o.tablespace, o.tipo DESC
  ;
  UPDATE dba_log.log SET fim = SYSDATE WHERE id_log = v_log_seq;
  COMMIT;
 
  EXCEPTION
    WHEN OTHERS THEN
      v_code := SQLCODE;
      v_errm := SUBSTR(SQLERRM, 1 , 64);
      INSERT INTO dba_log.erros (id_log, cod_erro, mensagem) VALUES (v_log_seq, v_code, v_errm);
END;
/

Agendamento

Se você estiver utilizando o Oracle 10g ou superior, deve preferir usar o SCHEDULER:

BEGIN
 
  DBMS_SCHEDULER.CREATE_WINDOW(
    window_name=>'SYS.MONTH_START_WINDOW',
    resource_plan=>'SYSTEM_PLAN',
    start_date=>SYSTIMESTAMP,
    duration=>numtodsinterval(240, 'minute'),
    repeat_interval=>'FREQ=MONTHLY;BYMONTHDAY=1;BYHOUR=3',
    end_date=>null,
    window_priority=>'LOW',
    comments=>'Start of the month window for maintenance task'
  );
 
  DBMS_SCHEDULER.CREATE_JOB(
    job_name => 'DBA_LOG.TABLESPACE_LOAD_MENSAL',
    job_type => 'STORED_PROCEDURE',
    job_action => 'DBA_LOG.TABLESPACE_LOAD',
    schedule_name => 'SYS.MONTH_START_WINDOW',
    enabled => TRUE
  );
 
  DBMS_SCHEDULER.SET_ATTRIBUTE(
    name => '"DBA_LOG"."TABLESPACE_LOAD_MENSAL"',
    attribute => 'job_priority',
    value => 4
  );
 
  DBMS_SCHEDULER.CREATE_JOB(
    job_name => 'DBA_LOG.OBJETO_TAMANHO_LOAD_SEMANAL',
    job_type => 'STORED_PROCEDURE',
    job_action => 'DBA_LOG.OBJETO_TAMANHO_LOAD',
    schedule_name => 'SYS.WEEKEND_WINDOW',
    enabled => TRUE
  );
 
  DBMS_SCHEDULER.SET_ATTRIBUTE(
    name => 'DBA_LOG.OBJETO_TAMANHO_LOAD_SEMANAL',
    attribute => 'job_priority',
    value => 4
  );
 
  DBMS_SCHEDULER.CREATE_JOB(
    job_name => 'DBA_LOG.OBJETO_INVALIDO_LOAD_DIARIO',
    job_type => 'STORED_PROCEDURE',
    job_action => 'DBA_LOG.OBJETO_INVALIDO_LOAD',
    schedule_name => 'SYS.WEEKNIGHT_WINDOW',
    enabled => TRUE
  );
 
  DBMS_SCHEDULER.SET_ATTRIBUTE(
    name => 'DBA_LOG.OBJETO_INVALIDO_LOAD_DIARIO',
    attribute => 'job_priority',
    value => 4
  );
 
  DBMS_SCHEDULER.CREATE_JOB(
    job_name => 'DBA_LOG.OBJETO_QT_LOAD_DIARIO',
    job_type => 'STORED_PROCEDURE',
    job_action => 'DBA_LOG.OBJETO_QT_LOAD',
    schedule_name => 'SYS.WEEKNIGHT_WINDOW',
    enabled => TRUE
  );
 
  DBMS_SCHEDULER.SET_ATTRIBUTE(
    name => 'DBA_LOG.OBJETO_QT_LOAD_DIARIO',
    attribute => 'job_priority',
    value => 4
  );
 
END;
/

Se estiver utilizando o Oracle 9i ou inferiro, terá que utilizar os JOBs para agendar a coleta de dados:

VARIABLE jobno NUMBER;
BEGIN
  DBMS_JOB.SUBMIT(:jobno, 'BEGIN DBA_LOG.OBJETO_QT_LOAD; END;',
    TRUNC(SYSDATE) + 1/24, 'TRUNC(SYSDATE) + 1/24 + 30');
  COMMIT;
END;
/
 
VARIABLE jobno NUMBER;
BEGIN
  DBMS_JOB.SUBMIT(:jobno, 'BEGIN DBA_LOG.TABLESPACE_LOAD; END;',
    TRUNC(SYSDATE) + 1/24, 'TRUNC(SYSDATE + 30,''MONTH'') + 1/24');
  COMMIT;
END;
/
 
VARIABLE jobno NUMBER;
BEGIN
  DBMS_JOB.SUBMIT(:jobno, 'BEGIN DBA_LOG.OBJETO_TAMANHO_LOAD; END;',
    TRUNC(SYSDATE) + 1/24, 'NEXT_DAY(TRUNC(SYSDATE), ''SATURDAY'') + 1/24');
  COMMIT;
END;
/
 
VARIABLE jobno NUMBER;
BEGIN
  DBMS_JOB.SUBMIT(:jobno, 'BEGIN DBA_LOG.OBJETO_INVALIDO_LOAD; END;',
    TRUNC(SYSDATE) + 1/24, 'TRUNC(SYSDATE) + 25/24');
  COMMIT;
END;
/
 
VARIABLE jobno NUMBER;
BEGIN
  DBMS_JOB.SUBMIT(:jobno, 'BEGIN DBA_LOG.OBJETO_QT_LOAD; END;',
    TRUNC(SYSDATE) + 1/24, 'TRUNC(SYSDATE) + 25/24');
  COMMIT;
END;
/

Conclusão

Com os dados coletados nas tabelas, você só precisa agora exercitar um pouco do seu conhecimento de SQL para fazer consultas criativas e gerar relatórios dos mais diversos e entregar para o seu chefe no final do ano. Não, adianta nada criar os objetos agora e tentar fazer mágica. Após um anos, você poderá observar com alguma precisão a sazonalidade das aplicações e fazer boas projeções. Que tal começar o ano com um mínimo de coleta de dados na sua base? Quando a turma do ITIL bater na sua porta, algumas coisas já estarão encaminhadas para o seu lado.

É muito comum ter várias aplicações numa única base do Oracle organizadas por esquemas. Se for este o seu caso, você se verá com alguma frequência para migrar um esquema inteiro da base de produção para homologação, do teste para homologação e por aí vai. Exportar os objetos e importar é muito simples, tanto com utilizando o IMP e EXP comuns até a versão 9i como com o Data Pump no 10g em diante:

Com o imp e exp:

exp usuario@nome_base_origem file=dump_esquema.dmp owner=nome_esquema
imp usuario@nome_base_destino file=dump_esquema.dmp fromuser=nome_esquema touser=nome_esquema

Com o data pump:

expdp usuario@nome_base_origem dumpfile=data_pump_dir dumpfile=dump_esquema.dmp schemas=nome_esquema
impdp usuario@nome_base_destino dumpfile=data_pump_dir dumpfile=dump_esquema.dmp schemas=nome_esquema

Bom, até aí não há muito motivo para espanto, é algo trivial. O detalhe é quando você precisa apagar todos os objetos já existentes antes de importar os novos. Para isso, um pouco de SQL sempre ajuda:

SELECT 'DROP TABLE ' || owner || '.' || table_name || ' CASCADE CONSTRAINTS;'
  FROM dba_tables
  WHERE owner = 'NOME_ESQUEMA'';
 
SELECT 'DROP ' || object_type || ' ' || owner || '.' || object_name || ';'
  FROM dba_objects
  WHERE
    object_type != 'PACKAGE BODY' AND
    owner = 'NOME_ESQUEMA';

É claro que você poderia criar uma função para fazer tudo isso (limpar os objetos e importar o dump) numa tacada só. Mas eu diria que dois comandos SQLs não são motivo para tanto.