Lexapro And Birth Defects, Lexapro Celexa Wellbutrin

Últimamente me ha dado por ponerme un poco al día en C#, y es que la noticia de que Micrososft haya liberado el framework ASP.NET MVC bajo licencia MS-PL, es decir, como software libre, me ha motivado bastante para ponerme con esta tecnología. Pero antes de entrar al trapo con ASP.NET MVC, he querido echar un vistazo a las alternativas de BBDD de las que disponía para programar con Mono en Linux.

Después de mirar los diferentes SGBD de que disponía decidí quedarme con MySQL, porque que estoy muy familiarizado ya que en PHP casi siempre me ha tocado usar esta base de datos. Postgre SQL me ha parecido me ha parecido una alternativa muy buena a MySQL, sobre todo después de la incertidumbre que se me ha generado después de la compra de Sun por parte de Oracle.

Para conectar con MySQL desde .NET lo primero que hay que hacer es bajarse el conector desde el sitio web de MySQL. Yo he bajado la versión 5.2, aunque ya van por la 6.0. Bajaros el que pone “Windows Binaries, no installer ”, estos son los binarios compilados para Windows del conector,es decir, el ensamblado, o dll, como quieras llamarlo.

No te asustes, que aunque estén compilados para Windows, Mono es compatible con estos binarios.

Una vez descargado el fichero lo descomprimes y lo que nos interesa es el directorio “bin”, donde se encuentra la dll del conector.

Ahora hay que instalar el ensamblado en la caché de ensamblados global de Mono, esto se hace con la utilidad gacutil, para ello usamos el comando:

sudo gacutil -i MySql.Data.dll

Se supone que se ha descomprimido el paquete del conector y se tiene acceso al directorio bin, donde se encuentra el fichero MySql.Data.dll.

Ahora ya se encuentra instalado el ensamblado en el entorno Mono.

Lo siguiente es abrir monodevelop y crear un nuevo proyecto, yo lo he creado de consola. Hace poco escribí un post donde puse un vídeo con el proceso de instalación de monodevelop en Suse Linux 11.1, por si te lías con la instalación.

Crear un proyecto de consola en Monodevelop

Ahora pinchamos con el botón derecho del ratón sobre el directorio Referencias->Editar Referencias.

Agregar referencia a System.Data

Hay que agregar el ensamblado del conector que acabamos de descargar y una referencia a la librería System.Data de .NET para trabajar con bases de datos.

Agregar el ensamblado del conector MySQL en Monodevelop

Ahora ya podemos comenzar a programar usando el conector de MySQL desde Mono. Yo he creado una base de datos llamada “NET” y he creado una tabla dentro de ella, a continuación pongo el código SQL necesario para crear la tabla.

CREATE DATABASE `NET` ;
CREATE TABLE `NET`.`miTabla` (
`id` INT NOT NULL AUTO_INCREMENT ,
`cuerpo` VARCHAR( 300 ) NOT NULL ,
PRIMARY KEY ( `id` )
) ENGINE = MYISAM ;
INSERT INTO `NET`.`miTabla` (
`id` ,
`cuerpo`
)
VALUES (
NULL , 'datos de prueba, 1'
), (
NULL , 'más datos de prueba, 2'
);

El ejemplo que he creado es muy simple, uso un Reader para obtener los datos de la tabla, lo recorro y lo imprimo por la pantalla.

A continuación pongo el código.

using System;
using System.Data;
using MySql.Data.MySqlClient;
namespace pruebaMySQL
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			string connectionString = "Server=localhost;Database=NET;User ID=root;Password=;Pooling=false;";
  			MySqlConnection conn = new MySqlConnection(connectionString);
 
        	string query = "SELECT id,cuerpo FROM miTabla";
 
			conn.Open();
 
           MySqlCommand myCommand = new MySqlCommand(query, conn);
           MySqlDataReader myReader = myCommand.ExecuteReader();
 
           while (myReader.Read())
           {
			Console.Write("El ID es: " + myReader["id"].ToString());
			Console.WriteLine("  El cuerpo es: " + myReader["cuerpo"].ToString());
 
           }
           myReader.Close();
           myCommand.Dispose();
           conn.Close();
		}
	}
}

Se han añadido los espacios de nombres a : System.Data y MySql.Data.MySqlClient, necesarios para trabajar con el conector de MySQL sin tener que estar poniendo siempre la ruta completa de cada objeto.

En la connectionString se ha de poner la cadena con este formato siempre a piñón fijo, sustituyendo los valores dependiendo del servidor y base de datos que quieras consultar. En el objeto myReader se almacena el resultado de la consulta, que se ejecuta con el método ExecuteReader del objeto mySqlCommand, que a su vez necesita una conexión con el servidor (objeto mySqlConnection) y una string que contenga la consulta SQL que se desea realizar (query). Como se puede comprobar es muy sencillo.

Es importante cerrar el reader con el método Close, ejecutar el método Dispose del objeto myCommand para liberar memoria, y cerrar la conexión (objeto conn) con el método Close, para cerrar el socket con el servidor de MySQL y colapsarlo.

Por último, pulsamos F5 y …

Ejecución del programa

Return to the Mobile Edition.

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.

Return to the Mobile Edition.

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

CREATE TRIGGER <nombre>
    {BEFORE|AFTER}
    {INSERT|UPDATE|DELETE}
    ON
<tablename>
    FOR EACH ROW
    BEGIN
    <sentenciasSQL>
    END;

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:

GRANT CREATE TRIGGER ON nombreTabla TO Usuario

Vamos a ver un ejemplo sencillo:

Creamos la tabla miTabla

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

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.

delimiter //
CREATE TRIGGER miTabla_bu before UPDATE
ON miTabla
FOR each row
begin
    SET @nombreViejo = OLD.nombre;
    SET @nombreNuevo = NEW.nombre;
end//

Vamos a ver otro tigger :

CREATE TRIGGER miTabla_bi
before INSERT ON miTabla
FOR each row
begin
    SET @x = 'Trigger activado';
    SET NEW.nombre = ‘Valor introducido desde el TRIGGER’;
end//

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

CREATE TABLE controlMiTabla
(
   id int NOT NULL AUTO_INCREMENT,
   id_registro int,
   anterior_nombre varchar(50),
   nuevo_nombre varchar(50),
   usuario varchar(40),
   modificado datetime,
   PRIMARY KEY(id)
) ENGINE = InnoDB;

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:

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

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.

Return to the Mobile Edition.

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:

DELIMITER //
 
CREATE FUCNTION holaMundo() RETURNS VARCHAR(20)
BEGIN
    RETURN ‘HolaMundo’;
END
//

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

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 :

DROP FUNCTION IF EXISTS holaMundo

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.

DELIMITER //
 
CREATE FUNCTION holaMundo() RETURNS VARCHAR(30)
BEGIN
  DECLARE salida VARCHAR(30) DEFAULT 'Hola mundo';
;
  SET salida = ‘Hola mundo con VARIABLES’;
  RETURN salida;
END
//

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:

DROP FUNCTION IF EXISTS holaMundo
 
CREATE FUNCTION holaMundo(entrada VARCHAR(20)) RETURNS VARCHAR(20)
BEGIN
  DECLARE salida VARCHAR(20);
  SET salida = entrada;
  RETURN salida;
END

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:

CREATE FUNCTION divide(dividendo int,divisor int) returns int
begin
    declare aux int;
    declare contador int;
    declare resto int;
    SET contador = 0;
    SET aux = 0;
    while (aux + divisor) <= dividendo do
        SET aux = aux + divisor ;
        SET contador = contador + 1;
    end while;
    SET resto = dividendo - aux ;
RETURN contador;
end;
//

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

SELECT divide(20,2)

Lo que devolvería 10.

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

Return to the Mobile Edition.

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:

    CREATE TABLE t2(
    s1 int,
    PRIMARY KEY (s1))engine=innodb;

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

    CREATE TABLE t3 (
    s1 int, KEY(s1),
    FOREIGN KEY (s1) REFERENCES t2 (s1))engine=innodB;

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:

INSERT INTO t3 VALUES(5);

Error:

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…

 CREATE TABLE error_log(error_message varchar(80));

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

delimiter //
CREATE procedure procedimientoConHandler(parametro1 int)
begin
    declare exit handler FOR 1452
    begin
        INSERT INTO error_log VALUES (concat('Time: ',current_date,'. Error de clave ajena para el valor= ', parametro1));
    end;
    INSERT INTO t3 VALUES (parametro1);
    .
    .
    .
end;
//

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

Return to the Mobile Edition.

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 :

        declare miVar int;

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 :

        SET miVar = 56 ;

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

delimiter //
CREATE procedure miProc(IN p1 int)     /* Parámetro de entrada */
    begin
        declare miVar int;        /* se declara variable local */
        SET miVar = p1 +1 ;        /* se establece la variable */
        IF miVar = 12 then
            INSERT INTO lista VALUES(55555);
        else
INSERT INTO lista VALUES(7665);
        end IF;
    end;
//

SWITCH

delimiter //
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;
//

Creo que no hacen falta explicaciones.

COMPARACIÓN DE CADENAS

delimiter //
CREATE procedure compara(IN cadena varchar(25), IN cadena2 varchar(25))
    begin
        IF strcmp(cadena, cadena2) = 0 then
            SELECT "son iguales!";
        else
            SELECT "son diferentes!!";
        end IF;
    end;
//

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

USO DE WHILE

delimiter //
CREATE procedure p14()
    begin
        declare v int;
        SET v = 0;
        while v < 5 do
            INSERT INTO lista VALUES (v);
            SET v = v +1 ;
        end while;
    end;
//

Un while de toda la vida.

USO DEL REPEAT

delimiter //
CREATE procedure p15()
    begin
        declare v int;
        SET v = 20;
        repeat
            INSERT INTO lista VALUES(v);
            SET v = v + 1;
        until v >= 1
        end repeat;
    end;
//

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

LOOP LABEL

delimiter //
CREATE procedure p16()
    begin
        declare v int;
        SET v = 0;
        loop_label : loop
            INSERT INTO lista VALUES (v);
            SET v = v + 1;
            IF v >= 5 then
            leave loop_label;
            end IF;
        end loop;
    end;
//

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.

Return to the Mobile Edition.

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.

Lee el resto de esta entrada »

Return to the Mobile Edition.