Ao longo dos anos, o banco Oracle permite realizrmos muitas operações online, como:

• Modificar a maioria dos parâmetros (Apenas 90 dos 350 não são modificáveis online.)
• Reorganização de objetos (transformar uma tabela não particionada em uma particionada, recuperando um espaço livre, e assim por diante)
• Criar índices
• Aplicação de patches no Banco de dados com o Oracle Real Application Clusters
• Atualizar o banco de dados Oracle de release em release

O resultado é que quase todas mudanças em nível de banco de dados pode ser feito enquanto o banco está funcionando e realizando transações – com algumas raras excepções gritantes, como re-criar uma procedure, alterar triggers, adicionar grants, revoke de grant, e modificar views. Em suma, os objetos que constituem esse tipo de modificação não podiam ser modificadas, enquanto os usuários estavam utilizando. Se uma procedure estava sendo executada e um DBA tentou atualizar ela (CREATE OR REPLACE o código com o novo código mexido, afim de corrigir um bug), o DBA iria ficar esperando (BLOCKED) por essa pessoa até terminar sua execução.

Além disso, qualquer pessoa que tentou posteriormente executar uma procedure que o DBA está tentando substituir também ficaria bloqueado pelo DBA. E na maioria dos casos, o DBA não modifica apenas uma única procedure, mas muitas,  e o CREATE OR REPLACE do novo código da procedure tenderia a invalidar outros objetos dependentes também. O banco de dados parece “congelar”, o DBA não pode realizar as tarefas de patch (substituir alguns procedimentos, pacotes, views, triggers, e assim por diante), e os usuários finais não podem realizar as suas tarefas. Eles acabaram bloqueando e travando-se mutuamente.

Isto tudo termina tudo com o Oracle Database 11g Release 2 e o Edition-Based Redefinition, que permite aos DBAs e usuários finais acessar mais de uma ocorrência de uma stored procedure, trigger, view, e outros objetos e, portanto, isolar as mudanças em um esquema. Começando com o Oracle Database 11g Release 2, um único esquema pode agora ter duas ou mais ocorrências (vamos pensar em “versões”) de um stored procedure (função, trigger, e assim por diante) ou uma view ou de sinônimos e todos seus metadados relacionados, tais como GRANTS a esses objetos. (Estas duas ocorrências são independentes, eles coexistem, mas não interferem umas com as outras.) A “mágica” que permite isso é o novo objeto de edição (EDITION),  que introduz um novo namespace transparente que permite mais de uma ocorrência ao mesmo tempo de uma stored procedure, trigger e assim por diante.

No passado, um objeto de esquema era referenciado com dois componentes: o owner do objeto e o nome. Isso impedira a existência de dois procedimentos armazenados como “P” em um único esquema. Ou seja, você poderia ter apenas um objeto referenciado por “OWNER.P”.

O objeto de edição no Oracle Database 11g Release 2 introduz uma terceira dimensão no esquema de resolução de nomes: todos os objetos são referenciados pela edição da sessão, o owner do objeto e o nome do objeto. Cada banco de dados tem pelo menos uma edição a ela associados, e a base de dados tem sempre uma edição padrão. Quando você cria uma sessão no Oracle Database 11g Release 2, a sua sessão terá um atributo associado a ela que indica a edição que sua sessão estará usando (por padrão, esta será a edição padrão do banco de dados). Usando ALTER SESSION, você pode especificar qualquer edição para a qual tiver sido concedido o acesso em sua sessão.

Quando você invocar ou referenciar objetos no Oracle Database 11g Release 2, esses objetos são referenciado também com a edição fixada na sua sessão. Isso significa que um administrador do aplicativo pode agora logar, alterar uma sessão para utilizar uma edição chamada VERSION2, por exemplo, e compilar o código para esta edição. O trabalho realizado pelo administrador da aplicação na edição VERSION2 é visível apenas em sessões usando a edição VERSION2. “VERSION2″ porque não é a edição padrão, ninguém mais vê essas mudanças (novas procedures, views, drop de pacotes, e assim por diante) a menos que a pessoa solicita especificamente (via ALTER SESSION) e tem o privilégio de usar e “ver” aquela edição. O administrador do aplicativo é capaz de criar ou substituir qualquer código sem concorrer com os outros que estão executando o código. Se o administrador do aplicativo precisa substituir 50 unidades de PL/SQL, essa pessoa pode fazê-lo em isolamento durante todo o tempo enquanto aplicação de produção continua rodando.

O exemplo a seguir demonstra este pequeno conceito. Vou começar como DBA, criando uma conta de demonstração e concedendo o mínimo de privilégios necessário:

SQL> create user demo
  2    identified by demo;
User created.

SQL> grant create session,
  2       create procedure
  3    to demo;
Grant succeeded.

Agora vou iniciar o processo que me permitirá criar mais de uma ocorrência de objetos do meu código na base de dados. Vou precisar de uma nova edição, a fim de fazer isso. O seguinte comando cria a nova edição:

SQL> create edition version2
  2      as child of ora$base;
Edition created.

Criei uma edição chamada VERSION2 no meu banco de dados, e ela começa sendo filha de ORA$BASE. Como mencionado acima, cada banco de dados tem pelo menos uma edição e cada banco de dados tem uma edição padrão. Por exemplo, todo Oracle Database 11g Release 2 vai ter uma edição padrão chamado ORA$BASE. Como filha de ORA$BASE, minha edição VERSION2 começa a vida como uma cópia completa da edição padrão ORA$BASE. Tudo que está valendo em ORA$BASE também está em VERSION2.

É importante notar, contudo, que esta VERSION2 é uma cópia virtual. A instrução CREATE EDITION não copia fisicamente cada objeto da ORA$BASE. Pelo contrário, VERSION2 aponta para os objetos ORA$BASE, e não vai começar a usar espaço no dicionário até que eu modifique os objetos no contexto da edição VERSION2.

Então, agora eu vou instalar a versão 1 da minha aplicação na conta DEMO:

DEMO> create or replace
  2      procedure my_procedure
  3      as
  4      begin
  5         dbms_output.put_line
  6         ( 'I am version 1.0' );
  7      end;
  8      /
Procedure created.

DEMO> create or replace
  2      procedure my_procedure2
  3      as
  4      begin
  5         my_procedure;
  6      end;
  7      /
Procedure created.

Até agora muito simples, e quando eu executo essa “aplicação” eu vejo o seguinte:

DEMO> exec my_procedure2
I am version 1.0

PL/SQL procedure successfully completed.

Agora, vamos supor que este código esteja executando em produção por um tempo e eu descubro um bug, algo que precise reparar na stored procedure. No passado, eu precisaria que o usuário parasse de rodar, a fim de instalar o novo código.

Agora, no entanto, eu posso levantar a mudança no banco de dados enquanto o banco está funcionando, e os usuários estão executando o meu código com a edição padrão (ORA$BASE). Primeiro, como o DBA, eu preciso permitir que a conta DEMO use edições, e então eu preciso permitir que a conta DEMO veja e use a edição VERSION2. Além disso, para esta demonstração, vou deixar que a conta SCOTT veja e use VERSION2:

SQL> alter user demo
  2    enable editions;
User altered.

SQL> grant use
  2    on edition version2
  3    to demo;
Grant succeeded.

SQL> grant use
  2    on edition version2
  3    to scott;
Grant succeeded.

A instrução ALTER USER permite que a conta DEMO use edições dos códigos. Sem este GRANT, a conta DEMO seria capaz de ter apenas de ter uma cópia do código em vigor, em determinado momento, assim como na versão 7.0 até a versão 11.1 do Oracle Database. A instrução GRANT USE em seguida, permite que a conta DEMO e SCOTT vejam a edição VERSION2. Como a conta DEMO é habilitada para edição, ela será capaz de modificar a edição VERSION2 assim como alterar implementação de vários objetos, nesta edição, sem afetar outras edições. A conta SCOTT será capaz de usar apenas a edição deste VERSION2 – para definir a sua edição atual, na sua sessão de VERSION2 e ver os objetos como eles existem naquela edição.

Agora eu vou “patchear” a minha aplicação. Logando novamente com a conta DEMO, vou ver primeiro o que eu tenho no local após alterar a minha sessão de usar a edição VERSION2, como mostrado na Listagem 1.

Listagem de código 1: Definindo a edição VERSION2 e selecionando procedures

DEMO> alter session
  2       set edition = version2;
Session altered. 

DEMO> select object_name,
  2               object_type,
  3               status,
  4               edition_name
  5      from user_objects;

OBJECT_NAME      OBJECT_TYPE    STATUS    EDITION_NAME
-------------    -----------    ------    ------------
MY_PROCEDURE2    PROCEDURE      VALID     ORA$BASE
MY_PROCEDURE     PROCEDURE      VALID     ORA$BASE

Então, agora, na edição VERSION2, eu tenho ambas unidades de PL/SQL (MY_PROCEDURE e MY_PROCEDURE2), mas como denota a coluna EDITION_NAME, eles são “herdadas” da ORA$BASE. A edição VERSION2 está apontando para a cópia em ORA$BASE, mas não é uma cópia física do código.

Digamos que eu tenha que corrigir dois bugs. Primeiro, eu tenho um bug na implementação de MY_PROCEDURE, e eu vou substituir esse código. Em segundo lugar, eu perdi um GRANT, quando estava fazendo deploy do meu aplicativo, o usuário SCOTT era pra ter o privilégio EXECUTE MY_PROCEDURE2, mas de alguma forma isso não aconteceu quando eu instalei a última aplicação. Eu vou começar atualizando o código:

DEMO> create or replace
  2      procedure my_procedure
  3      as
  4      begin
  5         dbms_output.put_line
  6         ( 'I am version 2.0' );
  7      end;
  8      /
Procedure created.

DEMO> select object_name,
  2         edition_name
  3      from user_objects;

OBJECT_NAME      EDITION_NAME
-------------    ------------
MY_PROCEDURE2    ORA$BASE
MY_PROCEDURE     VERSION2

Como você pode ver, eu ainda tenho apenas dois objetos, mas existem três objetos físicos lá, como você verá em seguida. Tenho MY_PROCEDURE2, que é herdado ORA$BASE, e eu tenho MY_PROCEDURE, que agora existe fisicamente na edição VERSION2. Isso é chamado de colocar em prática o código quando eu tenho uma cópia física na edição, eu atualizei o código naquela edição.

Usando um novo conjunto de views pra ver em todas as edições e final em _AE – Eu posso ver todo o estado do meu esquema DEMO. Eu consulto a view USER_OBJECTS_AE para OBJECT_NAME e EDITION_NAME:

DEMO> select object_name,
  2         edition_name
  3      from user_objects_AE;

OBJECT_NAME      EDITION_NAME
-------------    ------------
MY_PROCEDURE     ORA$BASE
MY_PROCEDURE2    ORA$BASE
MY_PROCEDURE     VERSION2

Olhando para as diferentes edições, você pode ver que eu atualizei duas cópias físicas de MY_PROCEDURE agora: uma na edição padrão ORA$BASE e uma na nova edição VERSION2 que estou trabalhando. Agora vou aplicar o grant de EXECUTE para SCOTT:

DEMO> grant execute
  2      on my_procedure2
  3      to scott;
Grant succeeded.

DEMO> select object_name,
  2          edition_name
  3       from user_objects;

OBJECT_NAME      EDITION_NAME
-------------    ------------
MY_PROCEDURE2    VERSION2
MY_PROCEDURE     VERSION2

DEMO> select object_name,
  2         edition_name
  3       from user_objects_AE;

OBJECT_NAME      EDITION_NAME
-------------    ------------
MY_PROCEDURE2    ORA$BASE
MY_PROCEDURE     ORA$BASE
MY_PROCEDURE2    VERSION2
MY_PROCEDURE     VERSION2

Se você olhar para USER_OBJECTS, verá que eu tenho as duas procedures, mas ambas já foram atualizadas na edição VERSION2. Ao conceder o grant de EXECUTE nas procedures MY_PROCEDURE2 para SCOTT, eu fiz uma versão física da stored procedure aparecer na edição VERSION2, e eu apliquei o grant para que a edição em isolamento, sem encontrar quaisquer problemas de concorrência (problemas de bloqueios / lock porque alguém estava rodando a procedure). Olhando a USER_OBJECTS_AE, você pode ver que há agora quatro objetos físicos, dois em cada edição.

Agora, quando eu executo a procedure MY_PROCEDURE2 na edição VERSION2, eu vejo

DEMO> SELECT SYS_CONTEXT
  2         ('userenv',
  3          'current_edition_name') sc
  4       FROM DUAL;

SC
----------------------
VERSION2

DEMO> exec my_procedure2
I am version 2.0

PL/SQL procedure successfully completed.

A versão 2.0 do código é executada.

Agora, simplesmente por conectar e depois usar o banco com edição padrão (ainda ORA$BASE), iremos ver

DEMO> connect demo/demo
Connected.

DEMO> SELECT SYS_CONTEXT
  2         ('userenv',
  3          'current_edition_name') sc
  4      FROM DUAL;

SC
-----------------------
ORA$BASE

DEMO> exec my_procedure2
I am version 1.0

PL/SQL procedure successfully completed.

A versão 1.0 do código ainda está lá, e por padrão, ele será executado.

Além disso, para ver o efeito do privilégio EXECUTE que eu concedi ao SCOTT, eu posso conectar como SCOTT e tentar executar o procedimento armazenado MY_PROCEDURE2 na edição padrão e a edição VERSION2, como mostrado na Listagem 2.

Listagem de código 2: Executando my_procedure2 em edições atuais e na VERSION2

DEMO> connect scott/tiger
Connected.

SCOTT> SELECT SYS_CONTEXT
  2         ('userenv',
  3          'current_edition_name') sc
  4       FROM DUAL;

SC
-----------------------
ORA$BASE

SCOTT> exec demo.my_procedure2
BEGIN demo.my_procedure2; END;

      *
ERROR at line 1:
ORA-06550: line 1, column 7:
PLS-00201: identifier 'DEMO.MY_PROCEDURE2' must be declared
ORA-06550: line 1, column 7:
PL/SQL: Statement ignored

SCOTT> alter session
  2       set edition = version2;
Session altered.

SCOTT> exec demo.my_procedure2
I am version 2.0

PL/SQL procedure successfully completed.

Como você pode ver, quando SCOTT está usando a edição ORA$BASE, ele não pode ver ou executar a stored procedure MY_PROCEDURE2. No entanto, na edição VERSION2 o usuário SCOTT pode ver e executar esse procedimento, por isso, quando a versão 2.0 do aplicativo entra em produção, SCOTT terá a capacidade de executar esse procedimento por padrão.

Neste ponto, estou pronto para liberar este código para a produção para ser utilizado pela comunidade geral. Um único, simples ALTER DATABASE feito pelo DBA define a edição atual do banco de dados para VERSION2, e esse código se torna imediatamente acessível.

Gostaria de salientar que esta é apenas a ponta do iceberg. Aqui eu tive que fazer operações relativamente comums: substituir algumas unidades PL/SQL existentes e mudar GRANTS em alguns objetos. Eu não tomei toda a aplicação da versão 1.0 para a versão 2.0, porque isso implicaria mudar tabelas e outros objetos que não são “editáveis”. Então, o que esta coluna discutiu até agora é uma necessidade muito comum de aplicar correções em um sistema, em que você precise aplicar alterações e mudanças de código e privilégio, mas não alterações físicas, como alterações de esquema como adicionar colunas, acrescentar índices ou alterar tabelas. Estarei abordando a forma de realizar essas tarefas na próxima coluna.

Até então, veja o Capítulo 19 “Oracle Database Advanced Application Developer’s Guide 11g Release 2 (11.2)” encontrado em www.bit.ly/1m2n0J.

Esta é uma tradução literal do artigo escrito por Tom Kyte na Oracle Magazine de Janeiro/2010 por glufke.net.

Comente AQUI

Por que isso é importante para um desenvoledor Oracle ? Se você está criando um documento em PL/SQL que será aberto no Excel, a data ficará incorreta a não ser que você converta antes para o padrão do Excel.

Felizmente, a formula de conversão de datas é muito simples. A seguinte função fará a conversão de uma data no Oracle para o padrão do Excel:

CREATE OR REPLACE FUNCTION convertOracleToSerialDate(p_date DATE) RETURN NUMBER
IS
BEGIN
RETURN (p_date – TO_DATE(’01-JAN-1900?))+2;
END;
/

Veja:

SQL*Plus: Release 10.2.0.4.0 – Production on Mon Nov 23 22:31:54 2009

Copyright (c) 1982, 2007, Oracle.  All Rights Reserved.

Connected to:
Oracle Database 10g Express Edition Release 10.2.0.1.0 – Production

SQL> select convertOracleToSerialDate(’05-MAY-1968?) from dual;

CONVERTORACLETOSERIALDATE(’05-MAY-1968?)
—————————————-
24963

Se passarmos o valor “05-MAY-1968″ para a função acima, teremos como resopsta 24963. Agora, se colocarmos esse valor numa planilha excel e mudar o tipo da celula para DATA, teremos esse número convertido para “05/05/1968″, ou qualquer outro formato que você escolher.

O reverso também é possível. Caso desejamos converter do formato excel para oracle, usamos essa simples função:

CREATE OR REPLACE FUNCTION convertSerialToOracleDate(p_serial_date NUMBER) RETURN DATE
IS
BEGIN
  RETURN (TO_DATE(’01-JAN-1900?) + p_serial_date)-2;
END;
/

Exemplo:

SQL*Plus: Release 10.2.0.4.0 – Production on Mon Nov 23 22:45:44 2009

Copyright (c) 1982, 2007, Oracle.  All Rights Reserved.

Connected to:
Oracle Database 10g Express Edition Release 10.2.0.1.0 – Production

SQL> select convertSerialToOracleDate(24963) from dual;

CONVERTSE
———
05-MAY-68

SQL>

Agradecimentos a Jason Bennett pelas dicas acima.

Oracle Business Indicators é um aplicativo de B.I. que provê informações em tempo real, com acesso seguro sobre performance no iPhone.

Oracle Business Approvals for Managers permite que gerentes e executivos revisem tarefas chaves, acessem relatórios de B.I., tomem decisões e levem imediatamente as ações ao ambiente em modo seguro.

Oracle iReceipts é uma aplicação que é parte do Oracle PeopleSoft Expenses, que permite aos usuários criar e submeter despesas para transações de caixa em tempo real..

Oracle Mobile Sales Assistant é uma aplicação CRM que trás informação em tempo real segura que sua emprea precisa no aparelho móvel. Tarefas frequentes, colaboração com colegas e compradores, fechar negócios na estrada.

Oracle Mobile Sales Forecast é um aplicativo fácil de usar que mostra em tempo real uma visibilidade de oportunidade para organização.

Oracle Enterprise Asset Maintenance Workbench é um aplicativo que ajuda o departamento de manutenção a aumentar sua produtividade. A aplicação ajudará os engenheiros de campo e trabalhadores a tirar vantagem do GPS que o iPhone possui.

Oracle Business Approvals for Sales Managers permite que executivos na área de vendas realizem tarefas chave, acessem informações relevantes ao negócio e visualizem relatório afim de tomar decisões em minutos onde estiver.

Se você está interessado em desenvolver aplicativos para o iPhone usando Oracle jDeveloper, veja esse artigo

SET AUTOTRACE ON
SELECT bla bla bla...

Execution Plan
----------------------------------------------------------

--------------------------------------------------------------
| Id  | Operation          | Name       | Rows  | Cost (%CPU)|
--------------------------------------------------------------
|   0 | SELECT STATEMENT   |            |     1 |   102   (0)|
|   1 |  SORT AGGREGATE    |            |     1 |            |
|   2 |   TABLE ACCESS FULL| TABELA     |  4322 |   102   (0)|
--------------------------------------------------------------

Note
-----
   - 'PLAN_TABLE' is old version

PLAN_TABLE is old version ???

Olhei no script de criação da nova PLAN_TABLE e descobri nos comentários a data de cada modificação: 19 de Outubro de 1988 !

rem
rem $Header: utlxplan.sql 29-oct-2001.20:28:58 mzait Exp $ xplainpl.sql
rem
Rem Copyright (c) 1988, 2001, Oracle Corporation.  All rights reserved.
Rem NAME
REM    UTLXPLAN.SQL
Rem  FUNCTION
Rem  NOTES
Rem  MODIFIED
Rem     mzait      10/26/01  - add keys and filter predicates to the plan table
Rem     ddas       05/05/00  - increase length of options column
Rem     ddas       04/17/00  - add CPU, I/O cost, temp_space columns
Rem     mzait      02/19/98 -  add distribution method column
Rem     ddas       05/17/96 -  change search_columns to number
Rem     achaudhr   07/23/95 -  PTI: Add columns partition_{start, stop, id}
Rem     glumpkin   08/25/94 -  new optimizer fields
Rem     jcohen     11/05/93 -  merge changes from branch 1.1.710.1 - 9/24
Rem     jcohen     09/24/93 - #163783 add optimizer column
Rem     glumpkin   10/25/92 -  Renamed from XPLAINPL.SQL
Rem     jcohen     05/22/92 - #79645 - set node width to 128 (M_XDBI in gendef)
Rem     rlim       04/29/91 -         change char to varchar2
Rem   Peeler     10/19/88 - Creation
Rem
Rem This is the format for the table that is used by the EXPLAIN PLAN
Rem statement.  The explain statement requires the presence of this
Rem table in order to store the descriptions of the row sources.

create table PLAN_TABLE (
	statement_id 	varchar2(30),
	timestamp    	date,
	remarks      	varchar2(80),
	operation    	varchar2(30),
	options       	varchar2(255),
	object_node  	varchar2(128),
	object_owner 	varchar2(30),
	object_name  	varchar2(30),
	object_instance numeric,
	object_type     varchar2(30),
	optimizer       varchar2(255),
	search_columns  number,
	id		numeric,
	parent_id	numeric,
	position	numeric,
	cost		numeric,
	cardinality	numeric,
	bytes		numeric,
	other_tag       varchar2(255),
	partition_start varchar2(255),
        partition_stop  varchar2(255),
        partition_id    numeric,
	other		long,
	distribution    varchar2(30),
	cpu_cost	numeric,
	io_cost		numeric,
	temp_space	numeric,
        access_predicates varchar2(4000),
        filter_predicates varchar2(4000));

Atingiu a maioridade! Feliz aniversário PLAN_TABLE!

Continuando o artigo sobre colunas virtuais no Oracle 11g, veremos outras possibilidades do uso dessa feature.

Se tentarmos inserir dados que resultem em uma coluna virtual duplicada, podemos esperar uma violação de Unique Constraint:

SQL> INSERT INTO t (n1, n2) VALUES (10, 20);
INSERT INTO t (n1, n2) VALUES (10, 20)
*
ERROR at line 1:
ORA-00001: unique constraint (SCOTT.T_PK) violated

Como vimos, gerou o exception ORA-00001.

Em seguida, veremos que, como podemos criar uma chave primária em uma coluna virtual, também podemos referenciá-la a uma constraint Foreign Key. No próximo exemplo, vamos criar uma tabela filha com uma foreign key para a coluna virtual N3.

SQL> CREATE TABLE t_child
  2  ( n3 INT
  3  , CONSTRAINT tc_fk
  4       FOREIGN KEY  (n3)
  5       REFERENCES  t(n3)
  6  );

Table created.

Iremos agora inserir alguns valores válidos e inválidos:

SQL> INSERT INTO t_child VALUES (30);

1 row created.

SQL> INSERT INTO t_child VALUES (40);
INSERT INTO t_child VALUES (40)
*
ERROR at line 1:
ORA-02291: integrity constraint (SCOTT.TC_FK) violated - parent key not found

Colunas Virtuais no 11g – Parte 1 – Introdução
Colunas Virtuais no 11g – Parte 2 – Índices e Constraints

Em versões mais recentes (a partir do 8i), temos como indexar as colunas baseados em função. (Function based indexes). Agora, a partir da versão 11g, o banco Oracle nos permite também armazenar expressões diretamente nas tabelas como colunas virtuais.

Como veremos neste artigo, colunas virtuais são mais flexíveis que as outras alternativas citadas. Vamos examinar seu uso básico e também considerar alguns outros aspectos dessa nova feature.

CRIANDO UMA COLUNA VIRTUAL

Começaremos criando uma simples tabela com uma única coluna virtual

SQL> CREATE TABLE t
  2  ( n1 INT
  3  , n2 INT
  4  , n3 INT GENERATED ALWAYS AS (n1 + n2) VIRTUAL
  5  );

Table created.

Vemos que uma coluna virtual é gerada de uma simples expressão envolvendo as outras colunas da tabela. A palavra chave VIRTUAL é opcional. Foi incluída pelo que a Oracle chama da “Clareza sintática”.

Colunas virutais não são armazenadas em disco. Elas são geradas em tempo de execução usando as expressões associadas (em nosso exemplo, N1 + N2). Existe algumas implicações na forma de inserir dados em tabelas que usam colunas virtuais:

SQL> INSERT INTO t VALUES (10, 20, 30);
INSERT INTO t VALUES (10, 20, 30)
            *
ERROR at line 1:
ORA-54013: INSERT operation disallowed on virtual columns

Outra forma que não pode ser feita:

SQL> INSERT INTO t VALUES (10, 20);
INSERT INTO t VALUES (10, 20)
            *
ERROR at line 1:
ORA-00947: not enough values

Tirando o fato que não podemos inserir ou alterar as colunas virtuais, elas ainda assim são consideradas parte da lista de colunas. Isso significa portanto, que precisamos referenciar as colunas físicas explicitamente nos comandos INSERT, como abaixo:

SQL> INSERT INTO t (n1, n2) VALUES (10, 20);

1 row created.

É claro que a prática acima já faz parte das melhores práticas que todo dsenevolvedor deve ter. Agora que temos dados dentro do nosso exemplo, podemos consultar a coluna virtual:

SQL> SELECT * FROM t;

        N1         N2         N3
---------- ---------- ----------
        10         20         30

1 row selected.

Nossa expressão é montada em tempo de execução e nos dá a saída acima!

Colunas Virtuais no 11g – Parte 1 – Introdução
Colunas Virtuais no 11g – Parte 2 – Índices e Constraints

o cliente paga um valor, esse valor é creditado e através de um usuário e senha você consegue usar ligar normalmente até acabar os créditos.

Com isso, no meu sistema principal, preciso ter a informação do quanto de crédito já foi utilizado ou algo parecido, então, a cada ligação, faço o débito da conta do cliente.

Como não tenho uma integração direta entre as aplicações, vou precisar de um Robô que faça a leitura de um lado e jogue no outro, porém, por algum motivo, esse robô perdeu a conexão e ninguém foi avisado, então, teremos que ficar nos preocupando vendo se o robô está sempre ativo, etc…

Vamos lá!

Preciso criar 3 parâmetros para receber os valores de usuário, senha, banco. Depois de criado e alimentado esses parâmetros (se é um robô, usuário e senha ficam fixados nesses parâmetros. caso desejem, podem passar esses valores por linha de comando como vou mostrar mais pra frente).
Preciso então criar uma trigger WHEN-NEW-FORM-INSTANCE e então atribuir esses valores ao seu bloco de login.
ex:

IF :parameter.usuario IS NOT NULL
AND :parameter.senha IS NOT NULL
AND :parameter.banco IS NOT NULL THEN
  :BlLogin.Usuario := UPPER(:parameter.usuario) ;
  :BlLogin.Senha := UPPER(:parameter.senha);
  :BlLogin.Banco := UPPER(:parameter.banco);
  EXECUTE_TRIGGER( 'On-Logon' ) /* Chamo a trigger ON-LOGON */
END IF;

Próximo passo é implementar a trigger ON-LOGON.

BEGIN
  Logon( :BlLogin.Usuario, :BlLogin.Senha || '@' || :BlLogin.Banco, False );
  -- Este procedimento está sendo chamado duas vezes a cada Logon
  IF vConectado IS NULL THEN
    IF Form_Failure Then
      vConectado := False;
    ELSE
      vConectado := True;
    END IF;
  END IF;
END;

No próximo passo vamos implementar a trigger que irá nos ajudar a identificar os tipos de erro, é a ON-ERROR.
Todo erro existente no forms, passa por ela para que seja possível um tratamento… se não tem nada ali, o erro aparece normalmente…

--Faixa de erros que se referem a perda de conexão,
--caso alguém saiba mais alguns, pode me enviar que faço inclusão aqui
IF DBMS_ERROR_CODE IN (-03114,-03113,-00028,-01012,-01041) THEN
  vTimer := Find_Timer( 'RELOG' );
  --Caso exista algum timer com nome de RELOG,
  --deleto o time para recriar o mesmo
  If Not Id_Null( vTimer ) Then
    Delete_Timer( vTimer );
  END IF;
  --Criando timer que irá disparar rotina de reconectar
  vTimer := Create_Timer( 'RELOG', 1500, Repeat );
END IF;

Agora que tudo foi criado e tratado, resta apenas a rotina final e mais importante… que é fazer a rotina para quando o timer disparar, fazer a abertura do novo form por linha de comando…

então, na trigger WHEN-TIMER-EXPIRED, vamos ter o seguinte código.

if Get_Application_Property( Timer_Name ) = 'RELOG' Then
  If :parameter.usuario Is Not Null
  and :parameter.senha Is Not Null
  and :parameter.banco Is Not Null Then
    --Preencho a variável com o valor da chave ORACLE_HOME
    Tool_Env.Getvar('ORACLE_HOME', v);
    --Pego o nome do modulo em execução
    vModulo := UPPER( GET_FORM_PROPERTY( GET_APPLICATION_PROPERTY( CURRENT_FORM_NAME), FILE_NAME  ));
    --Monto aqui a linha de comando que irá abrir o novo form
    v := v|| '\bin\ifrun60.exe ' || vModulo || ' usuario=' || :parameter.login || ' banco='|| :parameter.banco || ' senha=' || :parameter.senha;
    --Faço a abertura do mesmo
    Win_API_Shell.WinExec( v , WIN_API.SW_SHOWMINIMIZED, false);
    WIN_API_UTILITY.SLEEP(2000);/*Delay de 2 segundos*/
    --fecho o form que deu erro de conexão
    exit_form(no_validate);
  End If;
End If;

Pronto, Dessa forma, não preciso me preocupar tanto com a rotina do robô responsável pela integração… se a conexão parar, ele mesmo identifica isso, abre novo form e tudo resolvido!

Essa solução ajuda para aqueles casos em que sua empresa trabalha em RAC, pois, se uma instância cair, automaticamente ele fecha a que deu erro e abre outra na instância que ficou ativa.

Rodrigo Valentim é Analista de Sistemas Oracle Developer
http://www.rodrigovalentim.com/blog

1. Concatenando 2 Strings
2. Colocando a primeira letra do texto como Maiúscula
3. Transformando o texto em texto Minúsculo e Maiúsculo
4. Convertendo letras em códigos ASCII
5. Localizando a posição uma string no meio do texto
6. Atribuindo dígitos no final e/ou no inicio do texto
7. Removendo espaços no inicio e/ou fim do texto
8. Como inverter o texto
9. Substituindo Strings por outras Strings
10. Cortando o conteúdo do texto
11. Descobrindo o tamanho da string
12. Retornando colunas com valor não nulo
13. Exemplo da utilização de algumas funções
    • Pesquisando em uma string por um digito e exibindo o resto da string pegando como base esse digito localizado.
    • Repartindo uma string e inserindo um valor no meio.

1. Concatenando 2 strings

Existem duas formas de trabalhar concatenando strings. CONCAT e PIPE
Concat:

SQL: SELECT CONCAT ('Rodrigo ', 'Valentim') FROM dual;
CONCAT('RODRIGO','VALENTIM')
----------------------------
Rodrigo Valentim

Usando PIPE:

SQL: SELECT 'Rodrigo '||'Valentim' FROM dual;
'RODRIGO'||'VALENTIM'
---------------------
Rodrigo Valentim

2. Colocando a primeira letra do texto como Maiúscula.

SQL: SELECT INITCAP('rodrigo valentim') FROM dual;
INITCAP('RODRIGOVALENTIM')
--------------------------
Rodrigo Valentim

3. Alternar entre Maiúscula e Minúscula

SQL: SELECT LOWER('RODRIGO ')||UPPER('valentim') FROM dual;
LOWER('RODRIGO')||UPPER('VALEN
------------------------------
rodrigo VALENTIM

4. Convertendo letras em códigos ASCII

SQL: SELECT ASCII('A') FROM dual;
ASCII('A')
----------
65

SQL: SELECT ASCII('Z') FROM dual;
ASCII('Z')
----------
90

SQL: SELECT ASCII('a') FROM dual;
ASCII('A')
----------
97

SQL: SELECT ASCII('z') FROM dual;
ASCII('Z')
----------
122

SQL: SELECT ASCII(' ') FROM dual;
ASCII('')
----------
32

5. Localizando a posição uma string no meio do texto
Com a função INSTR, é possível localizar caracteres dentro de um texto, de forma normal ou inversa.

Localizando a primeira posição da string no texto

SQL: SELECT INSTR('Exemplo de como realizar pesquisa em uma string', 'r', 1, 1) localiza_1 from dual;
LOCALIZA_1
----------
17

Localizando a segunda posição da string no texto

SQL: SELECT INSTR('Exemplo de como realizar pesquisa em uma string', 'r', 1, 2) localiza_2 from dual;
LOCALIZA_2
----------
24

Localizando a terceira posição da string no texto

SQL: SELECT INSTR('Exemplo de como realizar pesquisa em uma string', 'r', 1, 3) localiza_3 from dual;
LOCALIZA_3
----------
44

Localizando a quarta posição da string no texto, como não existe mais de 3 letras r no texto, ele retorna zero.

SQL: SELECT INSTR('Exemplo de como realizar pesquisa em uma string', 'r', 1, 4) localiza_4 from dual;
LOCALIZA_4
----------
0

Para realizar a mesma pesquisa so que de ordem inversa, basta usar o valor negativo na função

SQL: SELECT INSTR('Exemplo de como realizar pesquisa em uma string', 'r', -1, 1) localiza_1 from dual;
LOCALIZA_1
----------
44

Nestas condições, ele me retorna a primeira posição na ordem inversa, ou seja, a última.

6. Atribuindo dígitos no final e/ou no inicio do texto.
Temos como usar o LPAD para inserir digitos na esquerda e RPAD para inserir digitos na direita.
LPAD:

SQL: SELECT LPAD('Rodrigo Valentim', 25, 'x') FROM dual;
LPAD('RODRIGOVALENTIM',25,'X')
------------------------------
xxxxxxxxxRodrigo Valentim

RPAD:

SQL: SELECT RPAD('Rodrigo Valentim', 25, 'x') FROM dual;
RPAD('RODRIGOVALENTIM',25,'X')
------------------------------
Rodrigo Valentimxxxxxxxxx

7.Removendo dígitos do inicio ou do fim ou de ambos do texto
Podendo ser espaços em branco ou letras (TRIM só remove espaços em branco).
LTRIM:

SQL: SELECT '*' || LTRIM('               Rodrigo Valentim               ') || '*' FROM dual;
'*'||LTRIM('RODRIGOVALENTIM')|
---------------------------------
*Rodrigo Valentim               *

RTRIM:

SQL: SELECT '*' || RTRIM('               Rodrigo Valentim               ') || '*' FROM dual;
'*'||RTRIM('RODRIGOVALENTIM')|
---------------------------------
*               Rodrigo Valentim*

TRIM:

SQL: SELECT '*'||TRIM('   Rodrigo Valentim   ')||'*' FROM dual;
'*'||TRIM('RODRIGOVALENTIM')||
------------------------------
*Rodrigo Valentim*

8. Como inverter o conteúdo em uma string

SQL: select reverse('MITNELAV OGIRDOR') from dual;
REVERSE('MITNELAVOGIRDOR')
--------------------------
RODRIGO VALENTIM

9. Substituindo Strings por outras Strings
Com a Função Replace é possível substituir o conjunto de caracteres por outro, no exemplo abaixo, ele vai alterar o valor DE para A

SQL: SELECT REPLACE('ABCDE','DE','A') FROM dual;
REPLACE('ABCDE','DE','A')
-------------------------
ABCA

10. Cortando conteúdo do texto com SUBSTR
Com essa função, é possível exibir somente partes do texto. No exemplo abaixo, digo que quero iniciar meu texto da posição 3 e andar mais 9 dígitos.

SQL: SELECT SUBSTR('Rodrigo Valentim', 3, 9) FIRST_FOUR FROM dual;
FIRST_FOUR
----------
drigo Val

11. Descobrindo o tamanho da string com a função LENGTH.

SQL: SELECT LENGTH('Rodrigo Valentim') FROM dual;
LENGTH('RODRIGOVALENTIM')
-------------------------
16

12. Retornando colunas com valor não nulo
Com a função COALESCE. Ela pesquisa entre as colunas passada e retorna o primeiro valor não nulo que foi encontrado.

SQL: create table artigo_coalesce(col1 varchar2(10), col2 varchar2(10), col3 varchar2(10), col4 varchar2(10));
Table created

SQL: insert into artigo_coalesce values (NULL, NULL, 'C','D');
1 row inserted
SQL: insert into artigo_coalesce values (NULL, 'A', 'C','D');
1 row inserted
SQL: insert into artigo_coalesce values ('B', 'A', 'C','D');
1 row inserted
SQL: insert into artigo_coalesce values (NULL, 'D', NULL,'A');
1 row inserted
SQL: SELECT COALESCE(COL1, COL2, COL3, COL4) FROM artigo_coalesce;
COALESCE(COL1,COL2,COL3,COL4)
-----------------------------
C
A
B
D

13.1 Pesquisando em uma string por um digito e exibindo o resto
Pesquisando em uma string por um digito e exibindo o resto da string pegando como base esse digito localizado. Bom, primeiro preciso saber qual a posição que preciso começar, neste caso, vou iniciar pela ‘\’. Vou pesquisar do fim para o inicio e localizar neste caso, a localização da ultima barra.

SQL: select INSTR('c:\arquivo\arquivo.txt', '\', -1, 1) from dual;
INSTR('C:\ARQUIVO\ARQUIVO.TXT'
------------------------------
11

Depois de localizar, preciso então usar ela como ponto inicial e ir até o final da string completa. Como não sei o tamanho total da minha string, pois, pode ser que ela mude algum dia, vou usar a função LENGTH que me retornará o tamanho total.

SQL: SELECT substr('c:\arquivo\arquivo.txt',INSTR('c:\arquivo\arquivo.txt', '\', -1, 1) ,length('c:\arquivo\arquivo.txt')) from dual;
SUBSTR('C:\ARQUIVO\ARQUIVO.TXT
------------------------------
\arquivo.txt

Depois de localizar o inicio e fim da minha string através das funções acima, preciso ajustar para que a barra não saia… a função SUBSTR está iniciando da posição 11 e indo até a posição final da string, por isso está me retornando a barra, então, preciso somar + 1 ao retorno da localização da ‘\’, para então ela não aparecer no meu resutlado.

SQL: SELECT substr('c:\arquivo\arquivo.txt',INSTR('c:\arquivo\arquivo.txt', '\', -1, 1) + 1 ,length('c:\arquivo\arquivo.txt')) from dual;
SUBSTR('C:\ARQUIVO\ARQUIVO.TXT
------------------------------
arquivo.txt

Então, andando da posição 12 até a ultima posição, consigo através do substr cortar parte do texto e extrair somente o que desejo.

13.2 Pegar uma String e inserir um valor no meio dela
Eu tenho uma String chamada ‘Existe Perfeita?’ e quero inserir o Lógica no meio dela utilizando uma query…

Pegando trechos do ultimo exemplo (13.1) vamos montar nossa query e assim ter nosso retorno…

Primeiro preciso pegar o espaço em branco, levando em consideração que é o meio da string.

SQL: SELECT instr('Existe Perfeita?',' ') FROM dual;
INSTR('EXISTEPERFEITA?','')
---------------------------
7

Agora vamos cortar somente o inicio da string, com SUBSTR vamos pegar da posição 1 até o espaço em branco (posição 7)

SQL: SELECT substr('Existe Perfeita?',1,instr('Existe Perfeita?',' ')) FROM dual;
SUBSTR('EXISTEPERFEITA?',1,INS
------------------------------
Existe

Temos então somente o Existe. Vamos então inserir (concatenar) o texto que queremos e ter como resultado o Existe Lógica

SQL: SELECT substr('Existe Perfeita?',1,instr('Existe Perfeita?',' '))||'Lógica' FROM dual;
SUBSTR('EXISTEPERFEITA?',1,INS
------------------------------
Existe Lógica

Agora falta inserir a parte final… vamos então pegar a String inicial e então cortar a parte do meio até o fim. Já sei qual o meio e para descobrir o fim é só usar a função LENGTH e então temos o resultado que queremos.

SQL: SELECT substr('Existe Perfeita?',1,instr('Existe Perfeita?',' '))||'Logica'||substr('Existe Perfeita?',instr('Existe Perfeita?',' '),length('Existe Perfeita?')) "Existe?" FROM dual;
Existe?
-----------------------
Existe Logica Perfeita?

Acredito que tenha conseguido passar um pouco do que é trabalhar com Strings no Oracle…

Espero ter esclarecido algumas dúvidas e as que não foram esclarecidas, podem me procurar que eu vou tentar ajudar!

Abraço e até a próxima.

Rodrigo Valentim é Analista de Sistemas Oracle Developer
http://www.rodrigovalentim.com/blog

No Oracle 11g, você pode adicionar uma cláusula que força a ordem de execução das triggers:

create or replace trigger tr_pay_follow_up
before update
on payments
for each row
FOLLOWS TRIGGER_ANTERIOR
begin
... etc ...

Neste caso a cláusula FOLLOWS força que a trigger seja disparada apenas após a trigger citada.

Primeiro passo é criar a especificação de uma Package.

PACKAGE PKG_EX_TABLE_RECORD IS
--Um Cursor é necessário para criar a “Table Of Cursor%ROWTYPE”,
--mesmo que não seja usado, pois o tipo a ser criado deve se
--basear em uma tabela ou um cursor
  CURSOR cExemplo IS
    SELECT cod_funcionario
      FROM empresa;

   -- Tipo: Coleção de registros
   TYPE tExemplo IS TABLE Of cExemplo%Rowtype INDEX BY binary_integer;

   -- Variável do tipo coleção de registros
   vExemplo tExemplo;

   --variável para os valores do cursor (não se pode atribuir
   --diretamente um registro do cursor à variável da coleção)
   vRec cExemplo%rowtype;
   -- índice
   x integer;
END;

Agora, vamos ver como armazenar informações nesse registro de memória.

DECLARE
  --vamos ver os funcionarios que tem salario menor que 2000 reais.
  CURSOR cEmpregados IS
  SELECT cod_funcionario
  FROM empresa
  WHERE func_sal <= 2000;

BEGIN
  –-iniciando o valor do indice
  PKG_EX_TABLE_RECORD.x := 0;
  FOR regfunc IN cEmpregados LOOP
    -- x é o indice para o registro, estou atritubindo mais 1 a ele de
    -- acordo com o que já existe, tipo uma sequence. Pego o ultimo
    -- valor e somo mais um.
    PKG_EX_TABLE_RECORD.x := nvl(PKG_EX_TABLE_RECORD.vExemplo.last,0) + 1;

    --atribui os valores do cursor (cConta_Produtos)
    --ao array de elementos
    PKG_EX_TABLE_RECORD.vExemplo(PKG_EX_TABLE_RECORD.x).cod_funcionario := regfunc.cod_funcionario;
  END LOOP;
END;

Agora, chegou a hora de ver conteúdo do registro de memória.

--Com um for loop, vamos varrer todo o registro
--de memória afim de recuperar os valores

--dessa forma, pego o ultimo valor caso exista.
FOR j IN 1..nvl(PKG_EX_TABLE_RECORD.vExemplo.last,0) LOOP 

  --uma nova opção está sendo utilizada, para então
  --ser possível ver se existe registro antes de
  --excluir, caso contrario, dará um erro por nao achar o registro
  IF PKG_EX_TABLE_RECORD.vExemplo.EXISTS(j) THEN
    --Verifica se o código do funcionario é igual ao listado abaixo,
    --assim, posso destaca-lo de alguma forma na tela
     IF PKG_EX_TABLE_RECORD.vExemplo(j).cod_funcionario = consulta.cod_funcionario THEN
       --ao localizar, uma ação será realizada
        (…)
     END IF;
  END IF;
END LOOP;

Pronto. Agora, não podemos esquecer de inserir uma função para limpar a memória quando você achar que não mais irá utiliza-la.

--vamos então varrer todo o registro de memória
FOR j IN 1..nvl(PKG_EX_TABLE_RECORD.vExemplo.last,0) LOOP

  --uma nova opção está sendo utilizada, para então ser possível
  --ver se existe registro antes de excluir, caso contrario,
  --dará um erro por nao achar o registro
  IF PKG_EX_TABLE_RECORD.vExemplo.EXISTS(j) THEN

    --Deletando registro de memoria. Uma vez deletado, a posição J
    --ficará sempre vazia, por isso a necessidade de usar o exists
     pkg_aviso_cirurgia.vAvisoCir.DELETE(j);
  END IF;

--Fim do Loop para verificar os agendamentos localizados
END LOOP;  

Pronto, agora já é possível arriscar na solução de algum problema que precise dessa rotina, ela pode ser utilizada da forma mais fácil até a mais complexa…

Rodrigo Valentim é Analista de Sistemas Oracle Developer
http://www.rodrigovalentim.com/blog