Utilizando Vetores e Matrizes com PLSQL - VARRAY

Prévia do material em texto

USING COLLECTIONS AND RECORDS (PARTE 01) – VARRAY 
Do que se trata este artigo
	Trata-se de um artigo de como utilizar as coleções e as variáveis de registros do PL/SQL.
Em que situação o tema é útil:
	Esta é uma técnica de programação muito utilizada nos casos em que o desenvolvedor necessita armazenar uma coleção de dados, como uma tabela virtual, por exemplo. Alocando um espaço na memória do servidor e acessando-o posteriormente, podendo tornar o próprio desenvolvimento mais eficiente e mais eficaz. E tratando-se de um espaço na memória e não no disco (seja ele rígido ou sólido), dispensando a necessidade de gravação, leitura e limpeza do espaço no disco, onde é muito mais ineficiente (mesmo sendo um disco SSD) comparando com o desempenho que se obtém pela memória.
	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ém no 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 (servem també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;
Resultado02:
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 seuparâ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 10:
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.