GPO ( Grupo de Profissionais Oracle )
A maior comunidade Oracle do Brasil !

Using Collections and Records (Parte 1) – VARRAY

Existem 3 tipos de coleções de dados em PL/SQL, sendo eles: matriz associativa (ou também conhecido como tabela por índices), tabela aninhada, matriz de tamanho variável, onde cada uma destas possuem as suas diferenças e características.

Nesta primeira etapa do artigo será abordado o tema de matriz de tamanho variável, que é conhecida como vetores e matrizes em matemática. Os conceitos de vetores e matrizes nada mais é do que tabelas de dados, onde possuímos os mesmos tipos de dados armazenados em diversas posições, sendo elas identificadas por linhas e colunas.

Um exemplo clássico de uma matriz, é para os amantes de jogos de tabuleiro conhecido como Batalha Naval, onde os jogadores tentavam adivinhar a posição em que estava o navio do seu oponente, falando o número da linha e o número da coluna, da mesma forma que coordenadas.

Vetores e Matrizes são estruturas de dados muito simples, que facilitam e ajudam muito quando possuímos muitas variáveis do mesmo tipo em um algoritmo. Imaginamos o seguinte problema, onde o desenvolvedor precisa criar uma lógica de programação que efetue a leitura do nome do aluno e as 4 notas de 50 alunos, e com isso calcule a média de cada um e informe quais foram aprovados e quais foram reprovados. Neste exemplo precisaríamos de 50 variáveis para armazenar os nomes de todos os alunos, onde teríamos ainda as 4 notas para cada aluno, ou seja, 4 vezes 50 iguais à 200 variáveis para armazenar todas as notas de cada aluno e por fim, mais 50 variáveis para armazenar as médias dos alunos, com isso imaginamos o tamanho do algoritmo e das linhas de código que será desenvolvida, pois serão totalizadas 250 variáveis. (FURTADO, 2005).

Abaixo um resumo de como ficaria esta estrutura utilizando o conceito de vetores e matrizes, onde há uma matriz para os dados dos alunos, notas e suas respectivas médias, ou seja, utilizaremos apenas uma variável e com isso ganharemos muito mais eficiência no desenvolvimento/manutenção do código e também no processamento dos dados que é muito mais rápido, com poucas linhas de código.

Exemplo:

 

1

2

3

4

Média

 

Nota 01

Nota 02

Nota 03

Nota 04

 

Miguel

7,00

8,00

6,00

9,00

7,50

Davi

5,00

6,00

5,00

5,00

5,25

Arthur

10,00

10,00

9,00

9,00

9,50

Pedro

9,00

8,00

7,00

7,00

7,75

Gabriel

8,00

8,00

8,00

8,00

8,00

Lucas

4,00

4,00

4,00

5,00

4,25

Rafael….

….

….

….

Maria

8,00

6,00

4,00

5,00

5,75

Nas linguagens programação, o vetor ou as matrizes, são conhecidas como ARRAY, porémno Oracle, estes tipos de dados fazem parte das coleções e registros do PL/SQL (PL/SQL Collection and Records), onde possuem outros tipos de matrizes e vetores, como por exemplo: tabelas aninhadas (Nested Tables), matrizes associativas (Associative Arrays) e os vetores e matrizes (VARRAY).

As coleções podem apenas possuir uma dimensão, onde você poderá modelar os vetores e matrizes multidimensionais, criando assim uma coleção de elementos sobre outra coleção de elementos. Pode ser utilizado as coleções e registros em um bloco anônimo de PL/SQL, procedimentos armazenados (Stored Procedures), funções (Functions), pacotes (Packages) e tipos de objeto (Types).

As VARRAYS, devem possuir um número fixo de elementos, mesmo você podendo alterar o número de elementos durante a execução do seu código. Eles usam números sequenciais para acessar os dados, onde pode ser definido tipos de objetos equivalentes aos VARRAYS, permitindo serem armazenadas no banco de dados.

Um tipo de objeto VARRAY, permite ao desenvolvedor associar um único identificador em uma coleção inteira, e esta associação permite manipular a coleção como um todo e fazer uma referência de elementos individuais com mais facilidade.

O VARRAY possuí um tamanho máximo com um número positivo e inteiro de elementos, por obrigatoriedade deve ser especificada no momento da definição do tipo de objeto quais quantos espaços alocados na memória para registros dos dados. Também devem ter um tamanho mínimo de 1 espaços, porém há uma exceção, o VARRAY pode não ter nenhum elemento, ou seja, ele se torna vazio (null), e não com tamanho de 0. (Luscher, 2002)

Segundo a documentação da Oracle, a escolha das matrizes entre tabelas aninhadas e VARRAY´s, pode ser uma tarefa que exigirá do desenvolvedor um certo cuidado. As instruções abaixo, mostram as vantagens de cada um no momento de escolha no qual utilizar:

– A utilização do VARRAY é uma boa opção quando o número de elementos é conhecido antecipadamente;
– Quando os elementos são geralmente todos acessados em sequência;
– Os VARRAY´s quando armazenados no banco de dados, mantêm a sua ordenação e subscritas, com isso ganha-se o desempenho na ordenação dos dados;

(Luscher 2002)

Havendo a necessidade de recuperar todos os elementos de um VARRAY ao mesmo tempo, onde é apropriado quando se opera em todos os elementos de uma só vez, este processo pode ser “impraticável” para um grande número de elementos, podendo tornar-se a consulta mais lenta e menos eficiente. (MOORE, 2009)

Para definir um VARRAY utilizamos a seguinte sintaxe:

TYPE TYPE_NAME IS {VARRAY OR VARYING ARRAY} (SIZE_LIMIT) OF ELEMENT_TYPE [NOT NULL];

Existem também os métodos que podem ser executadas em um VARRAY (servemtambém para as tabelas aninhadas e matrizes associativas), são eles: (BURLESON, 2008)

COUNT

Retorna o número de elementos de um VARRAY.

EXISTS

Retorna um valor booleano verdadeiro se o elemento no índice especificado exista, caso contrário retornará falso.

EXTEND

Aumenta o tamanho da matriz por 1 ou pelo número especificado. Não pode ser usado em matrizes associativas.

FIRST

Navega para o primeiro elemento da matriz.

LAST

Navega para o último elemento da matriz.

NEXT

Navega para o próximo elemento da matriz.

PRIOR

Navega para o elemento anterior da matriz.

TRIM

Remove o último elemento da matriz. Não pode ser usado em matrizes associativas.

DELETE

Remove todos os elementos de uma matriz.

LIMIT

Mostra o limite de tamanho de uma matriz.

Os comandos a seguir, mostram um vetor de 10 posições de números com tamanho total de 4 com 2 posições de casas decimais, e em seguida é declarado uma variável para o mostrar os valores do vetor em um bloco anônimo. No exemplo abaixo, é mostrado o valor do VARRAY que está na posição 3.

Exemplo 01:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(10) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 

BEGIN 
  DBMS_OUTPUT.PUT_LINE('VALOR: ' || VMY_VARRAY(3));

END;

Resultado 01:

Bloco anônimo concluído

VALOR: 1,2

Para o próximo exemplo, será percorrido todos os valores do vetor utilizando as funções FIRST e LAST e com uma função de repetição, neste exemplo veremos a função COUNT, que irá servir para mostrar junto ao código quantos registros o vetor possui no total.

Exemplo 02:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(10) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 

BEGIN 
  FOR i IN VMY_VARRAY.FIRST .. VMY_VARRAY.LAST
  LOOP
    DBMS_OUTPUT.pUT_LINE('VALOR (' || i || ') de (' || VMY_VARRAY.COUNT || '): ' || VMY_VARRAY(I));  

  END LOOP; 

END;

Resultado 02:

Bloco anônimo concluído

VALOR (1) de (10): 1
VALOR (2) de (10): 1,1
VALOR (3) de (10): 1,2
VALOR (4) de (10): 1,3
VALOR (5) de (10): 1,4
VALOR (6) de (10): 1,5
VALOR (7) de (10): 1,6
VALOR (8) de (10): 1,7
VALOR (9) de (10): 1,8
VALOR (10) de (10): 1,9

Pode-se utilizar o comando EXISTS para verificar se algum elemento do vetor existe, retornando verdadeiro (true) ou falso (false). Este comando deve-se informar um parâmetro de entrada do tipo número inteiro. Seguindo os exemplos abaixo, é efetuado um teste da posição 10 e 11 para verificar se ambos são existentes no vetor .

Exemplo 03:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(10) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 

BEGIN 
    IF VMY_VARRAY.EXISTS(10) THEN
      DBMS_OUTPUT.pUT_LINE('POSIÇÃO (' || 10 || '): ' || VMY_VARRAY(10) || ' É EXISTENTE.');

    ELSE
      DBMS_OUTPUT.pUT_LINE('POSIÇÃO (' || 10 || '): || ' NÃO É EXISTENTE.');

    END IF;

END;

Resultado 03:

Bloco anônimo concluído

POSIÇÃO (10): 1,9 É EXISTENTE.

Exemplo 04:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(10) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 

BEGIN 
    IF VMY_VARRAY.EXISTS(11) THEN
      DBMS_OUTPUT.pUT_LINE('POSIÇÃO (' || 11 || '): ' || VMY_VARRAY(11) || ' É EXISTENTE.');

    ELSE
      DBMS_OUTPUT.pUT_LINE('POSIÇÃO (' || 11 || '): ' || ' NÃO É EXISTENTE.');

    END IF;

END;

Resultado 04:

Bloco anônimo concluído

POSIÇÃO (11):  NÃO É EXISTENTE.

A função TRIM servirá para retirar o último elemento da matriz, caso não seja especificado um valor inteiro para o parâmetro de quantas posições deverá ser retirados, por padrão o PL/SQL irá retirar apenas um elemento da ultima posição, e caso seja especificado um valor, será a quantidade de elementos que deverão ser retirados, onde será retirado na ordem inversa, ou seja, do maior para o menor elemento. Deve-se observar também que caso seja retirado todos os valores do vetor, os mesmos não poderão mais ser acessados, pois estarão com valores nulos, e poderá ocorrer um erro, caso haja a tentativa de acessá-los. Os exemplos abaixo mostram as três situações.

Exemplo 05:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(10) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 

BEGIN 
  VMY_VARRAY.TRIM;
  FOR i IN VMY_VARRAY.FIRST .. VMY_VARRAY.LAST
  LOOP
    DBMS_OUTPUT.pUT_LINE('VALOR (' || i || ') de (' || VMY_VARRAY.COUNT || '): ' || VMY_VARRAY(I));  

  END LOOP; 

END;

Resultado 05:

Bloco anônimo concluído

VALOR (1) de (9): 1
VALOR (2) de (9): 1,1
VALOR (3) de (9): 1,2
VALOR (4) de (9): 1,3
VALOR (5) de (9): 1,4
VALOR (6) de (9): 1,5
VALOR (7) de (9): 1,6
VALOR (8) de (9): 1,7
VALOR (9) de (9): 1,8

Exemplo 06:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(10) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 

BEGIN 
  VMY_VARRAY.TRIM(5);
  FOR i IN VMY_VARRAY.FIRST .. VMY_VARRAY.LAST
  LOOP
    DBMS_OUTPUT.pUT_LINE('VALOR (' || i || ') de (' || VMY_VARRAY.COUNT || '): ' || VMY_VARRAY(I));  

  END LOOP; 

END;

Resultado 06:

Bloco anônimo concluído

VALOR (1) de (5): 1
VALOR (2) de (5): 1,1
VALOR (3) de (5): 1,2
VALOR (4) de (5): 1,3
VALOR (5) de (5): 1,4

Exemplo 07:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(10) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 

BEGIN 
  VMY_VARRAY.TRIM(10);
  FOR i IN VMY_VARRAY.FIRST .. VMY_VARRAY.LAST
  LOOP
    DBMS_OUTPUT.pUT_LINE('VALOR (' || i || ') de (' || VMY_VARRAY.COUNT || '): ' || VMY_VARRAY(I));  

  END LOOP; 

END;

Resultado 07:

ORA-06502: PL/SQL: erro numérico ou de valor
ORA-06512: em line 6
06502. 00000 -  "PL/SQL: numeric or value error%s"

*Cause:    An arithmetic, numeric, string, conversion, or constraint error
           occurred. For example, this error occurs if an attempt is made to
           assign the value NULL to a variable declared NOT NULL, or if an
           attempt is made to assign an integer larger than 99 to a variable
           declared NUMBER(2).

*Action:   Change the data, how it is manipulated, or how it is declared so
           that values do not violate constraints.

Pode-se utilizar os comandos PRIOR e NEXT para verificar qual o elemento anterior e também qual o próximo elemento do VARRAY, onde necessita de um parâmetro do tipo de número inteiro para informar quantas posições do vetor deverá retornar, no caso do PRIOR, ou seguir no caso do NEXT. Com isso é possível acessar às informações da posição especificada do VARRAY, conforme o exemplo abaixo:

Exemplo 08:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(10) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 

BEGIN   
  FOR i IN VMY_VARRAY.FIRST .. VMY_VARRAY.LAST
  LOOP   
    DBMS_OUTPUT.pUT_LINE('VALOR (' || i || ') de (' || VMY_VARRAY.COUNT || '): ' || VMY_VARRAY(I));  

    IF I > 1 THEN 
      DBMS_OUTPUT.pUT_LINE('ÍNDICE ANTERIOR: ' || VMY_VARRAY.PRIOR(I) || ' COM VALOR DE: ' || VMY_VARRAY(I-1));    

    END IF;  

    IF I < 10 THEN 
      DBMS_OUTPUT.pUT_LINE('PRÓXIMO ÍNDICE: ' || VMY_VARRAY.NEXT(I) || ' COM VALOR DE: ' || VMY_VARRAY(I+1));      

    END IF;      

    DBMS_OUTPUT.pUT_LINE('===============================');   

  END LOOP; 

END;

Resultado 08:

bloco anônimo concluído

VALOR (1) de (10): 1

PRÓXIMO ÍNDICE: 2 COM VALOR DE: 1,1
==========================================================
VALOR (2) de (10): 1,1
ÍNDICE ANTERIOR: 1 COM VALOR DE: 1

PRÓXIMO ÍNDICE: 3 COM VALOR DE: 1,2
==========================================================
VALOR (3) de (10): 1,2
ÍNDICE ANTERIOR: 2 COM VALOR DE: 1,1

PRÓXIMO ÍNDICE: 4 COM VALOR DE: 1,3
==========================================================
VALOR (4) de (10): 1,3
ÍNDICE ANTERIOR: 3 COM VALOR DE: 1,2

PRÓXIMO ÍNDICE: 5 COM VALOR DE: 1,4
==========================================================
VALOR (5) de (10): 1,4
ÍNDICE ANTERIOR: 4 COM VALOR DE: 1,3

PRÓXIMO ÍNDICE: 6 COM VALOR DE: 1,5
==========================================================
VALOR (6) de (10): 1,5
ÍNDICE ANTERIOR: 5 COM VALOR DE: 1,4

PRÓXIMO ÍNDICE: 7 COM VALOR DE: 1,6
==========================================================
VALOR (7) de (10): 1,6
ÍNDICE ANTERIOR: 6 COM VALOR DE: 1,5

PRÓXIMO ÍNDICE: 8 COM VALOR DE: 1,7
==========================================================
VALOR (8) de (10): 1,7
ÍNDICE ANTERIOR: 7 COM VALOR DE: 1,6

PRÓXIMO ÍNDICE: 9 COM VALOR DE: 1,8
==========================================================
VALOR (9) de (10): 1,8
ÍNDICE ANTERIOR: 8 COM VALOR DE: 1,7

PRÓXIMO ÍNDICE: 10 COM VALOR DE: 1,9
==========================================================
VALOR (10) de (10): 1,9
ÍNDICE ANTERIOR: 9 COM VALOR DE: 1,8
==========================================================

O comando de DELETE, efetua a limpeza de todos os elementos do VARRAY, ou seja, não será possível acessar mais nenhuma informação do VARRAY, pois estará sem nenhum elemento para ser acessado.

Exemplo 09:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(10) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 

BEGIN 
  VMY_VARRAY.DELETE;
  DBMS_OUTPUT.pUT_LINE('QUANTIDADE DE ELEMENTOS: ' || VMY_VARRAY.COUNT);  

END;

Resultado 09:

Bloco anônimo concluído

QUANTIDADE DE ELEMENTOS: 0

O comando EXTEND permite que o VARRAY seja estendido em seus elementos até o limite do seu tamanho máximo especificado, ou seja, se possuímos um VARRAY de 15 posições, mas é utilizado apenas 10 posições, então neste caso é possível estender o VARRAY por mais 5 posições. Pode-se definir também a quantidade de posições que o VARRAY deverá se estender, não devendo ultrapassar a quantidade limite. Por padrão do PL/SQL é a quantidade a estender é 1, caso não seja especificado nenhum valor no seu parâmetro.

Para o comando EXTEND, também poderá ser definido o valor padrão para os elementos que estão sendo criados, replicando para estes valores para as demais posição que forem estendidas. O valor que o EXTEND assumirá será com base na posição do elemento existente.

Para descobrir qual o tamanho do limite de elementos que um VARRAY possuí, basta utilizar o comando LIMIT, que retorna um valor do tipo inteiro referente ao tamanho do vetor definido na declaração do tipo do objeto.

Mas se caso ocorra da quantidade estendida ultrapassar o valor limite do tipo de objeto, será mostrado um erro de banco de dados, informando que a quantidade de elementos ultrapassou o limite do tamanho definido. Os exemplos abaixo mostrarão todas estas situações.

Exemplo 10:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(15) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9);   

BEGIN   
  DBMS_OUTPUT.pUT_LINE('QUANTIDADE DE ELEMENTOS: ' || VMY_VARRAY.COUNT);     
  VMY_VARRAY.EXTEND;      
  DBMS_OUTPUT.pUT_LINE('NOVA QUANTIDADE DE ELEMENTOS: ' || VMY_VARRAY.COUNT);     

END;

Resultado 10:

bloco anônimo concluído

QUANTIDADE DE ELEMENTOS: 10
NOVA QUANTIDADE DE ELEMENTOS: 11

Exemplo 11:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(15) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 
  iCOUNT INTEGER := 1;

BEGIN 
  WHILE iCOUNT <= VMY_VARRAY.LIMIT LOOP
    IF iCOUNT = 10 THEN 
      VMY_VARRAY.EXTEND(5);      
      DBMS_OUTPUT.pUT_LINE('TAMANHO DO VETOR ESTENDIDO PARA MAIS 5 POSIÇÕES');         

    END IF;

    DBMS_OUTPUT.pUT_LINE('VALOR (' || iCOUNT || ') de (' || VMY_VARRAY.COUNT || '): ' || VMY_VARRAY(iCOUNT));   

    iCOUNT := iCOUNT + 1;

  END LOOP;

END;

Resultado 11:

Bloco anônimo concluído

VALOR (1) de (10): 1
VALOR (2) de (10): 1,1
VALOR (3) de (10): 1,2
VALOR (4) de (10): 1,3
VALOR (5) de (10): 1,4
VALOR (6) de (10): 1,5
VALOR (7) de (10): 1,6
VALOR (8) de (10): 1,7
VALOR (9) de (10): 1,8

TAMANHO DO VETOR ESTENDIDO PARA MAIS 5 POSIÇÕES

VALOR (10) de (15): 1,9
VALOR (11) de (15): 
VALOR (12) de (15): 
VALOR (13) de (15): 
VALOR (14) de (15): 
VALOR (15) de (15):

Exemplo 12:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(15) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 
  iCOUNT INTEGER := 1;

BEGIN 
  WHILE iCOUNT <= VMY_VARRAY.LIMIT LOOP
    IF iCOUNT = 10 THEN 
      VMY_VARRAY.EXTEND(5,5);      
      DBMS_OUTPUT.pUT_LINE('TAMANHO DO VETOR ESTENDIDO PARA MAIS 5 POSIÇÕES');         

    END IF;

    DBMS_OUTPUT.pUT_LINE('VALOR (' || iCOUNT || ') de (' || VMY_VARRAY.COUNT || '): ' || VMY_VARRAY(iCOUNT));   

    iCOUNT := iCOUNT + 1;

  END LOOP;

END;

Resultado 12:

Bloco anônimo concluído

VALOR (1) de (10): 1
VALOR (2) de (10): 1,1
VALOR (3) de (10): 1,2
VALOR (4) de (10): 1,3
VALOR (5) de (10): 1,4
VALOR (6) de (10): 1,5
VALOR (7) de (10): 1,6
VALOR (8) de (10): 1,7
VALOR (9) de (10): 1,8

TAMANHO DO VETOR ESTENDIDO PARA MAIS 5 POSIÇÕES

VALOR (10) de (15): 1,9
VALOR (11) de (15): 1,4
VALOR (12) de (15): 1,4
VALOR (13) de (15): 1,4
VALOR (14) de (15): 1,4
VALOR (15) de (15): 1,4

Exemplo 13:

SET SERVEROUTPUT ON;

DECLARE
  TYPE tMY_VARRAY IS VARRAY(15) OF NUMBER(4,2);
  VMY_VARRAY tMY_VARRAY :=  tMY_VARRAY(1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9); 
  iCOUNT INTEGER := 1;

BEGIN 
  WHILE iCOUNT <= VMY_VARRAY.LIMIT LOOP
    IF iCOUNT = 10 THEN 
      VMY_VARRAY.EXTEND(10,5);      
      DBMS_OUTPUT.pUT_LINE('TAMANHO DO VETOR ESTENDIDO PARA MAIS 5 POSIÇÕES');         

    END IF;

    DBMS_OUTPUT.pUT_LINE('VALOR (' || iCOUNT || ') de (' || VMY_VARRAY.COUNT || '): ' || VMY_VARRAY(iCOUNT));   

    iCOUNT := iCOUNT + 1;

  END LOOP;

END;

Resultado 13:

ORA-06532: Subscrito além do limite
ORA-06512: em line 8
06532. 00000 -  "Subscript outside of limit" 

*Cause:    A subscript was greater than the limit of a varray or non-positive for a varray or nested table.
*Action:   Check the program logic and increase the varray limit if necessary.

No próximo artigo será abordado as matrizes associativas (Associatives Arrays).

Referências

  • FURTADO, Gustavo. O QUE SÃO VETORES E MATRIZES (ARRAYS). DICAS DE PROGRAMAÇÃO. 2005.
  • LUSCHER, Lenore. ORACLE9i, DATABASE PERFORMANCE TUNING GUIDE AND REFERENCE – RELEASE 2 (9.2). – A96533-01. 2002.
  • MOORE, Sheila. ORACLE® DATABASE PL/SQL LANGUAGE REFERENCE 11g RELEASE 1 (11.1) – B28370-05. 2009.
  • BURLESON, Don. ORACLE VARRAY EXAMPLES. 2008.

AGRADECIMENTOS

FABIO PELICER

ALEXANDRE PIETROBELLI

Abraços.

Share

You may also like...

Deixe um comentário

O seu endereço de e-mail não será publicado.