glufke.net » SQL

Melhorias nos EXTERNAL TABLES do 10g

glufke — Tue, 13 Jan 2009 23:48:10 +0000

A partir do Oracle 9i foi criado o conceito de EXTERNAL TABLES, ou seja, você cria uma tabela baseado num arquivo texto no sistema operacional e pode fazer consultas SQL nessa tabela (ou seja, diretamente no arquivo texto como se fosse uma tabela)
Agora a partir do oracle 10g é possível também criar um arquivo texto baseado numa tabela do banco usando o novo driver de Data Pump existente.

A possibilidade de gravar um arquivo texto se limita ao CREATE TABLE AS SELECT apenas. Não é permitido fazer UPDATE, DELETE ou INSERT numa external table.

Vamos a um exemplo:

SQL> CREATE DIRECTORY external_directory AS
'c:\oracle\admin\betatwo\directory';

SQL> GRANT READ, WRITE ON DIRECTORY external_directory
TO scott;
SQL> CREATE TABLE emp_history_ext
(ename, retire_date,
last_retirement_pay_date, pay_amount)
ORGANIZATION EXTERNAL
( TYPE oracle_datapump
  DEFAULT DIRECTORY external_directory
LOCATION ('emp_history_01.exp', 'emp_history_02.exp') )
parallel
AS
SELECT a.ename, b.retire_date,
b.last_retirement_pay_date, b.pay_amount
FROM emp a, retire_pay b
WHERE a.empno=b.empno;

Primeiramente, criamos um DIRECTORY e damos permissão de leitura e escrita. Isso apenas é requerido caso o usuário que criou o diretório não é o usuário que vai criar a external table. Após isso, criamos uma external table que será populada com o SELECT informado!

Após a criação, basta fazer a consulta diretamente no arquivo texto:

SQL> SELECT * FROM emp_history_ext;

ENAME      RETIRE_DA LAST_RETI PAY_AMOUNT
---------- --------- --------- ----------
SMITH      25-NOV-03 15-DEC-03       1000

A criação dessa external table resulta na criação de um arquivo texto no sistema operacional com os dados informados no SELECT. Também é gerado um arquivo de LOG no mesmo diretório:

C:\> dir c:\oracle\admin\betatwo\directory
 Volume in drive C has no label.
 Volume Serial Number is 3CE9-7321
 Directory of c:\oracle\admin\betatwo\directory
12/15/2003 07:52  PM      90    EMP_HISTORY_EXT_2528_1760.log
12/15/2003 07:52  PM   1,808    emp_history.exp

Outras informações:
Quando você dropa uma external table os arquivos textos continuam no sistema operacional! Isso pode ser um problema pois caso você execute novamente o comando pra recriar a external table, os arquivos já existirão e ocasionará um ERRO. Você deve excluir esses arquivos manualmente.

Novas funcionalidades com CONNECT BY

glufke — Mon, 12 Jan 2009 11:23:42 +0000

A partir do Oracle 10g temos mais algumas funcionalidades no uso da cláusula CONNECT BY dentro dos comandos SELECT. Essas mudanças se aplicam a queries hiearquicas permitindo o retorno de não apenas PAIS, FILHOS mas também “ancestrais”. São 3 as novas cláusulas disponíveis com CONNECT BY.

connect_by_iscycle
Determina se a linha corrente tem uma linha filha que também é seu ancestral.

SQL>  SELECT ename Emp, CONNECT_BY_ISCYCLE leaf, mgr "Manager",
  2     LEVEL-1 "Pathlen", SYS_CONNECT_BY_PATH(empno, '/') "Path"
  3     FROM emp
  4     Where level-1 < 3
  5     CONNECT BY NOCYCLE PRIOR empno = mgr;

EMP              LEAF Manager    Pathlen Path
---------- ---------- ------- ---------- ------------------------------
SCOTT               0    7566          0 /7788
ADAMS               0    7788          1 /7788/7876
FORD                0    7566          0 /7902
SMITH               0    7902          1 /7902/7369
ALLEN               0    7698          0 /7499
WARD                0    7698          0 /7521
MARTIN              0    7698          0 /7654
TURNER              0    7698          0 /7844
JAMES               0    7698          0 /7900
MILLER              0    7782          0 /7934
ADAMS               0    7788          0 /7876
JONES               0    7839          0 /7566
SCOTT               0    7566          1 /7566/7788
ADAMS               0    7788          2 /7566/7788/7876
FORD                0    7566          1 /7566/7902
SMITH               0    7902          2 /7566/7902/7369
BLAKE               0    7839          0 /7698
ALLEN               0    7698          1 /7698/7499
WARD                0    7698          1 /7698/7521
MARTIN              0    7698          1 /7698/7654
TURNER              0    7698          1 /7698/7844
JAMES               0    7698          1 /7698/7900
CLARK               0    7839          0 /7782
MILLER              0    7782          1 /7782/7934
SMITH               0    7902          0 /7369
KING                0                  0 /7839
JONES               0    7839          1 /7839/7566
SCOTT               0    7566          2 /7839/7566/7788
FORD                0    7566          2 /7839/7566/7902
BLAKE               0    7839          1 /7839/7698
ALLEN               0    7698          2 /7839/7698/7499
WARD                0    7698          2 /7839/7698/7521
MARTIN              0    7698          2 /7839/7698/7654
TURNER              0    7698          2 /7839/7698/7844
JAMES               0    7698          2 /7839/7698/7900
CLARK               0    7839          1 /7839/7782
MILLER              0    7782          2 /7839/7782/7934

37 rows selected

SQL>

connect_by_isleaf
Determina se a linha corrente é uma FOLHA na árvore definida pela operação connect by.

SQL> SELECT ename "Emp", CONNECT_BY_ISLEAF leaf, mgr "Manager",
  2     LEVEL-1 "Pathlen", SYS_CONNECT_BY_PATH(empno, '/') "Path"
  3     FROM emp
  4     Where level-1 < 3
  5     CONNECT BY NOCYCLE PRIOR empno = mgr;

Emp              LEAF Manager    Pathlen Path
---------- ---------- ------- ---------- ------------------------------
SCOTT               0    7566          0 /7788
ADAMS               1    7788          1 /7788/7876
FORD                0    7566          0 /7902
SMITH               1    7902          1 /7902/7369
ALLEN               1    7698          0 /7499
WARD                1    7698          0 /7521
MARTIN              1    7698          0 /7654
TURNER              1    7698          0 /7844
JAMES               1    7698          0 /7900
MILLER              1    7782          0 /7934
ADAMS               1    7788          0 /7876
JONES               0    7839          0 /7566
SCOTT               0    7566          1 /7566/7788
ADAMS               1    7788          2 /7566/7788/7876
FORD                0    7566          1 /7566/7902
SMITH               1    7902          2 /7566/7902/7369
BLAKE               0    7839          0 /7698
ALLEN               1    7698          1 /7698/7499
WARD                1    7698          1 /7698/7521
MARTIN              1    7698          1 /7698/7654
TURNER              1    7698          1 /7698/7844
JAMES               1    7698          1 /7698/7900
CLARK               0    7839          0 /7782
MILLER              1    7782          1 /7782/7934
SMITH               1    7902          0 /7369
KING                0                  0 /7839
JONES               0    7839          1 /7839/7566
SCOTT               0    7566          2 /7839/7566/7788
FORD                0    7566          2 /7839/7566/7902
BLAKE               0    7839          1 /7839/7698
ALLEN               1    7698          2 /7839/7698/7499
WARD                1    7698          2 /7839/7698/7521
MARTIN              1    7698          2 /7839/7698/7654
TURNER              1    7698          2 /7839/7698/7844
JAMES               1    7698          2 /7839/7698/7900
CLARK               0    7839          1 /7839/7782
MILLER              1    7782          2 /7839/7782/7934

37 rows selected

SQL>

connect_by_root
Retorna o valor da coluna da linha Raíz.

SQL> SELECT ename "Emp", CONNECT_BY_ROOT mgr "Manager",
  2     LEVEL-1 "Pathlen", SYS_CONNECT_BY_PATH(empno, '/') "Path"
  3     FROM emp
  4     Where level-1 < 3
  5     CONNECT BY NOCYCLE PRIOR empno = mgr;

Emp           Manager    Pathlen Path
---------- ---------- ---------- ------------------------------
SCOTT            7566          0 /7788
ADAMS            7566          1 /7788/7876
FORD             7566          0 /7902
SMITH            7566          1 /7902/7369
ALLEN            7698          0 /7499
WARD             7698          0 /7521
MARTIN           7698          0 /7654
TURNER           7698          0 /7844
JAMES            7698          0 /7900
MILLER           7782          0 /7934
ADAMS            7788          0 /7876
JONES            7839          0 /7566
SCOTT            7839          1 /7566/7788
ADAMS            7839          2 /7566/7788/7876
FORD             7839          1 /7566/7902
SMITH            7839          2 /7566/7902/7369
BLAKE            7839          0 /7698
ALLEN            7839          1 /7698/7499
WARD             7839          1 /7698/7521
MARTIN           7839          1 /7698/7654
TURNER           7839          1 /7698/7844
JAMES            7839          1 /7698/7900
CLARK            7839          0 /7782
MILLER           7839          1 /7782/7934
SMITH            7902          0 /7369
KING                           0 /7839
JONES                          1 /7839/7566
SCOTT                          2 /7839/7566/7788
FORD                           2 /7839/7566/7902
BLAKE                          1 /7839/7698
ALLEN                          2 /7839/7698/7499
WARD                           2 /7839/7698/7521
MARTIN                         2 /7839/7698/7654
TURNER                         2 /7839/7698/7844
JAMES                          2 /7839/7698/7900
CLARK                          1 /7839/7782
MILLER                         2 /7839/7782/7934

37 rows selected

SQL>

Cláusula RETURNING com funções somatórias

glufke — Fri, 09 Jan 2009 12:57:54 +0000

Oracle 10g agora permite o uso de funções somatórias na cláusula RETURNING. O seguinte exemplo faz um UPDATE no salário de todos empregados e retorna a média salarial resultante para as linhas afetadas.

SQL> VARIABLE a NUMBER
SQL> UPDATE employee
  2  SET sal=sal*1.10 RETURNING AVG(sal) INTO :a;
SQL> PRINT a
           a
    --------
      655.22

O mesmo exemplo acima mostrado dentro de um bloco PL/SQL:

Declare
     a   number;
begin
     update employee set sal=sal*1.10 returning avg(sal) into a;
     dbms_output.put_line(a);
end;

Lembre-se que essa média é apenas das linhas afetadas pelo UPDATE!

Também é possível utilizar em comandos DELETE:

Declare
     a   number;
begin
     delete from employee where sal > 1000 returning avg(sal) into a;
     dbms_output.put_line(a);
end;

Ignorando Acentos e Maiúsculas/Minúsculas no 10g

glufke — Thu, 08 Jan 2009 12:19:12 +0000

O Oracle 10g agora permite fazer consultas considerando ou não acentos e maiúsculas/minúsculas. Isso é feito pelo uso do parâmetro NLS_SORT. Vamos aos exemplos.

Temos que adicionar o prefixo _ai para “accent insensitive” (ignora os acentos). Ou _ci para “case insensitive” (ignora se é maiúsculo ou minúsculo).

O nls_sort afeta uma série de funções SQL e operações, incluindo essas:
* WHERE
* ORDER BY
* START WITH
* HAVING
* IN / NOT IN
* BETWEEN
* CASE-WHEN

Algumas funções entretanto, não são afetadas pelo nls_sort. (Como LIKE, TRIM, INSTR).

Observe o comportamento normal do ORDER BY:

SQL> select * from thomas_teste order by 1;

NOME
-------------------------------------------
THOMAS 2
Thomas 3
thomas 1

SQL>

Agora, a mesma consulta, mas antes mudamos o NLS_SORT para ignorar os maiúsculos e minúsculos:

SQL> ALTER SESSION SET NLS_SORT=generic_m_ci;

Session altered.

SQL> select * from thomas_teste order by 1;

NOME
-----------------------------------------------
thomas 1
THOMAS 2
Thomas 3

SQL>

Agora, o mesmo resultado acima SEM mudar a sessão:

SQL> select * from thomas_teste
2  order by nlssort( nome, 'NLS_SORT=generic_m_ci');

NOME
-------------------------------------------------------
thomas 1
THOMAS 2
Thomas 3

SQL>

E é claro, também pode usar o _ai para ignorar os acentos.
NOTA: o _ai inclui a funcionalidade do CASE INSENSITIVE também!

Select que retorna os Números Primos

glufke — Thu, 11 Oct 2007 22:40:31 +0000

Esse post vai mais a título de curiosidade. Sabemos que os números primos são números naturais que podem ser divididos apenas por dois números naturais, o 1 (um) e ele mesmo. Pois a tempos que eu queria um SQL que retornasse esses números!

Após um pouco de tentativas, saiu o SQL abaixo:

select z.zz PRIMOS
from
 (select rownum+1 zz
  from user_tables
  where rownum < 100
 ) z
where zz not in (
                select y.bb
                from (select rownum+1 aa from user_tables a where rownum < 100) x
                ,    (select rownum+1 bb from user_tables b where rownum < 100) y
                where bb<>aa
                  and mod(bb, aa)=0
                  and aa<=bb
                )
/

Abaixo, colocaremos uma amostra dos resultados:

SQL> select z.zz PRIMOS
  2  from
  3   (select rownum+1 zz
  4    from user_tables
  5    where rownum < 100
  6   ) z
  7  where zz not in (
  8                  select y.bb
  9                  from (select rownum+1 aa from user_tables a where rownum < 100) x
 10                  ,    (select rownum+1 bb from user_tables b where rownum < 100) y
 11                  where bb<>aa
 12                    and mod(bb, aa)=0
 13                    and aa<=bb
 14                  )
 15  /

   PRIMOS
---------
        2
        3
        5
        7
       11
       13
       17
       19
       23
       29
       31
       37
       41
       43
       47
       53
       59
       61
       67
       71
       73
       79
       83
       89
       97

25 rows selected.
SQL>

Talvez essa não seja a melhor forma de fazer isso (obviamente, que usar SQL pra calcular isso não é a melhor saída). Mesmo assim, fica como um "desafio vencido".

Comentários aqui

Como usar Índices Virtuais – NOSEGMENT INDEXES

glufke — Tue, 25 Sep 2007 22:49:51 +0000

Essa é para quem faz tunning de SQL. Digamos que você quer verificar se a criação de um novo índice vai ser realmente usada pelo otimizador. Antes de criá-lo, você pode testar se ele resolverá seu problema atraves de INDICE VIRTUAL.

O Oracle vai criar o índice no dicionário de dados mas não vai criar o índice fisicamente. Nada será armazenado nem acessado!

SQL> set autotrace traceonly explain

SQL> select name from emp where name = 'Alex';

Execution Plan
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=CHOOSE (Cost=164 Card=1 Bytes=500)
   1    0   TABLE ACCESS (FULL) OF 'EMP' (Cost=164 Card=1 Bytes=500)

Criando o Índice

SQL> create index emp_vir_idx1 on emp(name) nosegment;

Index created.

Agora, vamos ver se ele vai usar:

SQL> set autotrace traceonly explain

SQL> select name from emp where name = 'Alex';

Execution Plan
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=CHOOSE (Cost=164 Card=1 Bytes=500)
   1    0   TABLE ACCESS (FULL) OF 'EMP' (Cost=164 Card=1 Bytes=500)

Hei! Acesso FULL? Porque o oracle não está usando meu novo índice?
Você deve primeiro alterar sua sessão com o parâmetro oculto “_use_nosegment_indexes”.

SQL> alter session set "_use_nosegment_indexes" = true;

Session altered.

SQL> select name from emp where name = 'Alex';

Execution Plan
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=CHOOSE (Cost=1 Card=1 Bytes=500)
   1    0   INDEX (RANGE SCAN) OF 'EMP_VIR_IDX1' (NON-UNIQUE) (Cost=1 Card=1 Bytes=500)

Comente aqui

Ver Plano de execução de um SQL rodando

glufke — Tue, 25 Sep 2007 14:36:31 +0000

Imagine que você rodou um SQL que está demorando muito. O Trace está desligado e você quer saber o que pode estar errado com o SQL. Com essa dica, você enxerga o plano de execução deste SQL.

1. Escolha o SQL que está rodando

select address, hash_value, child_number, sql_text
from v$sql
where users_executing <> 0
/

2. Rode o sql abaixo, informando o address, hash_value, child_number retornado do Primeiro SQL.

SET VERIFY OFF
COL id          FORMAT 999
COL parent_id   FORMAT 999 HEADING "PARENT"
COL operation   FORMAT a35 TRUNCATE
COL object_name FORMAT a30
SELECT  id, parent_id, LPAD (' ', LEVEL - 1) ||
        operation || ' ' || options operation, object_name
FROM    (
        SELECT id, parent_id, operation, options, object_name
        FROM   v$sql_plan
        WHERE  address = '&address'
        AND    hash_value = &hash_value
        AND    child_number = &child_number
        )
START WITH id = 0
CONNECT BY PRIOR id = parent_id;

Obrigado a Roger Schrag que é o autor dessa dica!
Comente aqui

CASE WHEN versus DECODE

glufke — Fri, 07 Sep 2007 10:14:20 +0000

As vezes o CASE WHEN quebra o galho quando temos que usar condições mais complexas… Mas o que fazer quando não é possível usá-lo? (como nas versões anteriores ao 8i, e no PL*SQL anterior ao 9i). É muito simples!

Eis o nosso query:

SQL> select
  2    empno
  3  , sal
  4  , case
  5      when sal<1000  then 'SALARIO BAIXO'
  6      when sal>=1000 then 'SALARIO ALTO'
  7    end comentario
  8  from emp
  9  /

     EMPNO        SAL COMENTARIO
---------- ---------- -------------
      7369        800 SALARIO BAIXO
      7499       1600 SALARIO ALTO
      7521       1250 SALARIO ALTO
      7566       2975 SALARIO ALTO
      7654       1250 SALARIO ALTO
      7698       2850 SALARIO ALTO
      7782       2450 SALARIO ALTO
      7788       3000 SALARIO ALTO
      7839       5000 SALARIO ALTO
      7844       1500 SALARIO ALTO
      7876       1100 SALARIO ALTO
      7900        999 SALARIO BAIXO
      7902       3000 SALARIO ALTO
      7934       1000 SALARIO ALTO

E agora um query exatamente IGUAL sem o tal case-when…

SQL> select
  2    empno
  3  , sal
  4  , decode(sign(sal-1000), -1, 'SALARIO BAIXO', 'SALARIO ALTO')
  5  from emp
  6  /

     EMPNO        SAL DECODE(SIGN(S
---------- ---------- -------------
      7369        800 SALARIO BAIXO
      7499       1600 SALARIO ALTO
      7521       1250 SALARIO ALTO
      7566       2975 SALARIO ALTO
      7654       1250 SALARIO ALTO
      7698       2850 SALARIO ALTO
      7782       2450 SALARIO ALTO
      7788       3000 SALARIO ALTO
      7839       5000 SALARIO ALTO
      7844       1500 SALARIO ALTO
      7876       1100 SALARIO ALTO
      7900        999 SALARIO BAIXO
      7902       3000 SALARIO ALTO
      7934       1000 SALARIO ALTO
SQL>

Mais uma forma de se fazer isso SEM case-when:

select
  empno
, sal
, decode(greatest(sal,1000), 1000, 'SALARIO BAIXO', 'SALARIO ALTO')
from emp
/

Comente aqui

“IN” pode concatenar espaços em branco

glufke — Fri, 24 Aug 2007 18:40:32 +0000

Este caso é no mínimo curioso! É bem comum usarmos “IN” quando queremos que o banco considere várias opções para um determinado campo. Neste exemplo, vamos demonstrar que o ORACLE concatena espaços em branco em comparações com IN. Vamos aos exemplos:

Sabemos que o otimizador substitui todas opções do IN pra vários “OR” no SQL. No exemplo abaixo, vamos deixar o primeiro “SP” com um espaço em branco na direita! Não deveria retornar nenhuma linha:

SQL> SELECT 'SQL IN contatena espaços em branco!' CAMPO 2 FROM DUAL 3 WHERE 'SP ' IN ( 'SP', 'RJ' ) 4 /


CAMPO

-----------------------------------

SQL IN contatena espaços em branco!

SQL>

Agora, o mesmo teste com o TAB:
SQL> SELECT 'SQL IN contatena TAB!' CAMPO 2 FROM DUAL 3 WHERE 'SP ' IN ( 'SP', 'RJ' ) 4 /


CAMPO

---------------------

SQL IN contatena TAB!

SQL>

Agora, tentamos o mesmo com espaço em branco na esquerda:
SQL> SELECT 'SQL IN não concatena espaços na esquerda!' CAMPO 2 FROM DUAL 3 WHERE ' SP' IN ( 'SP', 'RJ' ) 4 /


no rows selected

SQL>

Agora, dentro de um bloco PL/SQL
SQL> DECLARE 2 VTEMP VARCHAR2(100); 3 BEGIN 4 SELECT 'SQL IN contatena espaços em branco!' CAMPO 5 INTO VTEMP 6 FROM DUAL 7 WHERE 'SP ' IN ( 'SP', 'RJ' ); 8 9 DBMS_OUTPUT.PUT_LINE('Concatenou'); 10 11 EXCEPTION WHEN NO_DATA_FOUND THEN 12 DBMS_OUTPUT.PUT_LINE('Nao concatenou'); 13 END; 14 / Concatenou


PL/SQL procedure successfully completed.

SQL>

Interessante: Usando variável, ele não faz isso!
SQL> DECLARE 2 VTEMP VARCHAR2(100); 3 VALOR VARCHAR2(10) :='SP '; 4 BEGIN 5 SELECT 'SQL IN contatena espaços em branco!' CAMPO 6 INTO VTEMP 7 FROM DUAL 8 WHERE valor IN ( 'SP', 'RJ' ); 9 10 DBMS_OUTPUT.PUT_LINE('Concatenou'); 11 12 EXCEPTION WHEN NO_DATA_FOUND THEN 13 DBMS_OUTPUT.PUT_LINE('Nao concatenou'); 14 END; 15 / Nao concatenou


PL/SQL procedure successfully completed.

SQL>

CONCLUSÃO
Mais uma prova que usar BINDS é sempre uma boa. “Montar” comandos SQL dinamicamente pode acarretar essa concatenação acima.

EXPLICAÇÃO PARA O CASO

Após uma pesquisa na internet sobre o assunto, verificamos um texto de Chip Dawes que diz o seguinte:

Blank-Padded and Nonpadded Comparison Semantics

With blank-padded semantics, if the two values have different lengths, then Oracle first adds blanks to the end of the shorter one so their lengths are equal. Oracle then compares the values character by character up to the first character that differs. The value with the greater character in the first differing position is considered greater. If two values have no differing characters, then they are considered equal. This rule means that two values are equal if they differ only in the number of trailing blanks. Oracle uses blank-padded comparison semantics only when both values in the comparison are either expressions of datatype CHAR, NCHAR, text literals, or values returned by the USER function.

OU seja, o Oracle concatena espaços em branco na string menor para que tenham o mesmo tamanho. Após isso, ele faz a comparação das strings. Se nenhuma letra é diferente, então são iguais.

Caso encerrado!

Como descobrir a versão do Oracle

glufke — Wed, 22 Aug 2007 23:34:43 +0000

Existem várias formas de descobrir a versão do Oracle sem olhar a “telinha inicial” do SQL*Plus. Neste artigo, debateremos 4 maneiras de se descobrir isso. Algumas são bem conhecidas e outra bem “raras” de se ver.

Usar a V$Version

SQL> select * from v$version;

BANNER
----------------------------------------------------------------
Oracle9i Enterprise Edition Release 9.0.1.4.0 - Production
PL/SQL Release 9.0.1.4.0 - Production
CORE    9.0.1.2.0       Production
TNS for Linux: Version 9.0.1.4.0 - Production
NLSRTL Version 9.0.1.4.0 - Production

5 rows selected.

SQL que mostra versão

SQL> select trunc( (&_O_RELEASE/100000000)) || '.' ||
  2    trunc( mod((&_O_RELEASE/1000000),100)) || '.' ||
  3    trunc( mod((&_O_RELEASE/10000),100)) || '.' ||
  4    trunc( mod((&_O_RELEASE/100),100))
  5    from dual;

TRUNC((
-------
9.0.1.4

1 row selected.

SQL>

Mais um script interessante

rem -----------------------------------------------------------------------
rem Filename:   ver.sql
rem Purpose:    Show database version with options intalled
rem             (handy for your HELP/ABOUT menu)
rem Date:       12-Nov-1999
rem Author:     Frank Naude (frank@ibi.co.za)
rem -----------------------------------------------------------------------

set head off feed off pages 0 serveroutput on

col banner format a72 wrap

select banner
from   sys.v_$version;

select '   With the '||parameter||' option'
from   sys.v_$option
where  value = 'TRUE';

select '   The '||parameter||' option is not installed'
from   sys.v_$option
where  value <> 'TRUE';

begin
    dbms_output.put_line('Port String: '||dbms_utility.port_string);
end;
/

Este script gera uma saída como essa:

SQL> @ver
Oracle9i Enterprise Edition Release 9.2.0.5.0 - Production
PL/SQL Release 9.2.0.5.0 - Production
CORE    9.2.0.6.0       Production
TNS for 32-bit Windows: Version 9.2.0.5.0 - Production
NLSRTL Version 9.2.0.5.0 - Production
   With the Partitioning option
   With the Objects option
   With the Advanced replication option
   With the Bit-mapped indexes option
   With the Connection multiplexing option
   With the Connection pooling option
   With the Database queuing option
   With the Incremental backup and recovery option
   With the Instead-of triggers option
   With the Parallel backup and recovery option
   With the Parallel execution option
   With the Parallel load option
   With the Point-in-time tablespace recovery option
   With the Fine-grained access control option
   With the Proxy authentication/authorization option
   With the Change Data Capture option
   With the Plan Stability option
   With the Online Index Build option
   With the Coalesce Index option
   With the Managed Standby option
   With the Materialized view rewrite option
   With the Materialized view warehouse refresh option
   With the Database resource manager option
   With the Spatial option
   With the Visual Information Retrieval option
   With the Export transportable tablespaces option
   With the Transparent Application Failover option
   With the Fast-Start Fault Recovery option
   With the Sample Scan option
   With the Duplexed backups option
   With the Java option
   With the OLAP Window Functions option
   With the Block Media Recovery option
   With the Fine-grained Auditing option
   With the Application Role option
   With the Enterprise User Security option
   With the Oracle Data Guard option
   With the OLAP option
   With the Heap segment compression option
   With the Join index option
   With the Trial Recovery option
   With the Oracle Data Mining option
   With the Online Redefinition option
   With the Streams option
   With the File Mapping option
   The Real Application Clusters option is not installed
   The Oracle Label Security option is not installed
Port String: IBMPC/WIN_NT-8.1.0
SQL>

Usar a DBMS_UTILITY

SQL> DESC DBMS_OUTPUT

PROCEDURE DB_VERSION
 Argument Name                  Type                    In/Out Default?
 ------------------------------ ----------------------- ------ --------
 VERSION                        VARCHAR2                OUT
 COMPATIBILITY                  VARCHAR2                OUT

SQL>
SQL>
SQL> declare
  2  a1 varchar2(1000);
  3  a2 varchar2(1000);
  4  begin
  5    dbms_utility.db_version(a1, a2);
  6    dbms_output.put_line('VERSAO: '||A1||'   COMPATIBILTY: '||A2);
  7  end;
  8  /
VERSAO: 9.2.0.5.0   COMPATIBILTY: 9.2.0.0.0
SQL>

Comente aqui