INTRODUCCIN

MySQL es el mayor sistema gestionador de bases de datos de codigo abierto SQL, es

desarrollado, distribuido y mantenido por MySQL AB. MySQL AB es una compaa
comercial,
fundada
por
desarrolladores
de MySQL.
MySQL es una base de datos relacional y fue originalmente desarrollado para manejar
grandes bases de datos mucho ms rpido que con otras soluciones existentes y ha sido
utilizada con xito en muchos entornos de produccin de alta demanda durante varios aos. A
pesar del constante desarrollo, el Servidor MySQL ofrece hoy en da una rica y til serie de
funciones. Su conectividad, velocidad y seguridad hacen del Servidor MySQL altamente
apropiado para acceder a bases de datos en Intenet.
MySQL es el ms popular de cdigo abierto del sistema de gestin de bases de datos
relacionales (RDBMS).
TIPOS DE DATOS :
Definicin: Tipos de Datos es la caracterstica de las columnas y variables que definen que
tipos de valores de datos pueden albergar. La caracterstica indica cuando un dato
representa un nmero, fecha, un carcter string, etc.
Los tipos de Datos son usados para indicar el tipo de campo que estamos creando en la tabla.
MySQL soporta un nmero de tipos de datos en tres categoras importantes:

Tipos Numricos
Tipos de Fecha y Hora
Tipos String(Carcter)

Antes de crear una tabla, identifica si en la columna debe ir un texto, un nmero o un tipo de
fecha. Cada columna en una tabla est hecha de tipos de datos. El tamao del valor deber ser el
valor ms pequeo dependiendo del valor ms grande.
Por ejemplo, si el nmero de estudiantes de un colegio est en cientos, establece la columna con
una cifra de tres dgitos SMALLINT(permitiendo hasta 999 valores).
Debemos ser conscientes de que si insertamos un string de cinco caracteres en un campo de (3)
caracteres, los dos caracteres finales sern truncados. Es mejor establecer una longitud para texto
y nmero de columnas as como otros atributos como UNSIGNED.
Los corchetes ('[' y ']') indican partes optionales del tipo de definiciones. Ahora nos iremos
levemente a una visin general de los tipos de datos MySQL.
TIPOS DE DATOS NUMRICOS :
Los tipos de datos numricos son como sigue:

BIT
TINYINT
BOOLEAN
SMALLINT
MEDIUMINT

INT

INTEGER
BIGINT
FLOAT
DOUBLE
DECIMAL
Vamos a ver los tipos de datos numricos de manera abreviada.
BIT :
BIT es un sinnimo de TINYINT(1). TINYINT[(M)] :
Un nmero entero muy pequeo. El rango suscrito va de -128 a 127. El rango no suscrito va de 0
a 255.
BOOL, BOOLEAN :
Estos tipos son sinnimos de TINYINT(1). Un valor para cero es considerado falso. Valores que
no sean cero son considerados verdad.
SMALLINT :
Un nmero entero pequeo. El rango suscrito va de -32768 a 32767. El rango no suscrito
va de 0 a 65535.
MEDIUMINT :
Un nmero entero de tamao medio. El rango suscrito va de -8388608 a 8388607. El rango
no suscrito va de 0 a16777215.
INT :
Un nmero entero de tamao normal. El rango suscrito va de - 2147483648 to
2147483647. El rango no suscrito va de 0 a4294967295.
INTEGER :
Este tipo es sinnimo de INT. BIGINT :
Un nmero entero grande. El rango suscrito va de - 9223372036854775808 a
9223372036854775807. El rango no suscrito va de 0 a 18446744073709551615.
FLOAT :
Un nmero punto flotante pequeo (simple precisin). Los valores van de
3.402823466E+38 a -1.175494351E-38, 0, y1.175494351E- 38 a
3.402823466E+38.

DOUBLE :
Un nmero punto flotante normal (doble precisin). Los valores van de
1.7976931348623157E+308 a-2.2250738585072014E-308, 0, y
2.2250738585072014E-308 a 1.7976931348623157E+308.
DECIMAL :
El nmero mximo de dgitos (M) para DECIMAL es 64.
TIPOS DE DATOS FECHA Y HORA :
DATE
TIME
DATETIME
TIMESTAMP
YEAR
DATE :
Una Fecha. El rango es 1000-01-01 a 9999-12-31. Los valores de fecha se muestran con el
formato YYYY-MM-DD (Ao-Mes-Da).
TIME :
Una Hora. El rango es -838:59:59 a 838:59:59. Los valores de hora se muestran con el formato
HH:MM:SS.
DATETIME :
Una combinacin de Fecha y Hora. El rango es 1000-01-01 00:00:00 a 9999-12-31 23:59:59. Los
valores fecha hora son mostrados en formato YYYY-MM-DD HH:MM:SS.
TIMESTAMP :
Una Marca de Tiempo. El rango es 1970-01-01 00:00:01 UTC hasta parcialmente el ao
2037. Una columna TIMESTAMP es tila para grabar la fecha y hora de una operacin INSERT
o UPDATE.
YEAR :
Un Ao. Los valores de ao son mostrados en formato de dos dgitos o de cuatro. El rango de
valores para un dgito de cuatro es 1901 a 2155. Para los dos dgito, el rango
es 70 a 69, representando aos desde 1970 a 2069.
Para todas la columnas de fecha y hora, podemos asignar tambin los valores usando strings o
nmeros.

TIPOS DE DATOS DE CADENAS:

CHAR
VARCHAR
TINYTEXT
TEXT
BLOB
MEDIUMTEXT
LONGTEXT
BINARY
VARBINARY
ENUM
SET
CHAR() :
Es un string de longitud fija que es principalmente usado cuando los datos no van a variar
mucho en su longitud. Toma valores de 0 a 255 de longitud de caracteres. Cuando almacenamos
valores CHAR ellos estn rellenos correctamente con espacios de la longitud especfica. Cuando
obtenemos valores CHAR, los espacios finales son eliminados.
VARCHAR() :
Es una variable string de longitud y es usada principalmente cuando los datos pueden variar
en longitud. Toma valores de 0 a255 de longitud de caracteres. Los
valores VARCHAR no son rellenados cuando son ms cortos.
TINYTEXT, TINYBLOB :
Un string con una longitud mxima de 255 caracteres.
TEXT :
Las columnas TEXT son tratadas como caracteres string (strings no binarios). Contiene una
longitud mxima de 65535caracteres.
BLOB :
BLOB es el acrnimo de Binary Large OBject (Objeto Binario Grande). Puede tener un
montn de datos variables. Las columnas BLOB son tratadas como string de bytes (string
binarios). Contiene una longitud mxima de 65535.

MEDIUMTEXT, MEDIUMBLOB :
Tiene una longitud mxima de 16777215 caracteres.
LONGTEXT, LONGBLOB :
Tiene una longitud mxima de 4294967295 caracteres.
BINARY :

BINARY es similar al tipo CHAR. Almacena el valor como string de byte binario en vez de
como un caracter string no binario
VARBINARY :
VARBINARY es similar al tipo VARCHAR. Almacena el valor como un string de bytes binario en
vez de como un caracter string no binario.
ENUM() :
Una enumeracion. Cada columna puede tener uno de los posibles valores especificados. Puede
almacenar solo uno de los valores que estn declarados en la lista especfica contenida en los
parntesis ( ). La lista ENUM tiene un alcance de ms de65535 valores..
SET() :
Un set. Cada columna puede tener ms de uno de los posibles valores especificados.
Contiene ms de 64 objetos de lista y puede almacenar ms de una opcin. Los valores SET
son representados internamente como nmeros enteros.

Si CHAR y VARCHAR son usados en la misma tabla, entonces MySQL cambiar

automticamente CHAR a VARCHAR por razones de compatibilidad. Los parntesis ( )
permiten introducir un mximo nmero de caractereces que sern usados en la columna.

OPERADORES :
Los operadores son usado para operar con dos operandos. Una amplia coleccin de Operadores
estn disponibles en MySQL. Los operadores precedentes son mostrados en esta tabla.
Preced. Mayor
1
2
3
4
5
6
7
8
9
10
11
12
Menor

:=
||, OR, XOR
&&, AND
BETWEEN, CASE, WHEN, THEN, ELSE
=, <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN
|
&
<<, >>
-, +
*, /, DIV, %, MOD
^
- (unary minus), ~ (unary bit inversion)
!, NOT
BINARY, COLLATE

CONVERSIN :
Tipo de conversin tiene lugar cuando los operadores son usados con diferentes tipos de
operandos en una expresin. Algunas conversiones son hechas implcitamente y algunas

necesitan conversiones explcitas.

En MySQL los nmeros son convertidos a strings y algunas veces los strings en nmeros
dependiendo de la condicin.
Consideremos un ejemplo parar convertir un string en un entero.
mysql> Select 1+'11';
--> 12
Aqu el string '11' es convertido a nmero y el resultado de la expresin es tambin un nmero.
Veamos otro ejemplo para convertir un entero en un string.
mysql> select concat(1, ' HIOX');
--> '1 HIOX'
No podemos convertir fundir un nmero en un string explicitamente. Aqu usamos la funcin
CAST() o CONCAT().
mysql> select 12, cast(12 as char);
--> 12, '12'
mysql> select 12, concat(12);
--> 12, '12'
OPERADORES LGICOS :
MySQL soporta las siguientes operaciones lgicas :

Operado AND(&&)
Operador OR(||)
Operador NOT(!)

OPERADORES DE COMPARACIN:
El operador de comparacin es usado para comparar expresiones o valores. El resultado de
comparacin ser o Verdadero (1) o Falso (0). MySQL admite los siguientes operadores de
comparacin:
EQUAL(=)
LESS THAN(<)

LESS THAN OR EQUAL(<=)

GREATER THAN(>)
GREATER THAN OR EQUAL(>=)
NOT EQUAL(<>,!=)
BETWEEN
GREATEST
FUNCIONES DEL SISTEMA FUNCIONES MATEMTICAS
ABS
ACOS
ASIN
ATAN

CEIL
COS
COT
DEGREES
EXP
FLOOR
FORMAT
LN
LOG
LOG(B,X)
LOG2
LOG10
MOD
PI
POWER
RADIANS
RAND
ROUND
SIGN
SIN
SQRT
TAN
TRUNCATE
Ahora vamos a ver algunas funciones Matemticas con un ejemplo.
ABS(X) :
Esta funcin devuelve el valor Absoluto para el valor dado.
mysql> select abs(5);
--> 5
mysql> select abs(-25);
--> 25
ACOS(X) :
Devuelve el valor arco coseno de el nmero dado.
mysql> select acos(0);
--> 1.5707963267949
mysql> select acos(1);
--> 0
ASIN(X) :
Devuelve el valor arco seno para el nmero dado.
mysql> select asin(1);
--> 1.5707963267949

mysql> select asin(0);

--> 0
ATAN(X) :
Devuelve el valor de la arcotangente para el valor dado.
mysql> select atan(1);
--> 0.78539816339745
mysql> select atan(2);
--> 1.1071487177941
CEIL(X) or CEILING(X) :
Devuelve el nmero entero ms pequeo ms prximo al valor dado pero no inferior a este.
mysql> select ceil(1.14);
--> 2
mysql> select ceiling(-1.14);
--> -1
COS(X) :
Devuelve el Coseno de X, donde X viene dado en radianes.
mysql> select cos(pi());
--> -1
mysql> select cos(0);
--> 1
COT(X) :
Devuelve el valor de la cotangente de X.
mysql> select cot(1);
--> 0.64209261593433
mysql> select cot(45);
--> 0.61736962378356
FUNCIONES DE CADENAS
Las funciones son sets predefinidos de instrucciones que devuelven un valor. Las funciones
referentes a strings son llamados funciones String. Hay diferentes tipos de funciones disponibles en
MySQL.
Las funciones string importantes son,
CHAR_LENGTH
CONCAT
CONCAT_WS
FORMAT
LCASE
LENGTH
LOCATE
REPEAT

REPLACE
REVERSE
SUBSTRING
CHAR_LENGTH(str) or CHARACTER_LENGTH(str) :
Esta funcin string devuelve la longitud del string.
mysql> select char_length("hioxindia");
--> 9
mysql> select character_length("easycalculation");
--> 15
CONCAT(str1,str2,...) :
Devuelve el string concatenado de los argumentos dados.
mysql> select concat('hiox','india');
--> 'hioxindia'
CONCAT_WS() :
Acrnimo de Concatenate With Separator (Concatenado Con Separador) y es una forma
especial de funcin CONCAT. Devuelve el string concatenado de los argumentos dados separado
por un separador dado.
mysql> SELECT CONCAT_WS('!','One','Two','Three');
--> 'One!Two!Three'
( Here '!' is the seperator)
FORMAT() :
Formatea el n dado y redondea a los dgitos dados despues del punto decimal.
mysql> SELECT FORMAT(12332.123456, 4);
--> '12,332.1235'
LCASE(str) or LOWER() :
Devuelve la minscula del string dado.
mysql> select lcase('HIOX');
--> 'hiox'
mysql> select lower('EASYCALCULATION');
--> easycalculation
De la manera que UPPER o UCASE devuelve la mayscula del string dado.
LENGTH(str) :
Devuelve la longitud del string dado en bytes. Si hay un caracter de 2 byte la longitud es
calculada como 2. Donde CHAR_LENGTH calcula solo la longitud del caracter.
mysql> select length('HIOXINDIA');
--> 9
LOCATE(substr,str) or POSITION(substr IN Str) :
Devuelve la posicin de la primera aparicin del substring en el string.
mysql> select locate('ind','hioxindia');
--> 5

mysql> select position('cul' in 'easycalculation');

--> 8
REPEAT(str,count) :
El string dado es repetido para la cuenta dada.
mysql> select repeat('HIOX',2);
--> 'HIOXHIOX'
REPLACE(str,from_str,to_str) :
En el string dado 'str' el 'from_str' es reemplazado por el string 'to_str'.
mysql> select replace('MyMYSql','My','you');
--> youMYSql
El 'from_str' es sensible a las maysculas. Aqu en el ejemplo superior la primera 'My' es
cambiada, pero no la segunda ('MY').
REVERSE(str) :
El string dado es revertido y devuelto.
mysql> select reverse('HIOX');
--> 'XOIH'
SUBSTRING(str,pos) :
La funcin devuelve un substring del string 'str' empezando en la posicin 'pos'.
mysql> select substring('EASYCALCULATION', 5);
--> 'CALCULATION'

FUNCIONES DE FECHA Y HORA

Esta funcin es usada para manipular el formato de muestra de una fecha y una hora. Vamos a
ver algunas funciones bsicas para fecha y hora.
CURDATE
CURTIME
DATEDIFF
DATE_ADD
DAYNAME
DAYOFMONTH
DAYOFWEEK
DAYOFYEAR
HOUR
MINUTE
MONTH
MONTHNAME
NOW
CURDATE() :
Esta funcin devuelve la fecha actual en formato 'YYYY-MM-DD' o 'YYYYMMDD' (Ao-Mes- Da)
mysql> select curdate();

--> 2007-01-03
CURTIME() :
Devuelve la hora actual en formato 'HH:MM:SS' o 'HHMMSS'.
mysql> select curtime();
--> 17:33:07
DATEDIFF(expression1,expression2) :
expression1 y expression2 son expresiones fecha o fecha-y-hora. Esta funcin devuelve
expression1 expression2 expresados como un valor en das de una fecha a la otra. Aqu slo las
partes de fecha sern consideradas para el clculo.
mysql> select datediff('2007-2-6 17:33:25','2007-1-1');
--> 36
DATE_ADD(fechahora, INTERVAL tipo expresin fechahora) :
Esta funcin de fecha aade la expresin a la datetime suministrada.
mysql> select date_add('2007-1-14', interval 15 day);
--> 2007-01-29
Esta funcin es la misma para DATE_SUB, pero tomar lugarsubstrayndola en vez de
aadindola.
DAYNAME(fecha) :
Devuelve el nombre del da para una fecha especificada.
mysql> select dayname('2007-01-04');
--> Thursday
DAYOFMONTH(fecha) or DAY(fecha) :
Devuelve la fecha para el da del mes en el rango de 1 a 31. DAY () es un sinnimo para
DAYOFMONTH().
mysql> select dayofmonth('2007-01-04');
--> 4
DAYOFWEEK(fecha) :
Devuelve el da de la semana en formato numrico como 1 para Domingo hasta 7 para
Sbado.
mysql> select dayofweek('2007-01-04');
--> 5
DAYOFYEAR(fecha) :
Devuelve el da del ao para la fecha dada en formato numrico, en rago de 1 a 366.
mysql> select dayofyear('2007-07-09');
--> 190
HOUR(hora) :
Devuelve la hora del tiempo especificado en formato numrico de 0 a 23.
mysql> select hour('14:46:12');
--> 14
MINUTE(hora) :
Devuelve el minuto del tiempo especificado en formato numrico de 0 a 59.
mysql> select minute('14:46:12');
--> 46

MONTH(fecha) :
Devuelve el mes para la fecha dada en formato numrico en rango de 0 a 12.
mysql> select month('2007-07-09');
--> 7
MONTHNAME(fecha) :
Devuelve el nombre del mes para la fecha especificada.
mysql> select monthname('2007-07-09');
--> July
NOW() :
Esta funcin de fecha devuelve la fecha y hora actual en formato 'YYYY-MM-DD
HH:MM:SS' o YYYYMMDDHHMMSS (Ao-Mes-Da Hora:Minuto:Segundo)
mysql> select now();
--> 2007-01-04 14:56:15
VARIABLES DENTRO DE RUTINAS ALMACENADAS
asignaciones
La sentencia SET puede realizar asignaciones simples o mltiples:
DECLARE var1, var2, var3;
SET var1 = 1 , var2 = 2 ;
SET var3 = var1 + var2 ;
Asignando valores con SELECT...INTO
Asigna el resultado de una sentencia SELECT a una variable. Fuera de la rutina deben ser variables de
usuario. Dentro de las rutinas, la sentencia puede utilizarse tambin para asignarle valores a variables
locales, las cuales fueron declaradas previamente con DECLARE.
DECLARE first_name_var CHAR(45);
DECLARE last_name_var CHAR(45);
SELECT first_name, last_name INTO
FROM actor a
WHERE actor_id=1;

v_first_name, v_last_name

La sentencia SELECT debe traer como mximo una fila, sino ocurrir un error. Si no trae ninguna fila,
las variables utilizadas en el INTO permanecern sin cambio.
Tambin se puede usar para asignar valores a parmetros de una rutina.
DELIMITER $$
DROP PROCEDURE IF EXISTS `sakila`.`PRC_MejorCliente`$$
CREATE PROCEDURE `sakila`.`PRC_MejorCliente`( OUT p_cliente SMALLINT,
OUT p_pay DECIMAL(5,2)
)
BEGIN
DECLARE v_last_month_start DATE; DECLARE v_last_month_end DATE;
/* Determine start and end time periods */
SET v_last_month_start = STR_TO_DATE('2005-06-01','%Y-%m-%d');

SET v_last_month_end = LAST_DAY(last_month_start);

SET p_cliente = 0,p_pay=0;
SELECT customer_id, SUM(amount) pago
INTO p_cliente,p_pay
FROM payment
WHERE DATE(payment_date) BETWEEN v_last_month_start AND v_last_month_end GROUP BY
customer_id
ORDER BY pago DESC LIMIT 1;
END $$
CALL PRC_MejorCliente(@cli,@pay);
SELECT @cli,@pay;
Una extensin del MySQL a los procedures es que la sentencia SELECT puede ser ejecutada para
generar conjuntos de resultados que son retornados directamente al cliente sin proceso
intermediario. EL cliente recibe los resultados como si ejecutara la sentencia SELECT el mismo. Esto
no aplica a las funciones almacenadas.
DELIMITER //
CREATE PROCEDURE PRC_Pelicula_Actor_Contador ()
BEGIN
SELECT 'Film', COUNT(*) FROM film;
SELECT 'Actor', COUNT(*) FROM actor;
SELECT 'Film_Actor', COUNT(*) FROM film_actor;
END;
//
Cuando se lo invoca retorna tres conjuntos de resultados de un registro
CALL Pelicula_Actor_Contador() mysql> CALL Pelicula_Actor_Contador();
+------+----------+ +-------+----------+
|
Film
|
COUNT(*)
|
|
Actor |
COUNT(*)
+------+----------+ +-------+----------+
|
Film
|
1000 |
|
Actor |
200
|
+------+----------+ +-------+----------+
1 row in set (0.01 sec) 1 row in set (0.01 sec)
+------------+----------+
|
Film_Actor
|
+------------+----------+
|
Film_Actor
|
+------------+----------+
1 row in set (0.01 sec)

COUNT(*)
5462

Query OK, 0 rows affected (0.01 sec)

Condicionales
La sentencia IF y CASE nos permiten evaluar condiciones. Ntese que tienen sintaxis diferente que la
funcin IF() y la expresin CASE. Las ultimas producen un valor que es utilizado en una expresin Estas
no son sentencias por si mismas. Tambin terminan con END en lugar de END CASE. Gracias a la

sintaxis diferente, es posible utilizar las funciones IF() y las expresiones CASE dentro de las rutinas
almacenadas sin tener ambigedad, incluso si se utilizan dentro de una sentencia IF o CASE.
IF expr
THEN statement_list
[ELSEIF expr THEN statement_list] ... [ELSE statement_list]
END IF
IF val IS NULL
THEN SELECT 'val is NULL';
ELSE SELECT 'val is not NULL';
END IF;
CASE es la otra sentencia que evala condiciones. Tiene dos modos. La primera sintaxis es la
siguiente:
CASE case_expr
WHEN when_expr THEN statement_list [WHEN when_expr THEN statement_list] ... [ELSE
statement_list]
END CASE
La expresin case_expr se evala y suele determinar cual de las siguientes clausulas en el resto de
la sentencia debe ejecutarse. La when_expr en la clausula inicial del WHEN se evala y compara con la
case_expr. Si son iguales, la lista de sentencias siguiente al THEN se ejecuta. Si when_expr no es igual
a case_expr, y existen otras clausulas WHEN, se manejan de forma similar a su turno. Si ninguna
clausula WHEN tiene una when_expr igual a case_expr, y hay una clausula ELSE, la lista de sentencias
de de la clausula ELSE es ejecutada.
Cada comparacin tiene el formato case_expr = when_expr. El significado de esto es que la
comparacin nunca es verdadera si el operando es NULL, no importa el valor del operando.
La siguiente sentencia CASE evala si un valor dado es 0, 1, o diferente:
CASE val
WHEN 0 THEN SELECT 'val es 0'; WHEN 1 THEN SELECT 'val es 1';
ELSE SELECT 'val no es 0 or 1';
END CASE;
CASE
CASE 2da Forma
WHEN when_expr THEN statement_list [WHEN when_expr THEN statement_list] ... [ELSE
statement_list]
END CASE
Ejemplo CASE 2da Forma
CASE
WHEN val IS NULL THEN SELECT 'val is NULL';
WHEN val < 0 THEN SELECT 'val es menor que 0'; WHEN val > 0 THEN SELECT 'val es mayor que 0';
ELSE SELECT 'val es 0';
END CASE;
Ciclos

La sintaxis de sentencias en MySQL provee tres tipos distintos de ciclo:

LOOP construye un ciclo incondicional sin sintaxis de terminacin Por esta razn, debe contener una
sentencia que especifique la salida del ciclo.
REPEAT y WHILE, las otras dos construcciones de ciclo, son condicionales. Incluyen una clausula que
determina si continua o termina la ejecucin del ciclo.
Los SQL estndar incluyen un ciclo FOR tambin. MySQL no lo soporta.
Ciclo LOOP
La sentencia LOOP crea un ciclo incondicional con la siguiente sintaxis:
LOOP
statement_list
END LOOP
La lista de sentencias dentro del ciclo se ejecuta repetidamente. El ciclo iterara por siempre a menos
que la lista de sentencias contenga alguna sentencia que genera la salida del ciclo. La salida puede
hacerse efectiva con una sentencia LEAVE o (en una funcin) una sentencia de retorno. El siguiente
LOOP itera mientras la variable i sea menor que 10:
Construccin Ciclo LOOP
DECLARE i INT DEFAULT 0;
my_loop: LOOP
SET i = i + 1;
IF i = 10 THEN
LEAVE my_loop;
END IF;
END LOOP my_loop;
Ciclo REPEAT
La sentencia REPEAT crea un ciclo condicional. Tiene la siguiente sintaxis:
REPEAT
lista_sentencias
UNTIL expr
END REPEAT
Las sentencias dentro del ciclo se ejecutan y luego se evala la expresin condicional expr. Si la
expresion es verdadera, el ciclo termina. De otro modo, comienza nuevamente. Notese que no se
utiliza punto y coma entre la expresin y END REPEAT. El siguiente ciclo REPEAT itera mientras la
variable i sea menor a 10:
Construccin Ciclo REPEAT
DECLARE i INT DEFAULT 0;
REPEAT
SET i = i + 1; UNTIL i >= 10 END REPEAT;
La sentencia WHILE crea un ciclo condicional. Es similar al REPEAT a excepcin que la expresin de
condicin aparece al principio del ciclo en vez de al final. Tambin, un ciclo WHILE continua mientra la

condicin sea verdadera, mientras que el ciclo REPEAT termina tan pronto como la condicin se
vuelve verdadera. La sintaxis de WHILE es la siguiente:
WHILE expr DO
statement_list
END WHILE

La expresin de condicin se evala y el ciclo finaliza si la la condicin no es verdadera. De otra forma,

la lista de sentencias dentro del ciclo se ejecuta, el control se transfiere al comienzo, y la expresin es
evaluada nuevamente. El siguiente ciclo WHILE itera mientras la variable sea menor a 10(diez):
DECLARE i INT DEFAULT 0; WHILE i < 10 DO
SET i = i + 1;
END WHILE;
Diferencia REPEAT y WHILE
Debido a que la evaluacin en un REPEAT se encuentra al final del ciclo, las sentencias dentro del ciclo
siempre se ejecutan al menos una vez. Con WHILE, la evaluacin se realiza al principio, por lo que es
posible que las sentencias dentro del ciclo no se ejecuten ni siquiera una vez. Por ejemplo, el
siguiente ciclo WHILE no ejecutara nunca las sentencias dentro del ciclo:
WHILE 1 = 0 DO SET x = 1; END WHILE;
As como los bloques BEGIN/END pueden ser anidados, los ciclos tambin En tales casos, es til
etiquetarlos por si es necesario salir de mas de un nivel de ciclo a la vez.
Dentro de una rutina existen dos sentencias que transfieren el control. Cada sentencia requiere una
etiqueta que indica a que construccin etiquetada debe aplicarse:
LEAVE label ITERATE label
LEAVE transfiere el control al final de la construccin nombrada y puede ser usada con bloques y
ciclos: BEGIN/END, LOOP, REPEAT, o WHILE.
ITERATE transfiere el control al principio de la construccin nombrada. Solo puede utilizarse dentro
de ciclos: LOOP, REPEAT, o WHILE. No puede utilizarse para reiniciar un bloque BEGIN/END.
LEAVE y ITERATE deben aparecer dentro de una construccin etiquetada.
El siguiente ejemplo incluye un ciclo etiquetado y muestra cmo salir del ciclo o comenzarlo
nuevamente con LEAVE y ITERATE.
DECLARE i INT DEFAULT 0;
my_loop: LOOP
SET i = i + 1;
IF i < 10 THEN ITERATE my_loop; ELSEIF i > 20 THEN LEAVE my_loop; END IF;
SELECT 'i is between 10 and 20';
END LOOP my_loop;
Transferencia de Control
La ultima forma de transferir el control es ejecutando una sentencia RETURN para retornar un valor al
proceso que llamo la rutina. Esto solo se aplica a las funciones, no a los procesos almacenados. El
siguiente ejemplo retorna el nombre del pas asociado a un cdigo de pas:
CREATE FUNCTION
`sakila`.`F_NombrePelicula`(p_id INT) RETURNS CHAR(255)
BEGIN
DECLARE v_namer CHAR(255);

SELECT title INTO v_name FROM film

WHERE film_id=p_id;
RETURN v_namer;
END;
Un manejador de error tiene un nombre y una sentencia que sera ejecutada luego de la ocurrencia de
una condicin dada, tal como una advertencia o un error. Comnmente los manejadores se usan para
detectar problemas y tratarlos de una manera mas apropiada y evitar que la rutina termine con un
error.
Se pueden nombrar mediante una declaracin con la sentencia DECLARE, debe hacerse junto con las
variables.
DECLARE nombre_condicin CONDITION FOR tipo_condicin;
Tipo de condicin puede ser un valor SQLSTATE o un cdigo de error numrico
DECLARE no_permite_null CONDITION FOR SQLSTATE '23000';
DECLARE no_permite_null CONDITION FOR 1048;
DECLARE HANDLER crea un manejador para una o mas condiciones y las asocia con una sentencia SQL
que sera ejecutada si cualquiera de las condiciones ocurre:
DECLARE tipo_manejador HANDLER FOR tipo_condicin [, tipo_condicin] ... sentencia
El tipo de manejador indica lo que sucede. CONTINUE causa
que la rutina contine la ejecucin, la instruccin SQL que sigue a la declaracin en la que se produjo
la condicin es la siguiente para ser procesada. EXIT causa la transferencia del control al final del
bloque en el que el manejador se declaro. El SQL estndar tambin define manejadores UNDO, pero
MySQL no es compatible con ellos.
Cada condicin asociada a un manejador debe ser una de las siguientes:

Un valor SQLSTATE o cdigo de error de MYSQL, se especifica de la misma manera que en una
sentencia DECLARE CONDITION.

El nombre de una condicin declarada previamente con una sentencia DECLARE CONDITION.

SQLWARNING, las cuales manejan condiciones para todos los valores SQLSTATE que
comienzan con 01.

NOT FOUND, las cuales manejan condiciones para todos los valores SQLSTATE que comienzan
con 02.

SQLEXCEPTION, las cuales manejan condiciones para todos los valores SQLSTATE no
manejados por SQLWARNING o NOT FOUND
CREATE PROCEDURE PRC_AgregaCliente (p_id
INT,p_id_tienda INT,p_nombre VARCHAR(45),p_apellido VARCHAR(45))
BEGIN
DECLARE EXIT HANDLER FOR 1062
BEGIN
SELECT 'ERROR numero de tienda invalido' AS result;
END;
DECLARE EXIT HANDLER FOR 1452

BEGIN
SELECT 'ERROR numero de cliente ya existe' AS result;
END;
INSERT INTO customer VALUES(p_id,p_id_tienda,p_nombre,p_apellido,NULL,1,1,CU
RRENT_DATE(),CURRENT_DATE());
SELECT 'Cliente agregado con xito' AS result;
END;
mysql> CALL PRC_AgregaCliente(601,9999999,'Maria', 'Rodriguez'); ERROR 1452 (23000): Cannot add
or update a child row: a foreign key constraint fails (`sakila/customer`, CONSTRAINT
`fk_customer_store` FOREIGN KEY (`store_id`)
REFERENCES `store` (`store_id`) ON UPDATE CASCADE)
mysql> CALL PRC_AgregaCliente(2,1,'Maria', 'Rodriguez');
ERROR 1062 (23000): Duplicate entry '2' for key 1
mysql> CALL PRC_AgregaCliente(601,9999999,'Maria', 'Rodriguez');
+---------------------------------+
|
result |
+---------------------------------+
|
ERROR numero de
tienda invalido |
+---------------------------------+
mysql> CALL PRC_AgregaCliente(2,1,'Maria', 'Rodriguez');
+-----------------------------------+
| result |
+-----------------------------------+
|
ERROR numero de
cliente ya
existe |
+-----------------------------------+
mysql> CALL PRC_AgregaCliente(601,1,'Maria', 'Rodriguez');
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000'
SET exit_loop = 1;
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000'
BEGIN
statement_list
END;
Para ignorar una condicin, declare un manejador CONTINUE y ascielo con un bloque vaco:
DECLARE CONTINUE HANDLER FOR SQLWARNING BEGIN END;
Conceptos bsicos de desarrollo en Procedimientos almacenados y Funciones
Que son?
Un procedimiento almacenado es un conjunto de comandos SQL que pueden almacenarse en un
servidor de base de datos. Luego de su creacin, cada cliente puede invocarlo y de esta manera se
reutiliza el cdigo, sin necesidad de ejecutar los comandos individualmente.

Sintaxis flexible: Los rutinas almacenadas pueden escribirse utilizando extensiones de la

sintaxis de SQL, tales como, construcciones de control de flujo, que facilitan realizar lgicas
complejas.

Capacidad de manejo de errores: Se pueden crear manejadores de error para ser utilizados
cuando se produzca una condicin determinada. De esta forma puede evitarse la finalizacin de la

rutina ante un error.

Compilacin Estndar: Se atienen a la sintaxis estndar, por lo que son trasladables a otras
bases de datos que sigan los estndares.

Encapsulacin y empaquetado de cdigo: Permite tener el cdigo almacenado y ser utilizado

desde mltiples aplicaciones.

Menos Re-invencin de la rueda: Actan como una biblioteca de soluciones para resolver
problemas, facilitan el compartir del conocimiento y la experiencia. Un programador SQL que tiene
habilidades, puede resolver un problema de gran ndole con un
SP y este puede ser reutilizado por otro.

Fcil de Mantener: Una rutina es ms fcil de mantener que una copia embebida en cada
aplicacin.

Reduccin del requerimiento de Ancho de Banda: Imagine mltiples operaciones realizadas

por un cliente sin la utilizacin de un SP. Cada sentencia y su resultado viajan a travs de la red,
incluso aquellos que calculan un resultado intermedio. Si en cambio esta operacin se realiza con SP,
las sentencias y resultados intermedios se procesan completamente del lado del servidor.

Mejor seguridad: Una rutina puede ser escrita para acceder a informacin sensible. Esta se
puede configurar para que el que la invoca o ejecuta, no vea informacin que no debe. Un SP puede
ser utilizado para modificar tablas en modo seguro sin darle al usuario acceso a la tabla.

Un SP no retorna solo un valor. Es invocado con una sentencia CALL.

Una funcin se invoca dentro de una expresin y retorna un valor simple directamente al
invocador para ser utilizada en esa expresin

No se puede invocar una funcin con CALL, y tampoco se puede invocar un SP en una
expresin
Invocacion de rutinas asociadas a la BD
Cada rutina almacenada esta asociada con una base en
particular.

Cuando se invoca la rutina, se realiza implcitamente USE db_name. No se permite cambiar la

base dentro de un SP.

Se interpreta una referencia, nombre_rutina, en la base de datos por defecto. Para

referirse a una rutina en una base de datos especifica hay que hacerlo de la manera:
CALL nombre_base_de_datos.nombre_rutina

Cuando una rutina se ejecuta,se cambia la base de datos a la que esta asociada la rutina y
cuando termina setea como base por defecto la base anterior. Debido a esto, se debe tener acceso a
esa base de datos para poder invocar la rutina.

Cuando se borra una base de datos, todos los procedimientos almacenados asociados con ella
tambin se borran.
CREATE PROCEDURE nombre_procedure ([Parmetros[,...]]) [caractersticas.]
Cuerpo_de_la_rutina
CREATE FUNCTION
nombre_funcion ([Parmetros[,...]])
RETURNS tipo_dato [Caractersticas..] Cuerpo_de_la_rutina
Puede darse como un bloque BEGIN / END que contiene varias sentencias. Cada declaracin debe
terminar con punto y coma (;).
Si usa el cliente de consola de mysql, el (;) es ambiguo entre la definicin de la rutina y el final de

sentencia. Para esto existe el

comando delimiter que nos permite definir como queremos marcar el final de una rutina.
La clausula opcional [Caractersticas] contiene los siguientes valores, estos pueden aparecer en
cualquier orden:

SQL SECURITY {DEFINER |

INVOKER}
Un SP corre con los privilegios del usuario que los creo o el que lo invoca. DEFINER es el valor por
default.

DETERMINISTIC o NOT DETERMINISTIC

Este valor indica si la rutina produce siempre el mismo resultado o no. El default es NOT
DETERMINISTIC.

COMMENT 'Cadena'
Especifica una descripcin para la rutina. Esta descripcin es mostrada junto con la informacin de
definicin de una rutina.
Cuerpo_de_la_rutina
Contiene el cuerpo del SP o funcin Esta puede ser una sentencia simple,varias sentencias, o puede
contener varios bloques de sentencias.
Declaracin de Parmetros

Los parmetros nos permiten pasarle valores a la rutina cuando se la invoca.

La declaracin de parmetros ocurre entre los parntesis () que le siguen al nombre de la

rutina CREATE PROCEDURE o CREATE FUNCTION.

CREATE FUNCTION
F_MontoAlquiler(p_CantPelicula INT,
p_importe DECIMAL(10,2))
RETURNS DECIMAL(10,2)
RETURN p_CantPelicula * p_importe;
SELECT F_MontoAlquiler(3,5)
Parmetros en los SP
El nombre en la declaracin de una variable debe ser precedido por una de las siguientes palabras
para indicar en que direccin fluye la informacin a travs de ese parmetro:

IN : Indica un parmetro de entrada. El valor del parmetro es pasado al SP. El SP puede

asignarle diferentes valores al parmetro, pero el cambio es visible solamente dentro del SP.

OUT : Indica un parmetro de salida. Si se pasa un valor al parmetro, es ignorado por el SP, y
su valor inicial es NULL. El SP setea su valor y cuando termina el valor del parmetro es pasado por el
SP al que lo llama. Este valor se ve accediendo a la variable.

INOUT : Indica un parmetro que puede ser tanto de entrada como de salida. El SP recibe el
parmetro tal como lo pasa el invocador y cuando termina vuelve a pasar su estado final.
DELIMITER $$
CREATE PROCEDURE PRC_testeo_parametros (IN p_in
INT, OUT p_out INT, INOUT p_inout INT) BEGIN
SELECT p_in , p_out , p_inout;
SET p_in = 100 , p_out = 200 , p_inout = 300;
END;

$$
SET @v_in = 0 , @v_out = 0 , @v_inout = 0
CALL PRC_testeo_parametros (@v_in, @v_out, @v_inout);
SELECT @v_in, @v_out, @v_inout
mysql> SET @v_in = 0 , @v_out = 0 , @v_inout = 0; Query OK, 0 rows affected (0.00 sec)
mysql> CALL PRC_testeo_parametros (@v_in, @v_out, @v_inout);
+------+-------+---------+
| p_in | p_out | p_inout |
+------+-------+---------+
|
0|
NULL | 0 |
+------+-------+---------+
1 row in set (0.01 sec)
Query OK, 0 rows affected (0.01 sec)

mysql> SELECT @v_in, @v_out, @v_inout;

+-------+--------+----------+
| @v_in | @v_out | @v_inout |
+-------+--------+----------+
|
0|
200 | 300 |
+-------+--------+----------+
1 row in set (0.00 sec)
Declaracin de Cursores
La sentencia DECLARE
La sentencia DECLARE es usada para declarar distintos tipos de items en rutinas almacenadas:

Variables locales

Condiciones, tales como alertas o excepciones

Manejadores de error

Cursores
Solo puede ser usada en un bloque BEGIN/END y debe aparecer en el bloque antes que cualquier otra
sentencia. Si se declaran distintos tipos de items, se deben declarar variables y condiciones primero,
luego cursores y finalmente manejadores de error.
Los items creados por DECLARE dentro de un bloque son locales a este. Cuando un bloque termina,
cualquier cursor abierto se cierra y las variables dejan de ser accesibles.
DECLARE nombre_variable

tipoDato

[DEFAULT valor]

A una variable se le pueden asignar valores usando SET, FETCH ... INTO y SELECT ... INTO. Las variables
locales difieren de las variables de usuario, estas no contienen un @ adelante.
DECLARE v_prueba
INT
DEFAULT 0
Asignando valores a Variables con SET
La sentencia SET asigna valores a variables, estas pueden ser variables de sistema o variables de
usuario. Se pueden setear variables fuera de las rutinas o pueden ser variables dentro de la rutina
previamente declaradas con DECLARE.
Un cursor te permite acceder a un conjunto de datos de a una fila a la vez. Debido a esto, los cursores
son utilizados en ciclos que fijan y procesan una fila dentro de cada iteracin del ciclo.
La implementacin del cursor en MySQL tiene las siguientes propiedades:

Provee de cursores de lectura; no pueden utilizarse para modificar tablas.


Los cursores solo avanzan a travs de los datos fila por fila; esto significa, que no son
desplazables en cualquier sentido.
Para usar un cursor en una rutina almacenada, comience escribiendo una sentencia DECLARE CURSOR
en el cual se nombra el cursor y se asocia al la sentencia SELECT que produce el conjunto de datos:
DECLARE nombre_cursor CURSOR FOR sentencia_select
Cada cursor declarado dentro de un bloque debe tener un nombre diferente.
Manejo de Cursores
Los cursores deben abrirse con una sentencia OPEN. Esta ejecuta la sentencia SELECT asociada con el
cursor:
OPEN nombre_cursor
La sentencia FETCH obtiene la prxima fila del conjunto de datos del cursor abierto. Tiene que
utilizarse una variable por cada columna del conjunto de datos. Pueden obtenerse los valores dentro
de variables o parmetros de rutinas:
FETCH nombre_cursor INTO var_name [, var_name] ...
FETCH frecuentemente se utiliza en un ciclo para que todas las filas puedan ser procesadas. Esto
presenta un problema: Que pasa cuando se alcanza el fin de datos? Ocurre una condicin de No
Data (SQLSTATE 02000), la cual puede ser detectada declarando un manejador para esa condicin
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000'
statement;
Cierre de Cursores
Cuando se termina de utilizar el cursor, se debe cerrar con una sentencia CLOSE:
CLOSE nombre_cursor
Cerrar un cursor es opcional. Cualquier cursor declarado en un bloque se cierra automticamente
cuando el bloque termina.
El siguiente ejemplo declara un cursor nombrado c y lo asocia con una sentencia que selecciona
filas de las pelculas que realizo un actor. Tambin declara una manejador de condicin que detecta el
fin del conjunto de datos. (La sentencia del manejador esta vaca pues el nico propsito es transferir
el control al final del bloque.)
DELIMITER $$
CREATE PROCEDURE PRC_Films_actor(p_actor INT)
BEGIN
DECLARE v_row_count INT DEFAULT 0;
DECLARE v_code
INT;
DECLARE v_name
CHAR(52);
DECLARE c CURSOR FOR
SELECT f.film_id,title FROM
film_actor f_a,film f WHERE

f_a.film_id=f.film_id AND
actor_id=p_actor;
OPEN c;
BEGIN
DECLARE EXIT HANDLER FOR SQLSTATE '02000' BEGIN END; LOOP
FETCH c INTO v_code, v_name; SET v_row_count = v_row_count + 1; END LOOP;
END;
CLOSE c;
SELECT 'Numero de peliculas realizadas =', v_row_count;
END;
$$
En el ejemplo precedente se utiliza un bloque de sentencias anidadas porque un manejador EXIT
termina el bloque dentro del cual se declara, no el ciclo dentro del cual la condicin ocurre. Si no se
hubiera utilizado un bloque de sentencias anidadas, el manejador hubiera transferido el control al
final del bloque principal luego de llegar al fin del conjunto de datos, y la sentencia CLOSE y SELECT
siguientes al ciclo no hubieran sido ejecutadas. Un enfoque alternativo no requiere de un bloque de
sentencias anidadas: Usa un manejador CONTINUE que setea una variable de estado que produce la
terminacin del ciclo, ya que la misma se se controla dentro de ciclo.
CREATE PROCEDURE PRC_Films_actor_2(p_actor INT)
BEGIN
DECLARE v_exit_flag INT DEFAULT 0; DECLARE v_row_count INT DEFAULT 0; DECLARE v_code INT;
DECLARE v_name CHAR(52);
DECLARE c CURSOR FOR
SELECT f.film_id,title FROM
film_actor f_a,film f WHERE
f_a.film_id=f.film_id AND
actor_id=p_actor;
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET v_exit_flag = 1;
OPEN c;
fetch_loop: LOOP
FETCH c INTO v_code, v_name;
IF v_exit_flag THEN LEAVE fetch_loop; END IF; SET v_row_count = v_row_count + 1;
END LOOP;
CLOSE c;
SELECT 'Numero de peliculas =', v_row_count;
END;
CREATE PROCEDURE PRC_Pais() SQL SECURITY INVOKER BEGIN
DECLARE v_id INT;
DECLARE v_name VARCHAR(50); DECLARE cur CURSOR FOR
SELECT country_id,country FROM country;
CREATE TEMPORARY TABLE tmpcountry (country VARCHAR(50)); OPEN cur;
BEGIN
DECLARE EXIT HANDLER FOR SQLSTATE '02000' BEGIN END; LOOP
FETCH cur INTO v_id,v_name;
INSERT INTO tmpcountry VALUES(v_name); END LOOP;
END;
CLOSE cur;
SELECT * FROM tmpcountry;
END

Triggers

A partir de MySQL 5.0.2 se incluy soporte bsico para triggers. Por ahora es muy bsico y limitado.
Que son los triggers?
Los triggers (disparadores en espaol) son acciones que pueden ejecutarse de manera automtica
cuando determinado evento ocurre en una tabla.
Al crear un trigger, se lo asocia con una tabla, y se lo programa para que se active antes o despus de
la ejecucin de que una sentencia del tipo DML (INSERT, DELETE o UPDATE) ocurra en esa tabla.
Bsicamente un trigger se compone de tres partes:
Evento
Es el evento que tiene que ocurrir para que el trigger se active.
Puede ser una sentencia INSERT, DELETE o UPDATE
Restriccin
Una vez activado el trigger, se puede evaluar una condicin, para ser ejecutado opcionalmente bajo
ciertas condiciones.
Accin
La accin que realiza el trigger al ejecutarse.
Triggers
CREATE TRIGGER nombre_trigger
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE }
ON nombre_tabla
FOR EACH ROW
sentencia_a_ejecutar
Referencias

En el trigger de un INSERT , NEW.nombre_columna indica el valor de una columna a ser

insertado dentro de una nueva columna. OLD no esta permitido.

En el trigger de un DELETE, OLD.nombre_columna indica el valor de una columna a ser

borrado. NEW no esta disponible.

En el trigger de un UPDATE, OLD.nombre_columna y NEW.nombre_columna hacer referencia

al valor de una fila antes y despus del UPDATE.

OLD debe ser utilizado en modo solo-lectura. NEW puede ser utilizado para leer o cambiar
valores de columnas.
Eliminacin de Triggers
Para eliminar un Trigger se utiliza la sentencia DROP TRIGGER.
DROP TRIGGER nombre_base.nombre_trigger;
Si no se hace referencia al nombre de la base de datos se utiliza la base por defecto.
DROP TRIGGER nombre_trigger;
Triggers:Premisos
Para poder crear o eliminar Triggers con las sentencias DROP y
CREATE se deben tener privilegios SUPER
Para asignar valor a una columna con SET NEW.col = VALOR, debe tener permiso de UPDATE o INSERT
para la columna, dependiendo de la operacin realizada.

Para utilizar NEW.col en una expresin, debe tener permiso de

SELECT para la columna.
Ejemplo Triggers
CREATE TABLE `sakila`.`audi_actor` (
`actor_id` SMALLINT(5) UNSIGNED NOT NULL AUTO_INCREMENT,
`first_name` VARCHAR(45) NOT NULL,
`last_name` VARCHAR(45) NOT NULL,
`last_update` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE
CURRENT_TIMESTAMP,
user_audi VARCHAR(30), accion_audi VARCHAR(1),
KEY `idx_actor_last_name` (`last_name`)
)
Creacin trigger INSERT
DROP TRIGGER IF EXISTS tr_audi_actor_insert;
CREATE TRIGGER
tr_audi_actor_insert AFTER INSERT ON actor
FOR EACH ROW BEGIN
INSERT INTO audi_actor VALUES
(NEW.actor_id,NEW.first_name,NEW.last_name,NE W.last_update,USER(),'i');
END;
DROP TRIGGER IF EXISTS tr_audi_actor_delete;
CREATE TRIGGER
tr_audi_actor_delete AFTER DELETE ON actor
FOR EACH ROW BEGIN
INSERT INTO audi_actor VALUES
(OLD.actor_id,OLD.first_name,OLD.last_name,
OLD.last_update,USER(),'d'); END;
DROP TRIGGER IF EXISTS tr_audi_actor_update;
CREATE TRIGGER
tr_audi_actor_update AFTER UPDATE ON actor
FOR EACH ROW BEGIN
INSERT INTO audi_actor VALUES
(OLD.actor_id,OLD.first_name,OLD.last_name,
OLD.last_update,USER(),'u'); END;
INSERT INTO actor(last_name,first_name)
VALUES('Roberto','Darin');
UPDATE actor SET first_name='Ricardo' WHERE
actor_id=213;
DELETE FROM actor WHERE actor_id=213
#Comprobamos tabla de auditoria
SELECT * FROM audi_actor;

EJEMPLOS
ESTRUCTURAS DE CONTROL :
IF THEN ELSE
Ejemplo: Crear una funcin para verificar si un nmero es positivo o negativo.
CREATE FUNCTION posi(n int) RETURNS
varchar(20)
begin
IF n > 0 then
return 'Es Positivo'; else
return 'Es Negativo'; end
IF;
end
WHILE
Ejemplo: Crear una funcin para calcular el factorial.
CREATE FUNCTION factorial(n int)
RETURNS int begin
declare f,c int; set f =
1;
set c = 1;
WHILE c <= n do set f
= f * c; set c = c +
1;
END WHILE;
return f; end
REPEAT UNTIL
CREATE procedure p15() begin
declare v int;
SET v = 20;
repeat
INSERT INTO lista VALUES(v); SET v
= v + 1;
until v &gt;= 1
end repeat;
end;
SWITCH
CREATE procedure miProc (IN p1 int)
begin
declare var int ;
SET var = p1 +2 ; case
var

when 2 then INSERT INTO lista VALUES (66666); when

3 then INSERT INTO lista VALUES (4545665); else
INSERT INTO lista VALUES (77777777);
end case; end;
LOOP LABEL

CREATE procedure p16() begin

declare v int;
SET v = 0;
loop_label : loop
INSERT INTO lista VALUES (v);
SET v = v + 1;
IF v &gt;= 5 then
leave loop_label; end
IF;
end loop; end;
FUNCIONES DEFINIDAS POR EL USUARIO
Ejemplo: Crear una funcin para obtener la suma de 2 nmeros.
CREATE FUNCTION suma(a int, b int) returns
int
begin
declare s int; set
s = a + b; return
(s); end
----------------------------------------Ahora, para hacer una llamada a nuestra Funcin solo necesitamos usar sentencia
SELECT, ejemplo:
select suma(2,5)
Ejemplo: Crear una funcin para mostrar una saludo. CREATE
FUNCTION Saludo (nom CHAR(20)) RETURNS CHAR(50)
RETURN CONCAT('Hola ', nom);
----------------------------------------Ahora usamos la funcin de la siguiente forma:
select Saludos('Hola')
Otro Ejemplo: Crear una funcin para calcular el Factorial de un nmero.
CREATE FUNCTION factorial(n int)
RETURNS int begin
declare f,c int; set f =
1;
set c = 1;

WHILE c <= n do set f

= f * c; set c = c +
1;
END WHILE;
return f; end
----------------------------------------Ahora usamos la funcin de la siguiente forma:

select factorial(5)

PROCEDIMIENTOS ALMACENADOS
Ejemplo: Crear un Procedimiento Almacenado para sumar 2 nmeros enteros.
CREATE PROCEDURE sumar (IN a int, IN b int) begin
declare s int; set
s = a + b; select s;
end
---------------------------------------------Ahora, Para hacer una llamada a nuestro Procedimiento Almacenado usaremos la
sentencia CALL, ejemplo:

CALL sumar(5,10)
Otro ejemplo: Crear un Procedimiento Almacenado para Insertar registros en la tabla productos.
CREATE PROCEDURE nuevoproducto (IN id varchar(3), IN nom varchar(50)) begin
INSERT INTO productos VALUES (id,nom); End
-----------------------------------------------Ahora utilizamos el Procedimiento Almacenado para Insertar un nuevo registro.
CALL nuevoproducto ('p5','Vitagrip')
Otro ejemplo: Crear un Procedimiento Almacenado para mostrar la cantidad de productos que se
tiene.
CREATE PROCEDURE cantidad () begin
DECLARE n int;
set n = (select count(idp) from productos);
select n; end
-----------------------------------------------Ahora llamamos al Procedimiento Almacenado para averiguar la cantidad de productos que tiene
la tabla.
CALL cantidad
TRIGGERS
Sintaxis necesaria para crear un trigger
CREATE TRIGGER <nombre>
{BEFORE|AFTER}
{INSERT|UPDATE|DELETE}

ON
<tablename>
FOR EACH ROW
BEGIN
<sentenciasSQL>
END;

Ejemplo:
Crear los siguientes Triggers para la Tabla productos:
a) Un Trigger que se desencadene(dispare) despus de INSERTAR nuevos
registros.
b) Un Trigger que se desencadene(dispare) despus de MODIFICAR registros.
c) Un Trigger que se desencadene(dispare) despus de ELIMINAR
registros.
Sea la tabla:
CREATE TABLE productos (idp varchar(3), nombre varchar(50))
Si lo que queremos es mantener el control de la tabla PRODUCTOS, para ver que o quien la
modifica y a que hora, que eliminan, etc. , podemos crear una Tabla Auxiliar donde iremos
anotando que insertar, modificar o eliminan.
Crearemos las tablas auxiliares:
CREATE TABLE produc_ins (idp varchar(3), nombre varchar(50)) CREATE TABLE
produc_modif (idp varchar(3), nombre varchar(50)) CREATE TABLE produc_elim
(idp varchar(3), nombre varchar(50))
------------------------------------------------------------------------------------------a)
CREATE TRIGGER Trigger_Producto_INSER after INSERT ON productos FOR each
row
begin
INSERT INTO produc_ins (idp, nombre) VALUES(NEW.idp , NEW.nombre); End
------------------------------------------------------------------------------------------b)
CREATE TRIGGER Trigger_Producto_MODIF after UPDATE ON productos FOR each
row
begin
INSERT INTO produc_modif (idp, nombre) VALUES(OLD.idp , NEW.nombre); end
------------------------------------------------------------------------------------------c)
CREATE TRIGGER Trigger_Producto_ELIM after DELETE ON productos FOR each
row
begin
INSERT INTO produc_elim (idp, nombre) VALUES(OLD.idp , OLD.nombre); end