miércoles, 30 de junio de 2010
lunes, 28 de junio de 2010
miércoles, 23 de junio de 2010
martes, 22 de junio de 2010
lunes, 21 de junio de 2010
lunes, 14 de junio de 2010
lunes, 7 de junio de 2010
Manual de Mysql 5
Algunos de los temas en el manual:
- Información General
- Instalar MySQL
- Tutorial de MySQL
- Usar los programas de MySQL
- Administración de Base de Datos
- Replicación en MySQL, etc
http://rapidshare.com/files/396343677/Manual_de_MySql.pdf
- Información General
- Instalar MySQL
- Tutorial de MySQL
- Usar los programas de MySQL
- Administración de Base de Datos
- Replicación en MySQL, etc
http://rapidshare.com/files/396343677/Manual_de_MySql.pdf
Tutorial de Erwin
Descargar libro de la sgte dirección:
http://rapidshare.com/files/396341996/ldErwin.PDF
http://rapidshare.com/files/396341996/ldErwin.PDF
Base de Datos con SQL Server 200
El texto está diseñado para programadores, analistas o técnicos de sistemas que deseen conocer la mecánica de trabajo de las bases de datos a través del uso de una de ellas en concreto: Microsoft SQL Server 2000.
Aspectos que se revisan:
1- Conceptos teóricos sobre Bases de Datos.
2- Diseño y modelización de datos tomando como base el modelo Entidad/Relación
3- Generalidades de SQL Server 2000
4- Lenguaje SQL a través de la implementación del mismo en SQL Server 2000 (Transact SQL)
5- Ejemplos de diseño utilizando una herramienta CASE: Power Designor
Aspectos que se revisan:
1- Conceptos teóricos sobre Bases de Datos.
2- Diseño y modelización de datos tomando como base el modelo Entidad/Relación
3- Generalidades de SQL Server 2000
4- Lenguaje SQL a través de la implementación del mismo en SQL Server 2000 (Transact SQL)
5- Ejemplos de diseño utilizando una herramienta CASE: Power Designor
Procedimientos almacenados en Mysql 5
Hoy, mientras leía mensajes del correo antiguo rescaté unos apuntes de un curso de programación que hice el pasado verano. Los apuntes eran de MySQL 5, más específicamente de cómo hacer procedimientos almacenados , triggers , handlers, funciones y toda esa parafernalia que MySQL implementa en su versión 5.
MySQL ha sido siempre un motor de bases de datos muy rápido y muy utilizado para proyectos open source de código abierto, sobre todo para proyectos web dada su gran velocidad. Pero también a sido muy criticado por la falta de características avanzadas que otros Sistemas Gestores de Bases de Datos , como Oracle, SQLServer de Microsoft o PostgreSQL si tenían. Estas características avanzadas son sobre todo los procedimientos almacenados, triggers, transacciones y demás cosas.
MySQL, que ahora forma parte de Sun, se puso las pilas y en su versión 5 implementó muchas de estas características, dejando un SGBD muy rápido y además muy bien preparado para implementar bases de datos realmente grandes y mantenibles.
Pero, ¿qué es realmente un procedimiento almacenado? Pues es un programa que se almacena físicamente en una tabla dentro del sistema de bases de datos. Este programa esta hecho con un lenguaje propio de cada Gestor de BD y esta compilado, por lo que la velocidad de ejecución será muy rápida.
Principales Ventajas :
- Seguridad:Cuando llamamos a un procedimiento almacenado, este deberá realizar todas las comprobaciones pertinentes de seguridad y seleccionará la información lo más precisamente posible, para enviar de vuelta la información justa y necesaria y que por la red corra el mínimo de información, consiguiendo así un aumento del rendimiento de la red considerable.
- Rendimiento: el SGBD, en este caso MySQL, es capaz de trabajar más rápido con los datos que cualquier lenguaje del lado del servidor, y llevará a cabo las tareas con más eficiencia. Solo realizamos una conexión al servidor y este ya es capaz de realizar todas las comprobaciones sin tener que volver a establecer una conexión. Esto es muy importante, una vez leí que cada conexión con la BD puede tardar hasta medios segundo, imagínate en un ambiente de producción con muchas visitas como puede perjudicar esto a nuestra aplicación… Otra ventaja es la posibilidad de separar la carga del servidor, ya que si disponemos de un servidor de base de datos externo estaremos descargando al servidor web de la carga de procesamiento de los datos.
- Reutilización: el procedimiento almacenado podrá ser invocado desde cualquier parte del programa, y no tendremos que volver a armar la consulta a la BD cada que vez que queramos obtener unos datos.
Desventajas:
El programa se guarda en la BD, por lo tanto si se corrompe y perdemos la información también perderemos nuestros procedimientos. Esto es fácilmente subsanable llevando a cabo una buena política de respaldos de la BD.
Tener que aprender un nuevo lenguaje… esto es siempre un engorro, sobre todo si no tienes tiempo.
¿Alguna otra?
Por lo tanto es recomendable usar procedimientos almacenados siempre que se vaya a hacer una aplicación grande, ya que nos facilitará la tarea bastante y nuestra aplicación será más rápida.
Vamos a ver un ejemplo :
Abrimos una consola de MySQL seleccionamos una base de datos y empezamos a escribir:
Vamos a crear dos tablas en una almacenaremos las personas mayores de 18 años y en otra las personas menores.
CREATE TABLE ninos(edad int, nombre varchar(50)); CREATE TABLE adultos(edad int, nombre varchar(50));
Imagínate que ahora queremos introducir personas en las tablas pero dependiendo de la edad queremos que se introduzcan en una tabla u otra, si estamos usando PHP podríamos comprobar mediante código si la persona es mayor de edad. Lo haríamos así:
$nombre = $_POST[‘nombre’]; $edad = $_POST[‘edad’]; if($edad < 18){ mysql_query(‘insert into ninos values(’ . $edad . ‘ , “’.$nombre.’”)’); }else{ mysql_query(‘insert into adultos values(’ . $edad . ‘ , “’.$nombre.’”)’); }
Si la consulta es corta como en este caso, esta forma es incluso más rápida que tener que crear un procedimiento almacenado, pero si tienes que hacer esto muchas veces a lo largo de tu aplicación es mejor hacer lo siguiente:
Creamos el procedimiento almacenado:
delimiter // CREATE procedure introducePersona(IN edad int,IN nombre varchar(50)) begin IF edad < 18 then INSERT INTO ninos VALUES(edad,nombre); else INSERT INTO adultos VALUES(edad,nombre); end IF; end; //
Ya tenemos nuestro procedimiento , vamos a por una visión más detallada…
La primera linea es para decirle a mySQL que a partir de ahroa hasta que no introduzcamos // no se acaba la sentencia, esto lo hacemos así por que en nuestro procedimiento almacenado tendremos que introducir el carcter “;” para las sentencias, y si pulamos enter MySQL pensará que ya hemos acabado la consulta y dará error.
Con create procedure empezamos la definición de procedimiento con nombre introducePersona. En un procedimiento almacenado existen parámetros de entrada y de salida, los de entrada (precedidos de “in”) son los que le pasamos para usar dentro del procedimiento y los de salida (precedidos de “out”) son variables que se establecerán a lo largo del procedimiento y una vez esta haya finalizado podremos usar ya que se quedaran en la sesión de MySQL.
En este procedimiento simple solo vamos usar de entrada, más adelante veremos como usar parámetros de salida.
Para hacer una llamada a nuestro procedimiento almacenado usaremos la sentencia call:
call introducePersona(25,”JoseManuel”);
Una vez tenemos ya nuestro procedimiento simplemente lo ejecutaremos desde PHP mediante una llamada como esta:
$nombre = $_POST['nombre']; $edad = $_POST['edad']; mysql_query(‘call introducePersona(’ . $edad . ‘ ,“ ’.$nombre.’ ”);’);
De ahora en adelante, usaremos siempre el procedimiento para introducir personas en nuestra BD de manera que si tenemos 20 scritps PHP que lo usan y un buen día decidimos que la forma de introducir personas no es la correcta, solo tendremos que modificar el procedimiento introducePersona y no los 20 scrits.
Como Redireccionar una Página de WordPress
Buenas, aquí les traigo otra técnica interesante para WordPress que nos permitirá redireccionar a cualquier URL desde una página de nuestro blog, existen plugins que hacen esto, pero para que usar uno si lo podemos hacer con una simples líneas y sin consumir nuestro ancho de banda (tal vez un poco pero no tanto al usar un plugin).
Esta técnica fue hecha por Dave Stewart y para usarla tenemos que crear una plantilla para usarla en la pagina que vamos a redireccionar, empecemos.
Paso 1:
Primero vamos a crear un archivo llamado template-redirect.php dentro de la carpeta de nuestro theme, por ejemplo, wordpress_root_directory/wp-content/themes/default/ y ahi debemos crear el archivo, quedándonos así ya con el archivo creado: wordpress_root_directory/wp-content/themes/default/template-redirect.php. Aun nos falta copiar las siguientes líneas al archivo recién creado con algún software, como por ejemplo, Adobe Dreamweaver o simplemente el Bloc de Notas que trae Windows.
Paso 2:Código HTML:/* Template Name: Page Redirect * @author Dave Stewart * @email dave@davestewart.co.uk * @web www.davestewart.co.uk * @name Page Redirect * @type PHP page * @desc Wordpress template that redirects the current page based on the content of the database entry it loads * @requires Wordpress * @install Copy this file to the directory of the theme you wish to use * usage 1. Create a new Page in your Wordpress control panel 2. Enter the URL (or local path, relative to your Wordpress directory) you want to redirect to as the only page content 3. Set the Page Template to "Page Redirect" 4. Publish */ if (function_exists('have_posts') && have_posts()){ while (have_posts()){ // get the post the_post(); // get content ob_start(); the_content(); $contents = ob_get_contents(); ob_end_clean(); // correctly build the link // grab the 'naked' link $link = strip_tags($contents); $link = preg_replace('/\s/', '', $link); // work out if(!preg_match('%^http://%', $link)){ $host = $_SERVER['HTTP_HOST']; $dir = dirname($_SERVER['PHP_SELF']); $link = "http://$host$dir/$link"; } // do the link header("Location: $link"); die(''); } } ?>
Ya creado el archivo con su respectivo código debemos ir a nuestro panel de administración en WordPress, de ahí tenemos que crear una nueva página para nuestro sitio, para ello, vamos a Páginas-> Crear y en la lista de Plantillas va a aparecer la que recién creamos, la elegimos y en el contenido ingresamos la URL donde queremos que se redireccione nuestra página al entrar.
Listo, solo nos queda probar si funciona yendo al inicio de nuestro blog y accediendo a la página creada, si funciona, se debería redireccionar a la URL indicada en el contenido de la pagina creada. Si no has podido o no sabes crear el archivo con su código, lo puedes bajar desde aquí.
Transacciones anidadas - MySQL
Las transacciones anidadas
Recordemos como funcionan las transacciones. Tenemos 4 sentencias que son:
• BEGIN TRAN: Comienza una transacción y aumenta en 1 @@TRANCOUNT
• COMMIT TRAN: Reduce en 1 @@TRANCOUNT, y si @@TRANCOUNT llega a 0 guarda la transacción
• ROLLBACK TRAN: Deshace la transacción actual, o si estamos en transacciones anidadas deshace la más externa y todas las internas. Además pone @@TRANCOUNT a 0
• SAVE TRAN: Guarda un punto (con nombre) al que podemos volver con un ROLLBACK TRAN si es que estamos en transacciones anidadas y no queremos deshacer todo hasta la más externa.
Un par de ejemplos dejarán las cosas más claras:
Uso del commit
Uso del rollback
En cuanto al SAVE TRAN podemos recordarlo con el siguiente ejemplo:
Un ROLLBACK a un SAVE TRAN no deshace la transacción en curso ni modifica @@TRANCOUNT, simplemente cancela lo ocurrido desde el ‘SAVE TRAN nombre‘ hasta su ‘ROLLBACK TRAN nombre’
Transacciones y procedimientos almacenados…
Cuando trabajamos con procedimientos almacenados debemos recordar que cada procedimiento almacenado es una unidad. Cuando se ejecuta lo hace de manera independiente de quien lo llama. Sin embargo si tenemos un ROLLBACK TRAN dentro de un procedimiento almacenado cancelaremos la transacción en curso, pero si hay una transacción externa al procedimiento en el que estamos trabajando se cancelará esa transacción externa.
Con esto no quiero decir que no se pueda usar, simplemente que hay que tener muy claras las 4 normas sobre las sentencias BEGIN, ROLLBACK y COMMIT que comentamos al principio de este artículo.
Veamos como se comporta una transacción en un procedimiento almacenado llamado desde una transacción.
En principio parece que si ejecutamos el procedimiento ‘Inserta1’ el resultado sería:
Pero lo que obtenemos es:
Si analizamos estos mensajes vemos que se inserta la primera fila, se salta al segundo procedimiento almacenado y se inserta la segunda fila. Se ejecuta el ‘ROLLBACK TRAN –Dos’ del segundo procedimiento almacenado y se deshacen las dos inserciones porque este ROLLBACK cancela la transacción exterior, la del primer procedimiento almacenado.
A continuación se termina el segundo procedimiento almacenado y como este procedimiento tiene un ‘BEGIN TRAN –Dos’ y no tiene un COMMIT o un ROLLBACK (recordemos que el ‘ROLLBACK TRAN –Dos’ termina el ‘BEGIN TRAN –Uno’) se produce un error y nos avisa que el procedimiento almacenado termina con una transacción pendiente.
Al volver al procedimiento almacenado externo se ejecuta el INSERT que inserta la tercera fila y a continuación el ‘COMMIT TRAN –-Uno’. Aquí aparece otro error puesto que este ‘COMMIT TRAN –Uno’ estaba ahí para finalizar una transacción que ya ha sido cancelada anteriormente.
El modo correcto
Para que nuestras transacciones se comporten como se espera dentro de un procedimiento almacenado podemos recurrir al SAVE TRAN.
Veamos como:
Ahora el ‘ROLLBACK TRAN guardado’ del segundo procedimiento almacenado deshace la transacción sólo hasta el punto guardado. Además este ROLLBACK no decrementa el @@TRANCOUNT ni afecta a las transacciones en curso.
El resultado obtenido al ejecutar este procedimiento almacenado es:
Una vez vistos estos ejemplos queda claro que no hay problema en utilizar transacciones dentro de procedimientos almacenados siempre que tengamos en cuenta el comportamiento del ROLLBACK TRAN y que utilicemos el SAVE TRAN de manera adecuada.
Recordemos como funcionan las transacciones. Tenemos 4 sentencias que son:
• BEGIN TRAN: Comienza una transacción y aumenta en 1 @@TRANCOUNT
• COMMIT TRAN: Reduce en 1 @@TRANCOUNT, y si @@TRANCOUNT llega a 0 guarda la transacción
• ROLLBACK TRAN: Deshace la transacción actual, o si estamos en transacciones anidadas deshace la más externa y todas las internas. Además pone @@TRANCOUNT a 0
• SAVE TRAN: Guarda un punto (con nombre) al que podemos volver con un ROLLBACK TRAN si es que estamos en transacciones anidadas y no queremos deshacer todo hasta la más externa.
Un par de ejemplos dejarán las cosas más claras:
BEGIN TRAN
-- Primer BEGIN TRAN y ahora @@TRANCOUNT = 1
BEGIN TRAN
-- Ahora @@TRANCOUNT = 2
COMMIT TRAN
-- Volvemos a @@TRANCOUNT = 1
-- Pero no se guarda nada ni se hacen efectivos los posibles cambios
COMMIT TRAN
-- Por fin @@TRANCOUNT = 0
-- Si hubiera cambios pendientes se llevan a la base de datos
-- Y volvemos a un estado normal con la transacción acabada
Uso del commit
BEGIN TRAN
-- Primer BEGIN TRAN y @@TRANCOUNT = 1
BEGIN TRAN
-- Ahora @@TRANCOUNT = 2
COMMIT TRAN
-- Como antes @@TRANCOUNT = 1
--Y como antes nada se guarda
ROLLBACK TRAN
-- Se cancela TODA la transacción. Recordemos que el COMMIT
-- de antes no guardo nada, solo redujo @@TRANCOUNT
-- Ahora @@TRANCOUNT = 0
COMMIT TRAN
-- No vale para nada porque @@TRANCOUNT es 0 por el efecto del ROLLBACK
Uso del rollback
En cuanto al SAVE TRAN podemos recordarlo con el siguiente ejemplo:
CREATE TABLE Tabla1 (Columna1 varchar(50))
GO
BEGIN TRAN
INSERT INTO Tabla1 VALUES (‘Primer valor’)
SAVE TRAN Punto1
INSERT INTO Tabla1 VALUES (‘Segundo valor’)
ROLLBACK TRAN Punto1
INSERT INTO Tabla1 VALUES (‘Tercer valor’)
COMMIT TRAN
SELECT * FROM Tabla1
Columna1
--------------------------------------------------
Primer valor
Tercer valor
(2 filas afectadas)
Un ROLLBACK a un SAVE TRAN no deshace la transacción en curso ni modifica @@TRANCOUNT, simplemente cancela lo ocurrido desde el ‘SAVE TRAN nombre‘ hasta su ‘ROLLBACK TRAN nombre’
Transacciones y procedimientos almacenados…
Cuando trabajamos con procedimientos almacenados debemos recordar que cada procedimiento almacenado es una unidad. Cuando se ejecuta lo hace de manera independiente de quien lo llama. Sin embargo si tenemos un ROLLBACK TRAN dentro de un procedimiento almacenado cancelaremos la transacción en curso, pero si hay una transacción externa al procedimiento en el que estamos trabajando se cancelará esa transacción externa.
Con esto no quiero decir que no se pueda usar, simplemente que hay que tener muy claras las 4 normas sobre las sentencias BEGIN, ROLLBACK y COMMIT que comentamos al principio de este artículo.
Veamos como se comporta una transacción en un procedimiento almacenado llamado desde una transacción.
CREATE PROCEDURE Inserta2
AS
BEGIN TRAN --Uno
INSERT INTO Tabla1 VALUES ('Valor2')
ROLLBACK TRAN --Uno
GO
CREATE PROCEDURE Inserta1
AS
BEGIN TRAN --Dos
INSERT INTO Tabla1 VALUES ('Valor 1')
EXEC Inserta2
INSERT INTO Tabla1 VALUES ('Valor3')
COMMIT TRAN --Dos
GO
En principio parece que si ejecutamos el procedimiento ‘Inserta1’ el resultado sería:
EXECUTE inserta1
SELECT * FROM tabla1
txt
--------------------------------------------------
Valor1
Valor3
(2 filas afectadas)
Pero lo que obtenemos es:
EXECUTE inserta1
SELECT * FROM tabla1
(1 filas afectadas)
(1 filas afectadas)
Servidor: mensaje 266, nivel 16, estado 2, procedimiento Inserta2, línea 8
El recuento de transacciones después de EXECUTE indica que falta una
instrucción COMMIT o ROLLBACK TRANSACTION. Recuento anterior = 1,
recuento actual = 0.
(1 filas afectadas)
Servidor: mensaje 3902, nivel 16, estado 1, procedimiento Inserta1, línea 8
La petición COMMIT TRANSACTION no tiene la correspondiente BEGIN TRANSACTION.
txt
--------------------------------------------------
Valor3
(1 filas afectadas)
Si analizamos estos mensajes vemos que se inserta la primera fila, se salta al segundo procedimiento almacenado y se inserta la segunda fila. Se ejecuta el ‘ROLLBACK TRAN –Dos’ del segundo procedimiento almacenado y se deshacen las dos inserciones porque este ROLLBACK cancela la transacción exterior, la del primer procedimiento almacenado.
A continuación se termina el segundo procedimiento almacenado y como este procedimiento tiene un ‘BEGIN TRAN –Dos’ y no tiene un COMMIT o un ROLLBACK (recordemos que el ‘ROLLBACK TRAN –Dos’ termina el ‘BEGIN TRAN –Uno’) se produce un error y nos avisa que el procedimiento almacenado termina con una transacción pendiente.
Al volver al procedimiento almacenado externo se ejecuta el INSERT que inserta la tercera fila y a continuación el ‘COMMIT TRAN –-Uno’. Aquí aparece otro error puesto que este ‘COMMIT TRAN –Uno’ estaba ahí para finalizar una transacción que ya ha sido cancelada anteriormente.
El modo correcto
Para que nuestras transacciones se comporten como se espera dentro de un procedimiento almacenado podemos recurrir al SAVE TRAN.
Veamos como:
CREATE PROCEDURE Inserta2
AS
SAVE TRAN Guardado
INSERT INTO Tabla1 VALUES ('Valor2')
ROLLBACK TRAN Guardado
GO
CREATE PROCEDURE Inserta1
AS
BEGIN TRAN
INSERT INTO Tabla1 VALUES ('Valor 1')
EXEC Inserta2
INSERT INTO Tabla1 VALUES ('Valor 3')
COMMIT TRAN
GO
Ahora el ‘ROLLBACK TRAN guardado’ del segundo procedimiento almacenado deshace la transacción sólo hasta el punto guardado. Además este ROLLBACK no decrementa el @@TRANCOUNT ni afecta a las transacciones en curso.
El resultado obtenido al ejecutar este procedimiento almacenado es:
EXECUTE inserta1
SELECT * FROM tabla1
(1 filas afectadas)
(1 filas afectadas)
(1 filas afectadas)
txt
--------------------------------------------------
Valor 1
Valor 3
(2 filas afectadas)
Una vez vistos estos ejemplos queda claro que no hay problema en utilizar transacciones dentro de procedimientos almacenados siempre que tengamos en cuenta el comportamiento del ROLLBACK TRAN y que utilicemos el SAVE TRAN de manera adecuada.
Suscribirse a:
Entradas (Atom)