Con este tutorial vamos a aprender a conectarnos a un dabatase de manera sencilla y rápida, vamos a crear nuestro propio módulo para poder automatizar nuestro proceso.
Este tutorial nada más va a cubrir lo más básico para la conexión a un database a través de perl, así que no voy a explicar nada del código que lleva cada sistema de database.
Los módulos
Antes de empezar es necesario que cheques si tienes los módulos necesarios.
El mejor módulo en mi opinión y en la de muchos es la de DBI, un módulo creado en lenguaje C++ por lo que está compilado. La gran ventaja que tienes este módulo, a parte de estar muy bien hecho por lo que no tiene bugs, es que es compatible con casi todos los sistemas de database, por lo que si usas este módulo para conectarte a tu database, podrás usar tu código con los más importantes sistemas de database.
Ahora, parte del módulo DBI vamos a necesitar otro módulo, nada más que este depende de qué database uses, si por ejemplo usas MySQL entonces el otro módulo sería DBD::mysql, si usaras postgres entonces sería DBD::Pg y así con los otros database.
Todos los módulos disponibles de DBD son:
- DBD::Sybase
- DBD::pNET
- DBD::mSQL
- DBD::mysql
- DBD::Unify
- DBD::Oracle
- DBD::Pg
- DBD::Ingres
- DBD::Illustra
- DBD::CSV
- DBD::Sqlflex
- DBD::Solid
- DBD::DBMaker
- DBD::Informix
- DBD::Ovrimos
- DBD::Teradata
- DBD::Multiplex
- DBD::InterBase
- DBD::XBase
- DBD::ODBC
- DBD::Adabas
- y muchos más
Como ves existen módulos de DBD para casi cualquier sistema de database que hay, sólo es cuestión de que instales el que quieres usar.
En caso de que te falte el módulo necesario entra a http://search.cpan.org
Nuestro módulo
Ahora si ya que tenemos todo listo, vamos a crear nuestro módulo para automatizar lo que sería el código necesario para abrir una conexión a nuestro database.
Vamos a ver el código completo:
#!/usr/bin/perl -w
package ConectarDB;
use strict;
use DBI;
# variables a editar
my $db_user = "usuario_database";
my $db_pass = "pwd_database";
my $host_name = "host_database";
my $db_name = "nombre_database";
# vars
my $q_string = "DBI:mysql:host=$host_name;database=$db_name";
sub connect{
return (DBI->connect ($q_string, $db_user, $db_pass,
{PrintError => 0, RaiseError => 1}));
}
1;
Muy bien veamos con cuidado cada parte, la primera línea, como siempre es el path a nuestro intérprete de perl seguido de inmediato por una línea que dice package, esto es muy importante por que si quieres cambiar el nombre de tu módulo debes de cambiarlo en esta línea, pues esta línea debe de tener el nombre exacto del archivo. Si por ejemplo decides que vas a guardar tu módulo como MiModulo.pm entonces esta linea debería de verse algo así:
package "MiModulo";
Es muy importante que cuides las mayúsculas de lo contrario no funcionaría.
Luego iniciamos el módulo DBI que es para la interface al database y el pragma strict, luego siguen las variables que debemos de editar dependiendo nuestro datos para accesar al database.
Ahora, hay una parte muy importante que debemos de checar bien que es la línea donde iniciamos la variable $q_string:
my $q_string = "DBI:mysql:host=$host_name;database=$db_name";
Checa que en este caso use "mysql" después de "DBI", esto lo debes de cambiar dependiendo del módulo DBD que uses, recuerda la lista que agregue anteriormente, es muy importante que pongas exactamante en nombre del DBD que estas usando de otra manera no va a funcionar. Digamos que usas el sistema de Oracle entonces sería "DBI:oracle".
La última línea que tiene el 1, nunca lo debes de quitar pues regresa un valor verdadero, necesario para que perl sepa que el módulo existe y funciona.
Ahora ya tenemos nuestro módulo vamos a pasar, ahora sí, a ver las funciones principales y cómo debemos de usar nuestro módulo.
Ejecutando
Muy bien, recuerda que primero debemos de llamar a nuestro módulo poniendo en el principio de tu script la línea:
use ConectarDB;
Ya que tenemos cargado nuestro módulo vamos a ejecutar algun query en nuestro database, esto lo haríamos de manera muy sencilla:
1: my $campo = "perl";
2: my($dbh,$sth);
3: $dbh = ConectarDB->connect();
4: $sth = $dbh->prepare('INSERT INTO tabla campo = ?') or die("Couldn't prepare statement: " . $dbh->errstr);
5: $sth->execute($campo) or die("Couldn't execute statement: " . $sth->errstr);
6: $sth->finish;
7: $dbh->disconnect;
Muy bien, veamos línea por línea, en la línea 1 iniciamos una variable con el valor de "perl", en la línea dos iniciamos dos variables que vamos a usar más adelante.
En la línea 3 asignamos a la variable $dbh todo el código necesario para conectarse al database a través de la función que hicimos en nuestro módulo.
En la línea 4 preparamos un query, en este caso lo hice como si estuviera ejecutando uno en MySQL, sabemos que estamos preparandolo porque llamamos la función "prepare()". Nota como dentro del query hay un signo de "?", este símbolo servirá como un contenedor, al cual le vamos a asignar un valor en la línea siguiente.
En la línea 5 ejecutamos ya el query que preparamos en la línea anterior, pero nota como enviamos nuestra variable $campo. Lo que va a hacer perl es tomar esa variable y ponerla en el contenedor "?" que pusimos anteriormente.
En la línea 6 terminamos el query y en la línea 7 terminamos la conexión al database.
Si quisieramos enviar más variables en nuestro query podríamos poner más contenedores "?", que serían sustituidos por las variables en el orden que las enviemos.
Recibir datos
Ya vimos como ejecutar un query, pero qué pasaría si quisieramos recibir datos, digamos que llamamos todas las celdas de nuestro database, o que pedimos un valor.
Si ejecutamos un query y sólo vamos a recibir un valor entonces podrías hacer algo así:
1: my($dbh,$sth);
2: $dbh = ConectarDB->connect();
3: $sth = $dbh->prepare('SELECT fecha FROM table WHERE nombre = ? AND apellido = ?') or die("Couldn't prepare statement: " . $dbh->errstr);
4: $sth->execute("Uriel","Lizama") or die("Couldn't execute statement: " . $sth->errstr);
5: my $fecha = $sth->fetchrow_array();
6: $sth->finish;
7: $dbh->disconnect;
En este código vemos como en la línea 3 puse 2 contenedores en mi query y por consiguiente en la línea 4 estoy enviando 2 variables, en el orden que quiero que se metan primer nombre y luego apellido.
La linea extra que pusimos en comparación a la de hace rato fue la línea 5 que inicializa la variable "$fecha" con el valor del campo que se regresa.
Si en otro caso quisieramos recibir dos valores podríamos hacer algo así:
1: my($dbh,$sth);
2: $dbh = ConectarDB->connect();
3: $sth = $dbh->prepare('SELECT fecha,id FROM table WHERE nombre = ? AND apellido = ?') or die("Couldn't prepare statement: " . $dbh->errstr);
4: $sth->execute("Uriel","Lizama") or die("Couldn't execute statement: " . $sth->errstr);
5: my ($fecha,$id) = $sth->fetchrow_array();
6: $sth->finish;
7: $dbh->disconnect;
Nota como en la línea 5 incluí otra variable sin problema, perl va a saber que el primer valor va para nuestra primera variable y el segundo para la segunda.
Pero digamos que son muchos valores los que recibimos y quisieramos meterlos en un array, eso sería muy fácil cambiando una línea:
1: my($dbh,$sth);
2: $dbh = ConectarDB->connect();
3: $sth = $dbh->prepare('SELECT fecha,id,nombre,apellido,edad,hobbies FROM table WHERE nombre = ? AND apellido = ?') or die("Couldn't prepare statement: " . $dbh->errstr);
4: $sth->execute("Uriel","Lizama") or die("Couldn't execute statement: " . $sth->errstr);
5: my @datos_personales = $sth->fetchrow_array();
6: $sth->finish;
7: $dbh->disconnect;
Ve cómo en la línea 4 en vez de asignar los valores a unas variables lo hacemos a un array.
Pero que pasaría si quiesieramos leer varias celdas y no sólo 1, entonces tendríamos que cambiar un poco más nuestro código:
1: my($dbh,$sth,@data);
2: $dbh = ConectarDB->connect();
3: $sth = $dbh->prepare('SELECT * FROM tabla WHERE edad = ?') or die("Couldn't prepare statement: " . $dbh->errstr);
4: $sth->execute("19") or die("Couldn't execute statement: " . $sth->errstr);
5: while(@data = $sth->fetchrow_array()){
6: }
7: $sth->finish;
8: $dbh->disconnect;
Ve que en la línea 5 pusimos el while, lo que nos dice es que mientras haya celdas que leer asigne todos los campos de la celda al array @data.
Como en el ejemplo anterior podemos usar en vez del array una variable o varias, dependiendo de tus necesidades.
Notas Finales
Ya vimos lo más básico de ejecutar y leer datos en nuestro database, sólo recuerda siempre desconectar tu database con la linea:
$dbh->disconnect;
Si quieres aprender más acerca de cómo usar el módulo DBI te recomiendo que leas su documentación en:
http://search.cpan.org/~timb/DBI-1.40/DBI.pm
