Introducción a TSQL

Unidad 12

Autor
Isabel Ponce
Unidad 12

Objetivos

• Lenguaje de Programación
– Control de flujo
• Lotes
• Comentarios
• declare
– Tipos de datos
– Variables locales
– Variable globales
• begin…end
• if…else
• case
• while…
• return
Lenguajes de
Programación

• SQL es, por definición, un lenguaje

orientado a conjuntos no a variables;
no procedural, sino transaccional.

• SQL Server, Oracle y MySQL

soportan las características estándar
de SQL, con mejoras en sus
lenguajes interactivos. Sin embargo,
además de esto, todos ellos
proporcionan estructuras de control
que permiten generar programas tipo
lotes (batch).

• Estas estructuras de control son

parte de los lenguajes de
programación o de control de flujo
de Transact-SQL de SQL Server, PL/
SQL de Oracle, y MySQL.
Lenguajes de
Programación

• Como lenguaje de consulta, SQL fue

concebido originalmente para usarse
interactivamente por usuarios
relativamente sofisticados que
estuvieran interesados en obtener
información inmediata vía la consulta
de BD.

• Sin embargo, el poder de un

lenguaje relacional es tal, que su
uso no debería limitarse a esta
aplicación, ya que tiene gran poder y
utilidad aplicándose a tareas
tradicionales de programación.

• Esto se obtiene mediante un

lenguaje de programación de DB o
de control de flujo para BD.
Lenguajes de
Programación

• Como lenguaje de programación de BD,

MySQL tiene las siguientes
características:

– comentarios
– declare
– begin…end
– if…else
– case
– loop...end loop
– repeat ...end repeat
– while…end while
– iterate
– leave
– return

• El lenguaje de control de flujo permite

que las instrucciones estén conectadas,
se relacionen entre ellas y se hagan
interdependientes con construcciones
similares a las de la programación.
Lotes

• La mayoría de las instrucciones

SQL tienen la habilidad de ser
ejecutadas en lote.

• Un lote es un grupo de
instrucciones SQL ejecutadas
al mismo tiempo.

• El lote es enviado al servidor y

procesado por el mismo.

• Si existe un error en alguna

instrucción del lote, esa
instrucción no se ejecuta y el
resto continua.
Lotes

• Ejemplo:

select title from titles

select au_lname from authors
select stor_name from stores

title

------------------------------------------------------------------
The Busy Executive's Database Guide

Cooking with Computers: Surreptitious Balance Sheets

You Can Combat Computer Stress!

Straight Talk About Computers

Silicon Valley Gastronomic Treats

The Gourmet Microwave

The Psychology of Computer Cooking

But Is It User Friendly?

...
(18 row(s) affected)

au_lname
----------------------------------------
White
Green
Carson
O'Leary
Straight
...
(23 row(s) affected)

stor_name
Comentarios

• Se pueden agregar comentarios a

cualquier Lote SQL para mejorar
la lectura y documentar el lote..

• Existen dos formas de

comentarios: /*…*/ y #

/* Los comentarios incluidos entre

estos delimitadores pueden
expandirse a múltiples líneas. Sin
límite */

#El gatito debe preceder a

#cada línea de comentario
Tipos de Datos

• Todas las piezas de datos en

una BD tienen un tipo de dato
específico.

• Cada columna se define con un

tipo de dato específico.

• Esto significa que si una

columna se define como un tipo
de dato entero, no se puede
introducir un carácter
alfabético.
Variables

• Las variables en SQL pueden

tener dos tipos de alcances:
local y global.

• Todas las variables que crea un

usuario tienen alcance local.

• Las variables globales son

reservadas para uso de SQL y
sólo deben ser asignadas por el
DBA.

• También se llaman de sesión e

inician con @.
Variables Locales

• Las variables locales son

– Definidas por el usuario

– Creadas usando declare
– Tienen un nombre y tipo de dato
– Son inicializadas a nulo al
crearlas
– Pertenecen al lote, bloque,
procedimiento almacenado, UDF,
o disparador que se esté
declarando

declare <nombre_variable> <tipo>

[default <valor>];

declare mivar char(10);

Variables Locales

• Los nombres de variables pueden

tener hasta 30 caracteres de
longitud, y no pueden ser palabras
reservadas.

• Para asignar valores a las variables,

se usa set:

set <variable> = <expresión>

[, <variable> = <expresión>]…

DELIMITER //
CREATE PROCEDURE proc1 ()
BEGIN
DECLARE a INT;
DECLARE b INT;
SET a = 5;
SET b = 5;
SELECT a, b, a * b;
END; //
Variables Locales

• Las variable pueden ser

asignadas con literales o una
expresiones.

• Las variables son escalares,

contienen exactamente un
valor.

• Pueden ser usadas en lugar de

valores literales o expresiones.

• No pueden usarse en lugares

de nombres de tablas, nombres
de columnas, u otros objetos de
la BD.
Variables Locales

• Las variables locales se usan

para gran variedad de cosas en
SQL, entre ellas:

– Se pueden realizar saltos

condicionales en base a los
valores de variables.
– Pasar valores a y desde un
procedimiento almacenado.
– Eliminar la necesidad de usar
subconsultas para funciones
de agregado.
– Reutilizar constantes a través
de un lote.
– Retornan mensajes persona-
lizados al usuario.
Control de Flujo

• Ningún lenguaje puede estar

completo sin la habilidad de saltar
a otras partes del código o
realizar varias veces una tarea.
• MySQL lo permite mediante un
pequeño conjunto de
construcciones:
– begin…end
– if…else...end if
– case...when...then...else...end
– while…end while
– repeat ...until...end repeat
– loop...end loop
– iterate...<etiqueta>
– leave ...<etiqueta>
– return
Control de Flujo

• begin…end agrupa instrucciones en

un bloque.

• if…else permite ejecutar instrucciones

condicionales.

• case facilita el anidamiento de

condiciones.

• loop, repeat y while repiten un

conjunto de comandos.

• leave detiene la ejecución de un ciclo y

sale de él.

• return sale de un lote.

• iterate repite un ciclo saltando a una

etiqueta definida por el usuario.
begin…end

• Begin…end se emplea para

definir bloques de instruc-
ciones a tratar juntas.

• Un bloque se indica:

begin
<instrucción>*
end

begin
select title from titles;
select au_lname from authors;
select stor_name from stores;
end;
if…else

if <expresión_lógica> then
<instrucción>
[elseif <expresión_lógica>] then
<instrucción>]
[else <instrucción>]
end if

• Una expresión lógica se evalúa

como falsa o verdadera.

• La expresión lógica controla la

ejecución de una instrucción if y
puede incluir: literales, variables
locales y subconsultas.

• La expresión lógica puede ser una

subconsulta que debe retornar un
sólo valor y debe estar encerrada
entre paréntesis.
if…else

create procedure proc1()

begin
if (select avg(price) from tmptitles)<15 then
update tmptitles set price = price * 2;
else
update tmptitles set price = price * 1.1;
end if;
end;

• La cláusula else es opcional

• Los nombres de columnas sólo se

pueden incluir como parte de la
subconsulta.

• No hay límite para el anidamiento.

if…else

create procedure proc2()

begin
declare nada varchar(30);
if (select avg(price) from titles
where type = 'mod_cook') < 15 then
select ‘Los siguientes libros son buenos’;
select substring(title, 1, 35) as title
from titles
where type = ‘mod_cook’;
else
if (select avg(price) from titles
where type = ‘mod_cook’) > 15 then
select ‘Los siguientes son libros caros’;
select substring(titile, 1, 35) as title
from titles
where type = ‘mod_cook’;
end if;
end if;
end;
if [not] exists

• Usar exists y no exists es útil cuando

sólo se desea saber si existen datos.
create procedure proc3()
begin
declare name varchar(30);
set name = 'Smith‘;
if exists (select * from authors
where au_lname = name) then
select “Hay una coincidencia“;
else
select “No hay coincidencia“;
end if;
end;

• Una condición exists detiene el

procesamiento tan pronto como
encuentra la primera coincidencia.
Por eso, es muy útil para forzar la
integridad referencial.
case

• Una instrucción Case es una forma de

compactar expresiones anidadas if…
else.

select …, case
<columna_a_trasnformar>
when <expBúsqueda1> then
<expReemplazo1>
…
when <expBúsquedaN> then
<expReemplazoN>
[else <expRemplazoContrario>]
end [as <alias>]
case

• Ejemplo:

select case type

when 'popular_comp' then ‘computación popular‘
when 'mod_cook' then ‘cocina moderna‘
when 'business' then ‘administración‘
when 'psychology' then ‘psicología‘
when 'trad_cook' then ‘cocina tradicional‘
else ‘sin categoría‘
end as categoria, substring(title, 1, 30), price precio
from titles
where price is not null
order by type;
case

• Case ofrece una sintaxis alterna que no

usa una expresión inicial. En vez de
eso, se evalúan una o más expresiones
lógicas, retornando la expresión
resultante cuando son verdaderas.

select …, case
when <expLógica1> then
<expReemplazo1>
…
when <expLógicaN> then
<expReemplazoN>
[else <expRemplazoContrario>]
end [as <alias>]
case

• Ejemplo:

select job_id, job_desc,

case
when job_desc = 'Sales Representative‘
then 'Oficina A‘
when (job_desc = 'Marketing Manager‘
or job_id = 10)
then ‘2º. Piso‘
when job_desc like 'C%' then ‘3er. Piso‘
else 'Oficina B‘
end as 'Ubicación‘
from jobs;
Resultados Case

job_id job_desc Ubicación

------ ------------------------------ ------------
1 New Hire - Job not specified Oficina B
2 Chief Executive Officer Tercer Piso
3 Business Operations Manager Oficina B
4 Chief Financial Officier Tercer Piso
5 Publisher Oficina B
6 Managing Editor Oficina B
7 Marketing Manager Segundo Piso
8 Public Relations Manager Oficina B
9 Acquisitions Manager Oficina B
10 Productions Manager Segundo Piso
11 Operations Manager Oficina B
12 Editor Oficina B
13 Sales Representative Oficina A
14 Designer Oficina B

(14 filas afectadas)

case

• También es posible emplearlo fuera de

una instrucción select.

create procedure p4 (IN parametro1 INT)

begin
declare variable1 INT;
set variable1 = parametro1 + 1;
CASE variable1
WHEN 0 THEN insert into t2 values (17);
WHEN 1 THEN insert into t2 values (18);
ELSE insert into t2 values(19);
END CASE;
end; //
while

• While se usa para ejecutar un bloque

de instrucciones repetidamente,
mientras la expresión lógica sea
verdadera.

[<etiquetaX>] while <exp_lógica>

do
<bloque de instrucciones a
ejecutar mientras la condición
sea verdadera>
end while [<etiquetaX>];

create procedure p5()

begin
while (select avg(c1) from t2) < 40 do
update t2 set c1 = c1 + 2;
select avg(c1) from t2;
end while;
end;
while

CREATE PROCEDURE p6 ()
BEGIN
DECLARE v INT;
SET v = 0;
WHILE v < 5 DO
INSERT INTO t2 VALUES (v);
SET v = v + 1;
END WHILE;
END; //

• Los ciclos también pueden anidarse.

repeat

• Repeat realiza también un ciclo con la

diferencia de que la condición se verifica
después de ejecutar al menos una vez el
conjunto de instrucciones.

[<etiquetaX>] repeat
<Bloque de instrucciones a ejecutar
hasta que la condición sea
verdadera>
until <expresión lógica> end repeat
[<etiquetaX>] ;

create procedure p7()

begin
declare v int;
set v = 0;
REPEAT
insert into t2 values (v);
set v = v + 1;
UNTIL v >= 5 END REPEAT;
end;
loop

• Loop es otra forma de crear un ciclo, a

diferencia de while y repeat, loop no
necesita una condición al principio o final
del conjunto de instrucciones, en vez de
eso emplea un if-leave.

[<etiquetaX>] loop
<Bloque de instrucciones que incluyen if -
leave>
end loop [<etiquetaX>] ;
create procedure p8()
begin
declare v int;
set v = 0;
etiqueta_ciclo: LOOP
insert into t2 values (v);
set v = v + 1;
if v >= 5 then
LEAVE etiqueta_ciclo;
end if;
END LOOP;
end;
leave e iterate

• Se pueden controlar las instrucciones en

un ciclo mediante leave o iterate.

• leave sale del ciclo más interno, pero no

del lote.

• iterate reinicia el procesamiento al inicio

del ciclo más interno.
create procedure p9()
begin
etiqueta1: while (select avg(c1) from t2) > 20 do
update t2 set c1 = c1 – 2;
if (select max(c2) from t2) < 40 then
leave etiqueta1;
else
if (select avg(c1) from t2) > 20 then
iterate etiqueta1;
end if;
end if;
end while etiqueta1;
end;
returns

• Returns se usa para terminar la

ejecución de una función y retorna el
valor especificado después de la
instrucción.
• En todas las funciones debe existir al
menos una instrucción return, pero
pueden haber varias.
• Return no se usa en procedimientos
almacenados ni disparadores.
if not exists
(select 1 from titles where title_id =
param)
begin
select “No existe ese título"
returns 0;
end
insert into detalleVentas...
Resúmen Unidad 12

• Los lotes consisten de más de una

instrucción SQL.

• Se pueden agregar comentarios de

dos formas: /*…*/ o #…

• Las variables pueden ser locales y

globales.

• Las variables locales se crean y

manejan por el usuario y se declaran
dentro de rutinas.

• Set se usa para asignar un valor a

una variable local.
Resúmen Unidad 9

• El control de flujo en los lotes puede

realizarse con las construcciones
principales.
– begin…end
– if…else
– case
– while…
– repeat...
– loop...
– leave y iterate
– return
Ejercicios

1. Crear un lote que muestre, en el

conjunto de resultados de la
consulta, el nombre completo del
estado en el que vive cada autor y
el nombre del autor.
2. Crear un lote que obtenga una lista
de libros de cocina tradicionales,
con un precio entre 10$ y 20$,
cuando al menos un libro cumpla
las condiciones que se indican. De
lo contrario, imprimir un mensaje
que indique que no hay ningún libro
que cumpla la condición y genere
una lista de libros de cocina que
cuesten menos de 10$.