lunes, 28 de enero de 2013
Funciones Matematicas
ABS(X)
Retorna el valor absoluto de X.
mysql> SELECT ABS(2);
-> 2
mysql> SELECT ABS(-32);
-> 32
Esta función puede usar valores BIGINT.
ACOS(X)
Retorna el arcocoseno de X, esto es, el valor cuyo coseno es X. Retorna NULL si X no está en el rango -1 a 1.
mysql> SELECT ACOS(1);
-> 0
mysql> SELECT ACOS(1.0001);
-> NULL
mysql> SELECT ACOS(0);
-> 1.5707963267949
ASIN(X)
Retorna el arcoseno de X, esto es, el valor cuyo seno es X. Retorna NULL si X no está en el rango de -1 a 1.
mysql> SELECT ASIN(0.2);
-> 0.20135792079033
mysql> SELECT ASIN('foo');
-> 0
ATAN(X)
Retorna la arcotangente de X, esto es, el valor cuya tangente es X.
mysql> SELECT ATAN(2);
-> 1.1071487177941
mysql> SELECT ATAN(-2);
-> -1.1071487177941
ATAN(Y,X) , ATAN2(Y,X)
Retorna la arcotangente de las variables X y Y. Es similar a calcular la arcotangente de Y / X, excepto que los signos de ambos argumentos se usan para determinar el cuadrante del resultado.
mysql> SELECT ATAN(-2,2);
-> -0.78539816339745
mysql> SELECT ATAN2(PI(),0);
-> 1.5707963267949
CEILING(X), CEIL(X)
Retorna el entero más pequeño no menor a X.
mysql> SELECT CEILING(1.23);
-> 2
mysql> SELECT CEIL(-1.23);
-> -1
Estas dos funciones son sinónimos. Tenga en cuenta que el valor retornado se convierte a BIGINT.
COS(X)
Retorna el coseno de X, donde X se da en radianes.
mysql> SELECT COS(PI());
-> -1
COT(X)
Retorna la cotangente de X.
mysql> SELECT COT(12);
-> -1.5726734063977
mysql> SELECT COT(0);
-> NULL
CRC32(expr)
Computa un valor de redundancia cíclica y retorna el valor sin signo de 32 bits. El resultado es NULL si el argumento es NULL. Se espera que el argumento sea una cadena y (si es posible) se trata como una si no lo es.
mysql> SELECT CRC32('MySQL');
-> 3259397556
mysql> SELECT CRC32('mysql');
-> 2501908538
DEGREES(X)
Retorna el argumento X, convertido de radianes a grados.
mysql> SELECT DEGREES(PI());
-> 180
mysql> SELECT DEGREES(PI() / 2);
-> 90
EXP(X)
Retorna el valor de e (la base del logaritmo natural) a la potencia de X.
mysql> SELECT EXP(2);
-> 7.3890560989307
mysql> SELECT EXP(-2);
-> 0.13533528323661
FLOOR(X)
Retorna el valor entero más grande pero no mayor a X.
mysql> SELECT FLOOR(1.23);
-> 1
mysql> SELECT FLOOR(-1.23);
-> -2
Tenga en cuenta que el valor devuelto se convierte a BIGINT.
LN(X)
Retorna el logaritmo natural de X, esto es, el logaritmo de X base e.
mysql> SELECT LN(2);
-> 0.69314718055995
mysql> SELECT LN(-2);
-> NULL
Esta función es sinónimo a LOG(X).
LOG(X), LOG(B,X)
Si se llama con un parámetro, esta función retorna el logaritmo natural de X.
mysql> SELECT LOG(2);
-> 0.69314718055995
mysql> SELECT LOG(-2);
-> NULL
Si se llama con dos parámetros, esta función retorna el logaritmo de X para una base arbitrária B.
mysql> SELECT LOG(2,65536);
-> 16
mysql> SELECT LOG(10,100);
-> 2
LOG(B,X) es equivalente a LOG(X) / LOG(B).
LOG2(X)
Retorna el logaritmo en base 2 de X.
mysql> SELECT LOG2(65536);
-> 16
mysql> SELECT LOG2(-100);
-> NULL
LOG2() es útil para encontrar cuántos bits necesita un número para almacenamiento. Esta función es equivalente a la expresión LOG(X) / LOG(2).
LOG10(X)
Retorna el logaritmo en base 10 de X.
mysql> SELECT LOG10(2);
-> 0.30102999566398
mysql> SELECT LOG10(100);
-> 2
mysql> SELECT LOG10(-100);
-> NULL
LOG10(X) es equivalente a LOG(10,X).
MOD(N,M) , N % M, N MOD M
Operación de módulo. Retorna el resto de N dividido por M.
mysql> SELECT MOD(234, 10);
-> 4
mysql> SELECT 253 % 7;
-> 1
mysql> SELECT MOD(29,9);
-> 2
mysql> SELECT 29 MOD 9;
-> 2
Esta función puede usar valores BIGINT.
MOD() también funciona con valores con una parte fraccional y retorna el resto exacto tras la división:
mysql> SELECT MOD(34.5,3);
-> 1.5
PI()
Retorna el valor de π (pi). El número de decimales que se muestra por defecto es siete, pero MySQL usa internamente el valor de doble precisión entero.
mysql> SELECT PI();
-> 3.141593
mysql> SELECT PI()+0.000000000000000000;
-> 3.141592653589793116
POW(X,Y) , POWER(X,Y)
Retorna el valor de X a la potencia de Y.
mysql> SELECT POW(2,2);
-> 4
mysql> SELECT POW(2,-2);
-> 0.25
RADIANS(X)
Retorna el argumento X, convertido de grados a radianes. (Tenga en cuenta que π radianes son 180 grados.)
mysql> SELECT RADIANS(90);
-> 1.5707963267949
RAND(), RAND(N)
Retorna un valor aleatorio en coma flotante del rango de 0 a 1.0. Si se especifica un argumento entero N, es usa como semilla, que produce una secuencia repetible.
mysql> SELECT RAND();
-> 0.9233482386203
mysql> SELECT RAND(20);
-> 0.15888261251047
mysql> SELECT RAND();
-> 0.63553050033332
mysql> SELECT RAND();
-> 0.70100469486881
mysql> SELECT RAND(20);
-> 0.15888261251047
Puede usar esta función para recibir registros de forma aleatoria como se muestra aquí:
mysql> SELECT * FROM tbl_name ORDER BY RAND();
ORDER BY RAND() combinado con LIMIT es útil para seleccionar una muestra aleatoria de una conjunto de registros:
mysql> SELECT * FROM table1, table2 WHERE a=b AND c<d
-> ORDER BY RAND() LIMIT 1000;
Tenga en cuenta que RAND() en una cláusula WHERE se re-evalúa cada vez que se ejecuta el WHERE.
RAND() no pretende ser un generador de números aleatorios perfecto, pero es una forma rápida de generar números aleatorios ad hoc portable entre plataformas para la misma versión de MySQL.
ROUND(X), ROUND(X,D)
Retorna el argumento X, redondeado al entero más cercano. Con dos argumentos, retorna X redondeado a D decimales. D puede ser negativo para redondear D dígitos a la izquierda del punto decimal del valor X.
mysql> SELECT ROUND(-1.23);
-> -1
mysql> SELECT ROUND(-1.58);
-> -2
mysql> SELECT ROUND(1.58);
-> 2
mysql> SELECT ROUND(1.298, 1);
-> 1.3
mysql> SELECT ROUND(1.298, 0);
-> 1
mysql> SELECT ROUND(23.298, -1);
-> 20
El tipo de retorno es el mismo tipo que el del primer argumento (asumiendo que sea un entero, doble o decimal). Esto significa que para un argumento entero, el resultado es un entero (sin decimales).
Antes de MySQL 5.0.3, el comportamiento de ROUND() cuando el argumento se encuentra a medias entre dos enteros depende de la implementación de la biblioteca C. Implementaciones distintas redondean al número par más próximo, siempre arriba, siempre abajo, o siempre hacia cero. Si necesita un tipo de redondeo, debe usar una función bien definida como TRUNCATE() o FLOOR() en su lugar.
Desde MySQL 5.0.3, ROUND() usa la biblioteca de matemática precisa para valores exactos cuando el primer argumento es un valor con decimales:
Para números exactos, ROUND() usa la regla de "redondea la mitad hacia arriba": Un valor con una parte fracional de .5 o mayor se redondea arriba al siguiente entero si es positivo o hacia abajo si el siguiente entero es negativo. (En otras palabras, se redondea en dirección contraria al cero.) Un valor con una parte fraccional menor a .5 se redondea hacia abajo al siguiente entero si es positivo o hacia arriba si el siguiente entero es negativo.
Para números aproximados, el resultado depende de la biblioteca C. En muchos sistemas, esto significa que ROUND() usa la regla de "redondeo al número par más cercano": Un valor con una parte fraccional se redondea al entero más cercano.
El siguiente ejemplo muestra cómo el redondeo difiere para valores exactos y aproximados:
mysql> SELECT ROUND(2.5), ROUND(25E-1);
+------------+--------------+
| ROUND(2.5) | ROUND(25E-1) |
+------------+--------------+
| 3 | 2 |
+------------+--------------+
Para más información, consulte Capítulo 23, Matemáticas de precisión.
SIGN(X)
Retorna el signo del argumento como -1, 0, o 1, en función de si X es negativo, cero o positivo.
mysql> SELECT SIGN(-32);
-> -1
mysql> SELECT SIGN(0);
-> 0
mysql> SELECT SIGN(234);
-> 1
SIN(X)
Retorna el seno de X, donde X se da en radianes.
mysql> SELECT SIN(PI());
-> 1.2246063538224e-16
mysql> SELECT ROUND(SIN(PI()));
-> 0
SQRT(X)
Retorna la raíz cuadrada de un número no negativo. X.
mysql> SELECT SQRT(4);
-> 2
mysql> SELECT SQRT(20);
-> 4.4721359549996
mysql> SELECT SQRT(-16);
-> NULL
TAN(X)
Retorna la tangente de X, donde X se da en radianes.
mysql> SELECT TAN(PI());
-> -1.2246063538224e-16
mysql> SELECT TAN(PI()+1);
-> 1.5574077246549
TRUNCATE(X,D)
Retorna el número X, truncado a D decimales. Si D es 0, el resultado no tiene punto decimal o parte fraccional. D puede ser negativo para truncar (hacer cero) D dígitos a la izquierda del punto decimal del valor X.
mysql> SELECT TRUNCATE(1.223,1);
-> 1.2
mysql> SELECT TRUNCATE(1.999,1);
-> 1.9
mysql> SELECT TRUNCATE(1.999,0);
-> 1
mysql> SELECT TRUNCATE(-1.999,1);
-> -1.9
mysql> SELECT TRUNCATE(122,-2);
-> 100
Todos los números se redondean hacia cero.
domingo, 27 de enero de 2013
Crear tabla
Creamos nuestra primera tabla producto
CREATE TABLE `producto` (
`codigo` CHAR(8) NOT NULL,
`nombre` VARCHAR(100) DEFAULT NULL,
`unidad` VARCHAR(20) DEFAULT NULL,
PRIMARY KEY (`codigo`)
) ENGINE=InnoDB;
a esta tabla le adicionaremos la siguiente información Catalogo2012.zip
Aquí tenemos un script con las tablas de departamentos, provincias y distritos
peru.sql
Aquí tenemos un script con las tablas de departamentos, provincias y distritos
Declaraciones
En una declaración se pueden crear:
DECLARE nombre_de_variable [, nombre_de_variable…] TIPO [valor predeterminado ];
DECLARE nombre_de_condición CONDITION FOR condición
condicion: {SQLSTATE [VALOR] sqlstate_value | mysql_errno}
DECLARE nombre_del_cursor CURSOR FOR instrucción_select
DECLARE handler_type
HANDLER FOR handler_condition [, handler_condition] …
instruccion
handler_type: {CONTINUE | EXIT}
handler_condition:
{
SQLSTATE[VALUE] sqlstate_value
| mysql_errno
| condition_name
| SQLWARNING
| NOT FOUND
| SQLEXCEPTION
}
La declaración de una variable local, una condición, un cursor o un manejador solamente puede aparecer al principio de un bloque BEGIN … END. Si se necesitan hacer diferentes declaraciones, éstas deben hacerse en el siguiente orden:
Las variables locales se pueden declarar dentro de alguna rutina en la misma línea (siempre y cuando sean del mismo tipo), separando cada una por una coma. Para darle un valor a éstas o para inicializarlas, se utilzará la instrucción SET.
La instrucción DECLARE … CONDITION crea el nombre para una condición. Dicho nombre puede referirse a una instrucción DECLARE … HANDLER. nombre_de_condición puede ser ya sea un valor SQLSTATE representado por cinco caracteres o un valor numérico específico de MySQL.
La instrucción DECLARE … CURSOR declara un cursor para ser asociado a algún SELECT , el cual no deberá contener la instrucción INTO. El cursor puede abrirse con la cláusula OPEN. Se deberá utilizar la instrucción FETCH para obtener los renglones resultantes del SELECT y se deberá cerrar con la instrucción CLOSE.
La instrucción DECLARE … HANDLER asocia una o más condiciones con una instrucción a ser ejecutada cuando alguna de las condiciones ocurre. El valor del handler_type indica qué ocurre cuando la condición se ejecuta. Con la instrucción CONTINUE , la ejecución de la instrucción continúa, con la instrucción EXIT el bloque BEGIN actual terminará.
handler_condition puede ser alguno de los siguientes valores:
Ejemplo:
delimiter $
CREATE PROCEDURE ejemplo ()
BEGIN
DECLARE 'Constraint Violation'
CONDITION FOR SQLSTATE '23000';
DECLARE EXIT HANDLER FOR
'Constraint Violation' ROLLBACK;
START TRANSACTION;
INSERT INTO t2 VALUES (1);
INSERT INTO t2 VALUES (1);
COMMIT;
END;
delimiter ;
- Variables locales
- Condiciones
- Cursores
- Manejadores
DECLARE nombre_de_variable [, nombre_de_variable…] TIPO [valor predeterminado ];
DECLARE nombre_de_condición CONDITION FOR condición
condicion: {SQLSTATE [VALOR] sqlstate_value | mysql_errno}
DECLARE nombre_del_cursor CURSOR FOR instrucción_select
DECLARE handler_type
HANDLER FOR handler_condition [, handler_condition] …
instruccion
handler_type: {CONTINUE | EXIT}
handler_condition:
{
SQLSTATE[VALUE] sqlstate_value
| mysql_errno
| condition_name
| SQLWARNING
| NOT FOUND
| SQLEXCEPTION
}
La declaración de una variable local, una condición, un cursor o un manejador solamente puede aparecer al principio de un bloque BEGIN … END. Si se necesitan hacer diferentes declaraciones, éstas deben hacerse en el siguiente orden:
- Declaración de variables y condiciones
- Declaración de cursores
- Declaración de manejadores
Las variables locales se pueden declarar dentro de alguna rutina en la misma línea (siempre y cuando sean del mismo tipo), separando cada una por una coma. Para darle un valor a éstas o para inicializarlas, se utilzará la instrucción SET.
La instrucción DECLARE … CONDITION crea el nombre para una condición. Dicho nombre puede referirse a una instrucción DECLARE … HANDLER. nombre_de_condición puede ser ya sea un valor SQLSTATE representado por cinco caracteres o un valor numérico específico de MySQL.
La instrucción DECLARE … CURSOR declara un cursor para ser asociado a algún SELECT , el cual no deberá contener la instrucción INTO. El cursor puede abrirse con la cláusula OPEN. Se deberá utilizar la instrucción FETCH para obtener los renglones resultantes del SELECT y se deberá cerrar con la instrucción CLOSE.
La instrucción DECLARE … HANDLER asocia una o más condiciones con una instrucción a ser ejecutada cuando alguna de las condiciones ocurre. El valor del handler_type indica qué ocurre cuando la condición se ejecuta. Con la instrucción CONTINUE , la ejecución de la instrucción continúa, con la instrucción EXIT el bloque BEGIN actual terminará.
handler_condition puede ser alguno de los siguientes valores:
- Un valor de SQLSTATE representado por una cadena de cinco caracteres
- Un valor numérico específico de MySQL
- El nombre de una condición declarada previamente con DECLARE … CONDITION.
- SQLWARNING, el cual cacha cualquier valor de SQLSTATE que empiece con 01.
- NOT FOUND, que cacha cualquier valor de SQLSTATE que empiece con 02.
- SQLEXCEPTION, que cacha cualquier valor de SQLSTATE no cachado por SQLWARNING o NOT FOUND.
Ejemplo:
delimiter $
CREATE PROCEDURE ejemplo ()
BEGIN
DECLARE 'Constraint Violation'
CONDITION FOR SQLSTATE '23000';
DECLARE EXIT HANDLER FOR
'Constraint Violation' ROLLBACK;
START TRANSACTION;
INSERT INTO t2 VALUES (1);
INSERT INTO t2 VALUES (1);
COMMIT;
END;
delimiter ;
sábado, 26 de enero de 2013
Funciones
Así como existen los procedimientos, también existen las funciones. Para crear una función, MySQL nos ofrece la directiva CREATE FUNCTION.
La diferencia entre una función y un procedimiento es que la función devuelve valores. Estos valores pueden ser utilizados como argumentos para instrucciones SQL, tal como lo hacemos normalmente con otras funciones como son, por ejemplo, MAX() o COUNT().
Utilizar la cláusula RETURNS es obligatorio al momento de definir una función y sirve para especificar el tipo de dato que será devuelto (sólo el tipo de dato, no el dato).
Su sintaxis es:
CREATE FUNCTION nombre (parámetro)
RETURNS tipo
[características] definición
Puede haber más de un parámetro (se separan con comas) o puede no haber ninguno (en este caso deben seguir presentes los paréntesis, aunque no haya nada dentro). Los parámetros tienen la siguiente estructura:nombre tipo
Donde:
CREATE FUNCTION hola (cadena CHAR(20)) RETURNS CHAR(50)
RETURN CONCAT('Hola , ',cadena,'!');
CREATE FUNCTION age (date1 DATE, date2 DATE)
RETURNS INT
BEGIN
DECLARE age INT;
SET age = (YEAR(date2) - YEAR(date1)) - IF(RIGHT(date2,5) < RIGHT(date1,5),1,0);
RETURN age;
END
La diferencia entre una función y un procedimiento es que la función devuelve valores. Estos valores pueden ser utilizados como argumentos para instrucciones SQL, tal como lo hacemos normalmente con otras funciones como son, por ejemplo, MAX() o COUNT().
Utilizar la cláusula RETURNS es obligatorio al momento de definir una función y sirve para especificar el tipo de dato que será devuelto (sólo el tipo de dato, no el dato).
Su sintaxis es:
CREATE FUNCTION nombre (parámetro)
RETURNS tipo
[características] definición
Puede haber más de un parámetro (se separan con comas) o puede no haber ninguno (en este caso deben seguir presentes los paréntesis, aunque no haya nada dentro). Los parámetros tienen la siguiente estructura:nombre tipo
Donde:
- nombre: es el nombre del parámetro.
- tipo: es cualquier tipo de dato de los provistos por MySQL.
- Dentro de características es posible incluir comentarios o definir si la función devolverá los mismos resultados ante entradas iguales, entre otras cosas.
- definición: es el cuerpo del procedimiento y está compuesto por el procedimiento en sí: aquí se define qué hace, cómo lo hace y cuándo lo hace.
CREATE FUNCTION hola (cadena CHAR(20)) RETURNS CHAR(50)
RETURN CONCAT('Hola , ',cadena,'!');
CREATE FUNCTION age (date1 DATE, date2 DATE)
RETURNS INT
BEGIN
DECLARE age INT;
SET age = (YEAR(date2) - YEAR(date1)) - IF(RIGHT(date2,5) < RIGHT(date1,5),1,0);
RETURN age;
END
viernes, 25 de enero de 2013
Procedimientos almacenados
Para crear un procedimiento, MySQL nos ofrece la directiva CREATE PROCEDURE. Al crearlo éste es ligado o relacionado con la base de datos que se está usando, tal como cuando creamos una tabla, por ejemplo.
Para llamar a un procedimiento lo hacemos mediante la instrucción CALL. Desde un procedimiento podemos invocar a su vez a otros procedimientos o funciones.
Un procedimiento almacenado, al igual cualquiera de los procedimientos que podamos programar en nuestras aplicaciones utilizando cualquier lenguaje, tiene:
MySQL sigue la sintaxis SQL:2003 para procedimientos almacenados, que también usa IBM DB2.
En resumen, la sintaxis de un procedimiento almacenado es la siguiente:
CREATE PROCEDURE nombre (parámetro)
[características] definición
Puede haber más de un parámetro (se separan con comas) o puede no haber ninguno (en este caso deben seguir presentes los paréntesis, aunque no haya nada dentro).
Los parámetros tienen la siguiente estructura: modo nombre tipo
Donde:
CREATE PROCEDURE simpleproc (INT param1 INT)
BEGIN
SELECT * FROM siniestro limit 0, param1;
END
CREATE PROCEDURE procedimiento2 (IN a INTEGER)
BEGIN
DECLARE variable CHAR(20);
IF a > 10 THEN
SET variable = 'mayor a 10';
ELSE
SET variable = 'menor o igual a 10';
END IF;
select variable;
END
CREATE PROCEDURE curdemo()
BEGIN
DECLARE done INT DEFAULT 0;
DECLARE a CHAR(16);
DECLARE b,c INT;
DECLARE cur1 CURSOR FOR SELECT id,data FROM test.t1;
DECLARE cur2 CURSOR FOR SELECT i FROM test.t2;
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done = 1;
OPEN cur1;
OPEN cur2;
REPEAT
FETCH cur1 INTO a, b;
FETCH cur2 INTO c;
IF NOT done THEN
IF b < c THEN
INSERT INTO test.t3 VALUES (a,b);
ELSE
INSERT INTO test.t3 VALUES (a,c);
END IF;
END IF;
UNTIL done END REPEAT;
CLOSE cur1;
CLOSE cur2;
END
CREATE DEFINER = 'root'@'localhost' PROCEDURE `compras`()
DETERMINISTIC
CONTAINS SQL
SQL SECURITY DEFINER
COMMENT ''
BEGIN
-- Declare local variables
DECLARE done BOOLEAN DEFAULT 0;
DECLARE o INT;
DECLARE t DECIMAL(8,2);
-- Declare the cursor
DECLARE ordernumbers CURSOR
FOR
SELECT id FROM compra;
-- Declare continue handler
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done=1;
-- Create a table to store the results
CREATE TEMPORARY TABLE IF NOT EXISTS ordertotals
(order_num INT, total DECIMAL(8,2));
-- Open the cursor
OPEN ordernumbers;
-- Loop through all rows
REPEAT
-- Get order number
FETCH ordernumbers INTO o;
-- Get the total for this order
-- Insert order and total into ordertotals
INSERT INTO ordertotals(order_num, total)
VALUES(o, t);
-- End of loop
UNTIL done END REPEAT;
-- Close the cursor
CLOSE ordernumbers;
select * from ordertotals;
drop table ordertotals;
END;
BEGIN
CREATE TEMPORARY TABLE IF NOT EXISTS temporal (id INT, dni varchar(8));
INSERT INTO temporal(id, dni) VALUES(1, "BLAS");
select * from temporal;
drop table temporal;
END
Para llamar a un procedimiento lo hacemos mediante la instrucción CALL. Desde un procedimiento podemos invocar a su vez a otros procedimientos o funciones.
Un procedimiento almacenado, al igual cualquiera de los procedimientos que podamos programar en nuestras aplicaciones utilizando cualquier lenguaje, tiene:
- Un nombre.
- Puede tener una lista de parámetros.
- Tiene un contenido (sección también llamada definición del procedimiento: aquí
- se especifica qué es lo que va a hacer y cómo).
- Ese contenido puede estar compuesto por instrucciones sql, estructuras de control, declaración de variables locales, control de errores, etcétera.
MySQL sigue la sintaxis SQL:2003 para procedimientos almacenados, que también usa IBM DB2.
En resumen, la sintaxis de un procedimiento almacenado es la siguiente:
CREATE PROCEDURE nombre (parámetro)
[características] definición
Puede haber más de un parámetro (se separan con comas) o puede no haber ninguno (en este caso deben seguir presentes los paréntesis, aunque no haya nada dentro).
Los parámetros tienen la siguiente estructura: modo nombre tipo
Donde:
- modo: es opcional y puede ser IN (el valor por defecto, son los parámetros que el procedimiento recibirá), OUT (son los parámetros que el procedimiento podrá modificar) INOUT (mezcla de los dos anteriores).
- nombre: es el nombre del parámetro.
- tipo: es cualquier tipo de dato de los provistos por MySQL.
- Dentro de características es posible incluir comentarios o definir si el procedimiento obtendrá los mismos resultados ante entradas iguales, entre otras cosas.
- definición: es el cuerpo del procedimiento y está compuesto por el procedimiento en sí: aquí se define qué hace, cómo lo hace y bajo qué circunstancias lo hace.
CREATE PROCEDURE simpleproc (INT param1 INT)
BEGIN
SELECT * FROM siniestro limit 0, param1;
END
CREATE PROCEDURE procedimiento2 (IN a INTEGER)
BEGIN
DECLARE variable CHAR(20);
IF a > 10 THEN
SET variable = 'mayor a 10';
ELSE
SET variable = 'menor o igual a 10';
END IF;
select variable;
END
CREATE PROCEDURE curdemo()
BEGIN
DECLARE done INT DEFAULT 0;
DECLARE a CHAR(16);
DECLARE b,c INT;
DECLARE cur1 CURSOR FOR SELECT id,data FROM test.t1;
DECLARE cur2 CURSOR FOR SELECT i FROM test.t2;
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done = 1;
OPEN cur1;
OPEN cur2;
REPEAT
FETCH cur1 INTO a, b;
FETCH cur2 INTO c;
IF NOT done THEN
IF b < c THEN
INSERT INTO test.t3 VALUES (a,b);
ELSE
INSERT INTO test.t3 VALUES (a,c);
END IF;
END IF;
UNTIL done END REPEAT;
CLOSE cur1;
CLOSE cur2;
END
CREATE DEFINER = 'root'@'localhost' PROCEDURE `compras`()
DETERMINISTIC
CONTAINS SQL
SQL SECURITY DEFINER
COMMENT ''
BEGIN
-- Declare local variables
DECLARE done BOOLEAN DEFAULT 0;
DECLARE o INT;
DECLARE t DECIMAL(8,2);
-- Declare the cursor
DECLARE ordernumbers CURSOR
FOR
SELECT id FROM compra;
-- Declare continue handler
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done=1;
-- Create a table to store the results
CREATE TEMPORARY TABLE IF NOT EXISTS ordertotals
(order_num INT, total DECIMAL(8,2));
-- Open the cursor
OPEN ordernumbers;
-- Loop through all rows
REPEAT
-- Get order number
FETCH ordernumbers INTO o;
-- Get the total for this order
-- Insert order and total into ordertotals
INSERT INTO ordertotals(order_num, total)
VALUES(o, t);
-- End of loop
UNTIL done END REPEAT;
-- Close the cursor
CLOSE ordernumbers;
select * from ordertotals;
drop table ordertotals;
END;
BEGIN
CREATE TEMPORARY TABLE IF NOT EXISTS temporal (id INT, dni varchar(8));
INSERT INTO temporal(id, dni) VALUES(1, "BLAS");
select * from temporal;
drop table temporal;
END
jueves, 24 de enero de 2013
Triggers
El soporte para TRIGGERS en MySQL se realizó a partir de la versión 5.0.2. Un trigger puede ser definido para activarse en un INSERT, DELETE o UPDATE en una tabla y puede configurarse para activarse ya sea antes o después de que se haya procesado cada renglón por el query.
Los TRIGGERS en MySQL tienen la misma limitante que las funciones. No pueden referirse a una tabla en general. Pueden solamente referirse a un valor del renglón que está siendo modificado por el query que se está ejecutando.
Las características más importantes de los TRIGGERS son:
Puede examinar el contenido actual de un renglón antes de que sea borrado o actualizado
Puede examinar un nuevo valor para ser insertado o para actualizar un renglón de una tabla
Un BEFORE TRIGGER, puede cambiar el nuevo valor antes de que sea almacenado en la base de datos, lo que permite realizar un filtrado de la información.
El siguiente ejemplo muestra un BEFORE TRIGGER para un SELECT de una tabla:
CREATE TABLE t(i INT, dt DATETIME);
delimiter $
CREATE TRIGGER t_ins BEFORE INSERT ON t
FOR EACH ROW BEGIN
SET NEW.dt = CURRENT_TIMESTAMP;
IF NEW.i < 0 THEN
SET NEW.i = 0;
END IF;
END$
delimiter ;
Los TRIGGERS en MySQL tienen la misma limitante que las funciones. No pueden referirse a una tabla en general. Pueden solamente referirse a un valor del renglón que está siendo modificado por el query que se está ejecutando.
Las características más importantes de los TRIGGERS son:
Puede examinar el contenido actual de un renglón antes de que sea borrado o actualizado
Puede examinar un nuevo valor para ser insertado o para actualizar un renglón de una tabla
Un BEFORE TRIGGER, puede cambiar el nuevo valor antes de que sea almacenado en la base de datos, lo que permite realizar un filtrado de la información.
El siguiente ejemplo muestra un BEFORE TRIGGER para un SELECT de una tabla:
CREATE TABLE t(i INT, dt DATETIME);
delimiter $
CREATE TRIGGER t_ins BEFORE INSERT ON t
FOR EACH ROW BEGIN
SET NEW.dt = CURRENT_TIMESTAMP;
IF NEW.i < 0 THEN
SET NEW.i = 0;
END IF;
END$
delimiter ;
Estructuras de Control
Las estructuras de control permiten, como su nombre lo indica, controlar el flujo de las instrucciones dentro de un procedimiento o una función. En la siguiente explicación, cada ocurrencia de instrucción(es), indica una lista de una o más instrucciones, cada una de las cuales debe terminar con ";".
Algunas de las estructuras pueden llevar una etiqueta (BEGIN, LOOP, REPEAT y WHILE). Las etiquetas no son sensibles a las mayúsculas o minúsculas pero deben seguir las siguientes reglas:
Si una etiqueta aparece al principio de alguna estructura, deberá también aparecer al final de la misma.
Una etiqueta no deberá aparecer al final de una estructura sin tener su correspondiente pareja al principio de la misma.
BEGIN ... END
BEGIN [instrucción(es)] END
etiqueta: BEGIN [instrucción(es)] END [etiqueta]
La estructura BEGIN … END se utiliza para agrupar un conjunto de instrucciones. Si un procedimiento o una función necesita contener más de una intrucción, éstas deberán aparecer dentro de un BEGIN … END. De la misma manera, si el procedimiento o función contienen una rutina DECLARE, ésta deberá aparecer al principio del bloque BEGIN … END.
CASE
CASE [expresión]
WHEN expresión1 THEN instruccion(es)
[WHEN expresión2 THEN instruccion(es)]
...
[ELSE instruccion(es)]
END CASE;
IF
IF expr1 THEN instruccion(es)
[ELSEIF expr2 THEN instruccion(es)] ...
[ELSE instruccion(es)]
END IF
ITERATE
ITERATE etiqueta
ITERATE solamente puede aparecer dentro de un LOOP, REPEAT y WHILE . Lo que realmente significa es: "Haz el ciclo de Nuevo". Por ejemplo:
delimiter $
CREATE PROCEDURE doiterate(p1 INT)
BEGIN
label1: LOOP
SET p1 = p1 + 1;
IF p1 < 10 THEN
ITERATE label1;
END IF;
LEAVE label1;
END LOOP label1;
SET @x = p1;
END$
delimiter ;
LEAVE
LEAVE etiqueta
Esta instrucción es utilizada para salir de alguna estructura de control. Puede ser usada dentro de un BEGIN … END o dentro de algún ciclo.
LOOP
[etiqueta_inicio:] LOOP
instruccion(es)
END LOOP [etiqueta_fin]
LOOP implementa un ciclo simple, permitiendo que una instrucción o conjunto de instrucciones se repitan. Las instrucciones dentro de este ciclo se repetirán hasta que se ocasione alguna salida, lo cual se hace generalmente con una instrucción LEAVE.
Un ciclo LOOP puede ser etiquetado. etiqueta_fin no puede estar presente a menos que etiqueta_inicio también lo está y, si ambos están presentes, deberán ser iguales.
REPEAT
[etiqueta_inicio:] REPEAT
instruccion(es)
UNTIL condicion
END REPEAT [etiqueta_fin];
La instrucción o instrucciones dentro de un ciclo REPEAT se repetirán hasta que la condicion sea verdadadera.
Un ciclo REPEAT puede ser etiquetado. etiqueta_fin no puede estar presente a menos que etiqueta_inicio también lo está y, si ambos están presentes, deberán ser iguales.
RETURN
RETURN expresión;
La instrucción RETURN se utiliza solamente dentro de una función. Al ejecutarse, terminará por completo la función dentro de la que se encuentra.
WHILE
[etiqueta_inicio:] WHILE condición DO
instruccion(es)
END WHILE [etiqueta_fin]
La instrucción o instrucciones dentro de un WHILE serán repetidas mientras la condición sea verdadera.
Un ciclo WHILE puede ser etiquetado. etiqueta_fin no puede estar presente a menos que etiqueta_inicio también lo está y, si ambos están presentes, deberán ser iguales.
Algunas de las estructuras pueden llevar una etiqueta (BEGIN, LOOP, REPEAT y WHILE). Las etiquetas no son sensibles a las mayúsculas o minúsculas pero deben seguir las siguientes reglas:
Si una etiqueta aparece al principio de alguna estructura, deberá también aparecer al final de la misma.
Una etiqueta no deberá aparecer al final de una estructura sin tener su correspondiente pareja al principio de la misma.
BEGIN ... END
BEGIN [instrucción(es)] END
etiqueta: BEGIN [instrucción(es)] END [etiqueta]
La estructura BEGIN … END se utiliza para agrupar un conjunto de instrucciones. Si un procedimiento o una función necesita contener más de una intrucción, éstas deberán aparecer dentro de un BEGIN … END. De la misma manera, si el procedimiento o función contienen una rutina DECLARE, ésta deberá aparecer al principio del bloque BEGIN … END.
CASE
CASE [expresión]
WHEN expresión1 THEN instruccion(es)
[WHEN expresión2 THEN instruccion(es)]
...
[ELSE instruccion(es)]
END CASE;
IF
IF expr1 THEN instruccion(es)
[ELSEIF expr2 THEN instruccion(es)] ...
[ELSE instruccion(es)]
END IF
ITERATE
ITERATE etiqueta
ITERATE solamente puede aparecer dentro de un LOOP, REPEAT y WHILE . Lo que realmente significa es: "Haz el ciclo de Nuevo". Por ejemplo:
delimiter $
CREATE PROCEDURE doiterate(p1 INT)
BEGIN
label1: LOOP
SET p1 = p1 + 1;
IF p1 < 10 THEN
ITERATE label1;
END IF;
LEAVE label1;
END LOOP label1;
SET @x = p1;
END$
delimiter ;
LEAVE
LEAVE etiqueta
Esta instrucción es utilizada para salir de alguna estructura de control. Puede ser usada dentro de un BEGIN … END o dentro de algún ciclo.
LOOP
[etiqueta_inicio:] LOOP
instruccion(es)
END LOOP [etiqueta_fin]
LOOP implementa un ciclo simple, permitiendo que una instrucción o conjunto de instrucciones se repitan. Las instrucciones dentro de este ciclo se repetirán hasta que se ocasione alguna salida, lo cual se hace generalmente con una instrucción LEAVE.
Un ciclo LOOP puede ser etiquetado. etiqueta_fin no puede estar presente a menos que etiqueta_inicio también lo está y, si ambos están presentes, deberán ser iguales.
REPEAT
[etiqueta_inicio:] REPEAT
instruccion(es)
UNTIL condicion
END REPEAT [etiqueta_fin];
La instrucción o instrucciones dentro de un ciclo REPEAT se repetirán hasta que la condicion sea verdadadera.
Un ciclo REPEAT puede ser etiquetado. etiqueta_fin no puede estar presente a menos que etiqueta_inicio también lo está y, si ambos están presentes, deberán ser iguales.
RETURN
RETURN expresión;
La instrucción RETURN se utiliza solamente dentro de una función. Al ejecutarse, terminará por completo la función dentro de la que se encuentra.
WHILE
[etiqueta_inicio:] WHILE condición DO
instruccion(es)
END WHILE [etiqueta_fin]
La instrucción o instrucciones dentro de un WHILE serán repetidas mientras la condición sea verdadera.
Un ciclo WHILE puede ser etiquetado. etiqueta_fin no puede estar presente a menos que etiqueta_inicio también lo está y, si ambos están presentes, deberán ser iguales.
Suscribirse a:
Entradas (Atom)