Explorando la Categoría: "BBDD"

Wordpress 2.6 incluye Google Gears para trabajar offline

BBDD, Javascript, Joomla, Wordpress

16 de Mayo del 2008

Leyendo anieto2k me entero que en la versión 2.6 de Wordpress se incluirá la tecnología Google Gears para trabajar offline, de esta manera se podrá seguir ecribiendo artículos aunque estemos en el campo sin conexión a internet, y después, en cuanto el navegador detecte una conexión, se sincronizará con la web y publicará todo el contenido escrito, un gran acierto

Cada vez se hace más potente la programación web y las posibilidades se hacen infinitas.

Google Gears es una implementación de Google para almacenar datos en el cliente y aún no esta muy extendido su uso, pero en el futuro standard HTML 5 esta prevista la inclusión de una BBDD en el navegador para facilitar la labor al programador y hacer las aplicaciones más dinamicas.

Ahora la pregunta para mí es: ¿Para cuando una cosa así en Joomla? , espero que no tarde mucho en desarrollarse.

Compártelo!

Author david   Comment RSS 2 Comentarios

Cómo crear triggers en MySQL 5

BBDD

27 de Marzo del 2008

Otra de las nuevas características incluidas en MySQL, además de los procedimientos almacenados, son los triggers, que traducido sería algo así como disparadores, son oyentes, que se mantienen a la escucha de los eventos que puedan producirse en una tabla (insert , update y delete) y ejecutan un código antes (before) o después (after) de que se produzca este evento.

Con los triggers podemos hacer cosas tan interesantes como mantener un log de que usuarios hace modificaciones en una tabla, que usuarios borran registros, o insertan, o lo que se te ocurra.

Para referenciar las columnas de antes y después de que el vento se haya disparado, se usan las palabras clave OLD y NEW. Con la sentencia insert solo se permite NEW, con update se permiten ambas y con delete solo OLD.

Sintaxis necesaria para crear un trigger

  1. CREATE TRIGGER <nombre>
  2.     {BEFORE|AFTER}
  3.     {INSERT|UPDATE|DELETE}
  4.     ON
  5. <tablename>
  6.     FOR EACH ROW
  7.     BEGIN
  8.     <sentenciasSQL>
  9.     END;
  10.  

Para poner nombre a los triggers es conveniente seguir una convención que hará más fácil identificar sobre que evento y tabla actúa el trigger. Esta sería una buena forma de nombrar nuestros triggers:

NombreTabla + “_” + abreviatura_tipo_tigger

Por lo tanto para nombrar un triger que se ejecuta sobre la tabla T1 después de un update lo haríamos de la siguiente forma si seguimos esta convención:

“T1_BU”

Esto puede ser útil, pero no es necesario, puedes poner el nombre que quieras a tu trigger.

Para crear triggers en una tabla es necesario hacerlo desde un usuario con permisos para ello. Para dar permiso a un usuario en una tabla para crear un trigger lo haríamos de la siguiente forma:

  1. GRANT CREATE TRIGGER ON nombreTabla TO Usuario
  2.  

Vamos a ver un ejemplo sencillo:

Creamos la tabla miTabla

  1. CREATE TABLE miTabla( id int , nombre varchar(50) );
  2.  

Y después creamos un trigger que va a crear una variable global con el nombre antiguo antes de ejecutar el update y otra con el nombre nuevo que habrá después de ejecutar el update.

  1. delimiter //
  2. CREATE TRIGGER miTabla_bu before UPDATE
  3. ON miTabla
  4. FOR each row
  5. begin
  6.     SET @nombreViejo = OLD.nombre;
  7.     SET @nombreNuevo = NEW.nombre;
  8. end//
  9.  

Vamos a ver otro tigger :

  1. CREATE TRIGGER miTabla_bi
  2. before INSERT ON miTabla
  3. FOR each row
  4. begin
  5.     SET @x = ‘Trigger activado’;
  6.     SET NEW.nombre = ‘Valor introducido desde el TRIGGER’;
  7. end//
  8.  

En esta ocasión, cada vez que se haga un insert sobre la tabla miTabla, se creará una variable global con el valor ‘Trigger activado’ y modificará el valor que se insertará en la columna nombre, por lo que siempre se insertará el valor ‘Valor introducido desde el trigger’.

Si lo que queremos es mantener el control de una tabla para ver quien la modifica y a que hora, podemos crear una tabla donde iremos anotando quien hace cada modificación y anotar los cambios.

Creamos la tabla auxiliar

  1. CREATE TABLE controlMiTabla
  2. (
  3.    id int NOT NULL AUTO_INCREMENT,
  4.    id_registro int,
  5.    anterior_nombre varchar(50),
  6.    nuevo_nombre varchar(50),
  7.    usuario varchar(40),
  8.    modificado datetime,
  9.    PRIMARY KEY(id)
  10. ) ENGINE = InnoDB;
  11.  

Y ahora vamos a crear un trigger que se encargue de llevar un log de quien actualiza la tabla, que valores modifica y a que hora:

  1. delimiter //
  2. CREATE TRIGGER MiTabla_BU after UPDATE ON miTabla
  3.    FOR each row
  4.     begin
  5.          INSERT INTO controlMiTabla (id_registro, anterior_nombre , nuevo_nombre, usuario  , modificado ) VALUES(OLD.id , OLD.nombre , NEW.nombre, CURRENT_USER(), NOW() );
  6.     end//
  7.  

Y ya tenemos nuestro trigger creado, con el cual llevaremos el control de la tabla.

Esto es recomendable hacerlo solo en las tablas de importancia critica, ya que si no nuestra base de datos crecerá de forma innecesaria.

Compártelo!

Author david   Comment RSS No hay Comentarios

Cómo crear funciones en MySQL

BBDD

20 de Marzo del 2008

Como hemos comentado en el post de procedimientos almacenados, tener nuestras funciones y procedimientos en MySQL en lugar de de procesar los datos con algún lenguaje del lado del servidor, como PHP , tiene la ventaja de que viaja menos información de la base de datos al servidor web , con el consiguiente aumento del rendimiento y que estas funciones harán que podamos atacar la base de datos desde cualquier otro lenguaje, como Java o ASP.NET sin tener que volver a procesar los datos otra vez.

MySQL tiene muchas funciones que podemos usar en nuestro procedimientos almacenados y consultas, pero en ocasiones podemos necesitar crear nuestras propias funciones para hacer cosas más especializadas…

Vamos a ver cómo crear funciones en MySQL:

  1. DELIMITER //
  2.  
  3. CREATE FUCNTION holaMundo() RETURNS VARCHAR(20)
  4. BEGIN
  5.     RETURN ‘HolaMundo’;
  6. END
  7. //
  8.  

Para comprobar que funciona tecleamos lo siguiente en la consola de MySQL :

  1. SELECT holaMundo();

Lo que devuelve el siguiente resultado : 

mysql> select holaMundo()//

+--------------+
| holaMundo()  |
+--------------+
| Hola Mundo!! |
+--------------+
1 row in set (0.00 sec)

Para borrar la función que acabamos de crear :

  1. DROP FUNCTION IF EXISTS holaMundo
  2.  

Uso de las variables en funciones:

Las variables en las funciones se usan de igual manera que en los procedimientos almacenados, se declaran con la sentencia DECLARE, y se asignan valores con la sentencia SET.

  1. DELIMITER //
  2.  
  3. CREATE FUNCTION holaMundo() RETURNS VARCHAR(30)
  4. BEGIN
  5.   DECLARE salida VARCHAR(30) DEFAULT ‘Hola mundo’;
  6. ;
  7.   SET salida = ‘Hola mundo con VARIABLES’;
  8.   RETURN salida;
  9. END
  10. //
  11.  

Esta variable es de ámbito local, y será destruida una vez finalice la función. Cabe destacar el uso de la sentencia DEFAULT en conjunto con DECLARE, que asigna un valor por defecto al declarar la variable.

Uso de parámetros en funciones:

  1. DROP FUNCTION IF EXISTS holaMundo
  2.  
  3. CREATE FUNCTION holaMundo(entrada VARCHAR(20)) RETURNS VARCHAR(20)
  4. BEGIN
  5.   DECLARE salida VARCHAR(20);
  6.   SET salida = entrada;
  7.   RETURN salida;
  8. END
  9.  

Ahora hemos creado una función que devuelve el mismo valor que le pasamos como parámetro.

Si tecleamos : 

mysql> select holaMundo("nosolocodigo")//
+---------------------------+
| holaMundo("nosolocodigo") |
+---------------------------+
| nosolocodigo             |
+---------------------------+
1 row in set (0.00 sec)

Obtenemos como resultado lo mismo que le hemos pasado como párametro, en este caso “nosolocodigo”

Para finalizar, algo un poco más complejo, vamos a crear una función que acepte un dividendo y un divisor y haga una división sin usar el operador división:

  1. CREATE FUNCTION divide(dividendo int,divisor int) returns int
  2. begin
  3.     declare aux int;
  4.     declare contador int;
  5.     declare resto int;
  6.     SET contador = 0;
  7.     SET aux = 0;
  8.     while (aux + divisor) <= dividendo do
  9.         SET aux = aux + divisor ;
  10.         SET contador = contador + 1;
  11.     end while;
  12.     SET resto = dividendo - aux ;
  13. RETURN contador;
  14. end;
  15. //
  16.  

Para usarlo, simplemente llamaríamos a la función así:

  1. SELECT divide(20,2)
  2.  

Lo que devolvería 10.

Mirar el post sobre el control de flujo con procedimientos almacenados si no entiendes esta última función.

Compártelo!

Author david   Comment RSS 4 Comentarios

Crear handlers para manejar errores en MySQL 5

BBDD

19 de Marzo del 2008

Seguimos con MySQL,hemos visto cómo hacer procedimientos almacenados y cómo controlar el flujo de estos. Ahora le toca el turno a los handlers…

Cuando trabajamos con procedimientos almacenados en MySQL tenemos que tener en cuenta que durante la ejecución de nuestra aplicación se pueden producir errores.

Por ejemplo, si estamos trabajando con el motor de base de datos innoDB y definimos claves ajenas, podrán producirse errores de integridad referencial si intentamos hacer un insert en un campo que clave ajena y el valor que intentamos introducir no existe en la tabla que referencia.

Para llevar el control de estos errores podemos definir handlers en nuestro procedimientos almacenados .

Cada error en MySQL desprende un código de error, el cual tendremos que anotar para manejarlo en nuestro handler.

Ejemplo de un handler

Creamos la siguiente tabla:

  1.    CREATE TABLE t2(
  2.     s1 int,
  3.     PRIMARY KEY (s1))engine=innodb;
  4.  

Después creamos esta otra que contiene una clave ajena que hace referencia a la anterior :

  1.    CREATE TABLE t3 (
  2.     s1 int, KEY(s1),
  3.     FOREIGN KEY (s1) REFERENCES t2 (s1))engine=innodB;
  4.  

Después intentamos insertar un valor en la tabla t3, se trata de un valor que no se encuentra en la columna de t2 que referencia… lo que arroja el siguiente error en la consola de mysql:

  1. INSERT INTO t3 VALUES(5);
  2.  

Error:

ERROR 1452 (23000): Cannot add or update a child row: a foreign key constraint fails (`pruebas/t3`, CONSTRAINT `t3_ibfk_1` FOREIGN KEY (`s1`) REFERENCES `t2` (`s1`))

Anota el código de error desprendido por que es lo que necesitamos para crear un handler que maneje este error, en este caso 1452.

Para manejar el error creamos un handler que almacenara el error en una tabla que vamos a crear donde iremos guardando un log de errores…

  1. CREATE TABLE error_log(error_message varchar(80));
  2.  

Ahora creamos el procedimiento almacenado que se encargara de introducir datos en la BD y manejar excepciones:

  1. delimiter //
  2. CREATE procedure procedimientoConHandler(parametro1 int)
  3. begin
  4.     declare exit handler FOR 1452
  5.     begin
  6.         INSERT INTO error_log VALUES (concat(‘Time: ‘,current_date,‘. Error de clave ajena para el valor= ‘, parametro1));
  7.     end;
  8.     INSERT INTO t3 VALUES (parametro1);
  9.     .
  10.     .
  11.     .
  12. end;
  13. //
  14.  

Creamos dentro del procedimiento un manejador de errores para el tipo de error deseado para que cuando se produzca el error introduzca en una tabla que indiquemos un log de errores y no falle la aplicación . La palabra exit significa que cuando se acabe la ejecución del handler se sale del procedimiento almacenado, si ponemos continue en lugar de exit, la ejecución de procedimiento almacenado proseguiría.

De esta manera para introducir valores en la base de datos lo haces llamando al procedimiento para que maneje los errores y tener un mayor control sobre la aplicación.

Ya tenemos nuestro procedimiento almacenado creado con control de errores.

Sintaxis para declarar handlers:

declare {exit | continue } handler for {error-number | {SQLSTATE error-string}}

Referencia : Documentación oficial de MySQL

Compártelo!

Author david   Comment RSS No hay Comentarios

Control de flujo en procedimientos almacenados para MySQL 5

BBDD

18 de Marzo del 2008

Seguimos con los procedimientos almacenados. Vamos a ver como llevar a cabo el control de flujo de nuestro procedimiento. También es interesante observar el uso de las variables dentro de los procedimientos. Si se declara una variable dentro de un procedimiento mediante el código :

  1.        declare miVar int;
  2.  

Esta tendrá un ámbito local y cuando se acabe el procedimiento no podrá ser accedida. Una vez la variable es declarada, para cambiar su valor usaremos la sentencia SET de este modo :

  1.        SET miVar = 56 ;
  2.  

Para poder acceder a una variable a la finalización de un procedimiento se tiene que usar parámetros de salida.

Vamos a ver unos ejemplos para comprobar lo sencillo que es :

IF THEN ELSE

  1.  
  2. delimiter //
  3. CREATE procedure miProc(IN p1 int)     /* Parámetro de entrada */
  4.     begin
  5.         declare miVar int;        /* se declara variable local */
  6.         SET miVar = p1 +1 ;        /* se establece la variable */
  7.         IF miVar = 12 then
  8.             INSERT INTO lista VALUES(55555);
  9.         else
  10. INSERT INTO lista VALUES(7665);
  11.         end IF;
  12.     end;
  13. //
  14.  

SWITCH

  1.  
  2. delimiter //
  3. CREATE procedure miProc (IN p1 int)
  4.     begin
  5.         declare var int ;
  6.         SET var = p1 +2 ;
  7.         case var
  8.             when 2 then INSERT INTO lista VALUES (66666);
  9.             when 3 then INSERT INTO lista VALUES (4545665);
  10.             else INSERT INTO lista VALUES (77777777);
  11.         end case;
  12.     end;
  13. //
  14.  

Creo que no hacen falta explicaciones.

COMPARACIÓN DE CADENAS

  1.  
  2. delimiter //
  3. CREATE procedure compara(IN cadena varchar(25), IN cadena2 varchar(25))
  4.     begin
  5.         IF strcmp(cadena, cadena2) = 0 then
  6.             SELECT "son iguales!";
  7.         else
  8.             SELECT "son diferentes!!";
  9.         end IF;
  10.     end;
  11. //
  12.  

La función strcmp devuelve 0 si las cadenas son iguales, si no devuelve 0 es que son diferentes.

USO DE WHILE

  1.  
  2. delimiter //
  3. CREATE procedure p14()
  4.     begin
  5.         declare v int;
  6.         SET v = 0;
  7.         while v < 5 do
  8.             INSERT INTO lista VALUES (v);
  9.             SET v = v +1 ;
  10.         end while;
  11.     end;
  12. //
  13.  

Un while de toda la vida.

USO DEL REPEAT

  1.  
  2. delimiter //
  3. CREATE procedure p15()
  4.     begin
  5.         declare v int;
  6.         SET v = 20;
  7.         repeat
  8.             INSERT INTO lista VALUES(v);
  9.             SET v = v + 1;
  10.         until v >= 1
  11.         end repeat;
  12.     end;
  13. //
  14.  

El repeat es similar a un “do while” de toda la vida.

LOOP LABEL

  1.  
  2. delimiter //
  3. CREATE procedure p16()
  4.     begin
  5.         declare v int;
  6.         SET v = 0;
  7.         loop_label : loop
  8.             INSERT INTO lista VALUES (v);
  9.             SET v = v + 1;
  10.             IF v >= 5 then
  11.             leave loop_label;
  12.             end IF;
  13.         end loop;
  14.     end;
  15. //
  16.  

Este es otro tipo de loop, la verdad es que teniendo los anteriores no se me ocurre aplicación para usar este tipo de loop, pero es bueno saber que existe por si algún día te encuentras algún procedimiento muy antiguo que lo use. El código que haya entre loop_label : loop y end loop; se ejecutara hasta que se encuentre la sentencia leave loop_label; que hemos puesto en la condición, por lo tanto el loop se repetirá hasta que la variable v sea >= que 5.

El loop puede tomar cualquier nombre, es decir puede llamarse miLoop: loop, en cuyo caso se repetirá hasta que se ejecute la sentencia leave miLoop.

Con esto ya podemos empezar a crear procedimientos medianamente complejos y útiles.

Compártelo!

Author david   Comment RSS 8 Comentarios
« Entradas Anteriores
blank
[x] Cerrar
E-mail