Hemos visto en los conceptos anteriores las instrucciones de MySQL que nos permiten definir estructuras condicionales dentro de los procedimientos almacenados. Ahora veremos que comandos disponemos para repetir bloques de instrucciones.
La primer estructura repetitiva que disponemos y es común a la mayoría de los lenguajes de programación es el 'while'.
while
La sintaxis es la siguiente:
while [condición] do [instrucciones] end while;
El bloque de instrucciones encerrado entre while y end while se repite mientras la condición se verifique verdadera.
Problema
Confeccionar un procedimiento almacenado que nos retorne dos valores aleatorios distintos comprendidos entre 0 y 10.
drop procedure if exists pa_generar_dos_aleatorios;
delimiter //
create procedure pa_generar_dos_aleatorios(
out valor1 int,
out valor2 int)
begin
set valor1=0;
set valor2=0;
while valor1=valor2 do
set valor1=rand()*10;
set valor2=rand()*10;
end while;
end //
delimiter ;
call pa_generar_dos_aleatorios(@v1,@v2);
select @v1,@v2;
El procedimiento almacenado 'pa_generar_dos_aleatorios' recibe dos parámetros de salida que debemos inicializarlos.
Previo al while cargamos el valor 0 a cada parámetro:
set valor1=0; set valor2=0;
La primera vez que se ejecuta la condición del while se verifica verdadera ya que ambos parámetros almacenan el cero.
Dentro del while y llamando a la función rand() generamos dos valores aleatorios comprendidos entre 0 y 10:
set valor1=rand()*10;
set valor2=rand()*10;
En el caso que los dos valores aleatorios generados sean iguales la condición del while seguirá verificándose verdadera y se volverán a generar otros dos valores aleatorios. El while finaliza cuando los dos valores aleatorios son distintos.
La ejecución de este procedimiento almacenado genera la siguiente salida:
repeat
La sintaxis es la siguiente:
repeat [instrucciones] until [condición] end repeat;
El bloque de instrucciones encerrado entre repeat y end repeat se ejecuta hasta que la condición del until se verifica verdadera.
Tener en cuenta que debemos pensar la condición de corte del bloque repetitivo con una condición contraria al while. El while se repite mientras la condición se verifica verdadera y el repeat se repite hasta que la condición sea verdadera.
La estructura repetitiva repeat es conveniente utilizarla cuando el bloque a repetir se debe ejecutar por lo menos una vez.
Problema
Confeccionar un procedimiento almacenado que nos retorne dos valores aleatorios distintos comprendidos entre 0 y 10.
drop procedure if exists pa_generar_dos_aleatorios;
delimiter //
create procedure pa_generar_dos_aleatorios(
out valor1 int,
out valor2 int)
begin
repeat
set valor1=rand()*10;
set valor2=rand()*10;
until valor1<>valor2
end repeat;
end //
delimiter ;
call pa_generar_dos_aleatorios(@v1,@v2);
select @v1,@v2;
Hemos resuelto el algoritmo de generar los dos valores aleatorios distintos utilizando la estructura repetitiva 'repeat' donde controlamos que se vuelvan a generar hasta que los mismos sean distintos.
Como vemos es más conveniente y conciso el algoritmo utilizando la estructura repetitiva 'repeat' en lugar del 'while'.
loop
La tercer estructura repetitiva que nos suministra MySQL se llama 'loop'. Este tipo de estructura repetitiva encierra un bloque de instrucciones entre los comandos 'loop' y 'end loop'.
Para finalizar el bloque encerrado por los comandos 'loop' y 'end loop' debemos ejecutar el comando 'leave' e indicar una etiqueta definida previa al comando 'loop'.
La sintaxis es la siguiente:
[etiqueta]:loop [instrucciones] end loop;
Problema
Confeccionar un procedimiento almacenado que nos retorne dos valores aleatorios distintos comprendidos entre 0 y 10.
drop procedure if exists pa_generar_dos_aleatorios;
delimiter //
create procedure pa_generar_dos_aleatorios(
out valor1 int,
out valor2 int)
begin
etiqueta1:loop
set valor1=rand()*10;
set valor2=rand()*10;
if valor1<>valor2 then
leave etiqueta1;
end if;
end loop;
end //
delimiter ;
call pa_generar_dos_aleatorios(@v1,@v2);
select @v1,@v2;
Es importante que en algún momento de la ejecución de las instrucciones contenidas entre loop y end loop se ejecute el comando leave, de no ser así estamos en presencia de una estructura repetitiva infinita.