Modulo3 - Conectar PHP Con Base de Datos

rea Tecnolgica de Educacin Virtual UTN FRC SEU
PHP, MySQL y E-Commerce Conectar PHP con base de datos

Autor: Ing. Oscar R. Espeche

1

UNIVERSIDAD TECNOLGICA NACIONAL
Facultad Regional Crdoba

Secretaria de Extensin Universitaria

rea Tecnolgica de Educacin Virtual

Coordinador General de Educacin Virtual: Magster Leandro D.
Torres

Curso:
PHP, MySQL y E-Commerce EV
05400/11
Mdulo:
Conectar PHP con base de datos

Tutor: Ing. Oscar R. Espeche
Mdulo 3-Conectar PHP con Base de Datos

2
3-1 Estructura de MySQL

3-2 Tipos de Datos de Mysql

3-3 Trabajar con el cliente mysql

3-4 Funciones PHP de acceso a MySQL

3-5 Trabajar con PHP y MySQL

3-6 Administracin de MySQL en Windows

3-7 Interconectar con otras bases de datos

3-8 Copias de seguridad en MySQL

3-9 Subir una aplicacin PHP al servidor

3
3-1 Estructura de MySQL

PHP tiene posibilidades de conexin con varias base de datos. En esta primera parte
veremos las caractersticas de conexin con la base MySQL.

Teniendo en cuenta la importancia de MySQL en el manejo de datos en un sitio Web,
veremos con mayor detalle las caractersticas de este administrador de base de datos.

Suponemos que ya tenemos instalado el servidor mysqld y el cliente mysql. A continuacin
nos ocuparemos en detalle de los trabajos que podemos hacer desde el cliente mysql con los
datos del servidor.

En esta seccin vamos a hacer un pequeo recorrido por MySQL, por su estructura y forma
de trabajar. Para ello suponemos que ya hemos conseguido (por fin...) instalar MySQL en
nuestra mquina. Lo primero que debemos hacer es asegurarnos que MySQL est activo en
nuestro servidor.

Todo el sistema de permisos de MySQL lo guarda en una base de datos llamada mysql, la
cul se componen de cinco tablas: host, user, db, tables_priv, colums_priv.

La tabla user contiene informacin sobre los usuarios, desde que mquinas pueden acceder
a nuestro servidor MySQL, su clave y de sus diferentes permisos.

La tabla host nos informa sobre que mquinas podrn acceder a nuestro sistema, as como
a las bases de datos que tendrn acceso y sus diferentes permisos.

Finalmente, las tablas db, tables_priv, columns_priv nos proveen de un control individual
de las bases de datos, tablas y columnas (campos).

Tabla user

CAMPO TIPO POR DEFECTO
Host char(60)
User char(16)
Password char(16)
Select_priv enum('N','Y') N
Insert_priv enum('N','Y') N
Update_priv enum('N','Y') N
Delete_priv enum('N','Y') N
Create_priv enum('N','Y') N
Drop_priv enum('N','Y') N
Reload_priv enum('N','Y') N
Shutdown_priv enum('N','Y') N
Process_priv enum('N','Y') N
File_priv enum('N','Y') N
Grant_priv enum('N','Y') N

4
References_priv enum('N','Y') N
Index_priv enum('N','Y') N
Alter_priv enum('N','Y') N

El trmino priv hace referencia a los privilegios de acceso.
Tabla host
Host char(60)
Db char(32)
Grant_priv enum('N','Y') N
Tabla db
Host char(60)
Db char(32)
User char(16)

He aqu una breve descripcin de los diferentes permisos:
Select_priv: Permite utilizar la sentencia SELECT
Insert_priv: Permite utilizar la sentencia INSERT
Update_priv: Permite utilizar la sentencia UPDATE
Delete_priv: Permite utilizar la sentencia DELETE
Create_priv: Permite utilizar la sentencia CREATE o crear bases de datos
Drop_priv: Permite utilizar la sentencia DROP o eliminar bases de datos

5
Reload_priv: Permite recargar el sistema mediante mysqladmin reload
Shutdown_priv: Permite parar el servidor mediante mysqladmin shutdown
Process_priv: Permite manejar procesos del servidor
File_priv: Permite leer y escribir archivos usando comando como SELECT INTO
OUTFILE y LOAD DATA INFILE
Grant_priv: Permite otorgar permisos a otros usuarios
Index_priv: Permite crear o borrar ndices
Alter_priv: Permite utilizar la sentencia ALTER TABLE
Si dejamos en blanco los campos user, host o db, haremos referencia a cualquier usario,
servidor o base de datos. Conseguiremos el mismo efecto poniendo el smbolo % en el
campo.

Administracin bsica de MySQL

Si nos conectamos como al administrador root, haciendo uso del comando cliente mysql
denominado precisamente, mysql podemos realizar tareas administrativas. Veremos
algunas tareas bsicas como crear base de datos y usuarios. Nos conectamos de la siguiente
manera:

C:\>AppServ\mysql\bin\mysql -u root -p
Enter password:**********
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 2 to server version: 4.0.24-nt

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Crear base de datos: Mediante el comando mysql ingresamos al entorno del cliente mysql
y desde all ejecutamos los comandos.

mysql> CREATE DATABASE alumno1;

Para poder realizar tareas con dicha base es necesario realizar el siguiente comando para
definir a dicha base como la base por defecto.

mysql> USE alumno1

Luego vemos las tablas de dicha base.

mysql> SHOW TABLES;
Empty set (0.00 sec)

Luego creamos las tabla como en el siguiente ejemplo.


6
mysql> CREATE TABLE mascotas(
-> nombre VARCHAR(20), propietario VARCHAR(20),
-> especie VARCHAR(20), sexo CHAR(1), nacimiento DATE,
-> fallecimento DATE);

Revisamos de nuevo la listas de las tablas de la base.

mysql> SHOW TABLES;
+----------------------+
| Tables in alumno1 |
+----------------------+
|mascotas |
+----------------------+

Vemos la estructura de la tabla.

mysql> describe mascotas;
+---------------+----------------+------+-----+---------+----- -+
| Field | Type | Null | Key | Default | Extra|
+---------------+----------------+------+-----+---------+-------+
| nombre | varchar(20) | YES | | NULL | |
| propietario | varchar(20) | YES | | NULL | |
| especie | varchar(20) | YES | | NULL | |
| sexo | char(1) | YES | | NULL | |
| nacimiento | date | YES | | NULL | |
| fallecimiento | date | YES | | NULL | |
+---------------+---------------+------+------+---------+-------+

6 rows in set (0.01 sec)

Crear cuenta de usuarios: Mediante el comando grant podemos crear cuentas de
usuarios y otorgar privilegios de acceso. Veamos los siguientes ejemplos.

mysql> GRANT USAGE ON *.* TO 'alumno1'@'localhost';

En este ejemplo creamos la cuenta alumno1 con acceso a MySQL desde localhost, pero sin
acceso a las bases de datos.

Para darle acceso a una base como alumno1 con todos los derechos, podemos usar el
siguiente comando.

mysql> GRANT ALL PRIVILEGES ON alumno1.* TO 'alumno1'@'localhost'
-> IDENTIFIED BY 'alumno' WITH GRANT OPTION;

En este caso le otorgamos a la cuenta alumno1 ( si no existe dicha cuenta, la crea) todos los
privilegios sobre la base de datos alumno1, pero para que acceda solo del host local.
Tambin le definimos la clave alumno a dicha cuenta. Este comando encripta la clave y la
almacena.


7
Todos estos datos son almacenados en la tabla user y db de la base de datos mysql.

Para ms datos sobre tareas administrativas se deber consultar al manual de MySQL.

8
3-2 Tipos de Datos de Mysql

Despus de la fase de diseo de una base de datos, y una vez se ha realizado el paso a
tablas del mismo, en necesario crear las tablas correspondientes dentro de la base de datos.
Para cada campo de cada una de las tablas, es necesario determinar el tipo de datos que
contiene, para de esa forma ajustar el diseo de la base de datos, y conseguir un
almacenamiento ptimo con la menor utilizacin de espacio. El presente artculo describe
cada uno de los tipos de datos que puede tener un campo en Mysql, para la versin 4.xx.xx.

Los tipos de datos que puede haber en un campo, se pueden agrupar en tres grandes
grupos:

1. Tipos numricos
2. Tipos de Fecha
3. Tipos de Cadena

Tipos numricos:

Existen tipos de datos numricos, que se pueden dividir en dos grandes grupos, los que
estn en coma flotante (con decimales) y los que no.

TinyInt: es un nmero entero con o sin signo. Con signo el rango de valores vlidos va
desde -128 a 127. Sin signo, el rango de valores es de 0 a 255

Bit Bool: un nmero entero que puede ser 0 1

SmallInt: nmero entero con o sin signo. Con signo el rango de valores va desde -32768 a
32767. Sin signo, el rango de valores es de 0 a 65535.

MediumInt: nmero entero con o sin signo. Con signo el rango de valores va desde -
8.388.608 a 8.388.607. Sin signo el rango va desde 0 a16777215.

Integer, Int: nmero entero con o sin signo. Con signo el rango de valores va desde -
2147483648 a 2147483647. Sin signo el rango va desde 0 a 429.4967.295

BigInt: nmero entero con o sin signo. Con signo el rango de valores va desde -
9.223.372.036.854.775.808 a 9.223.372.036.854.775.807. Sin signo el rango va desde 0 a
18.446.744.073.709.551.615.

Float: nmero pequeo en coma flotante de precisin simple. Los valores vlidos van desde
-3.402823466E+38 a -1.175494351E-38, 0 y desde 1.175494351E-38 a 3.402823466E+38.

xReal, Double: nmero en coma flotante de precisin doble. Los valores permitidos van
desde -1.7976931348623157E+308 a -2.2250738585072014E-308, 0 y desde
2.2250738585072014E-308 a 1.7976931348623157E+308


9
Decimal, Dec, Numeric: Nmero en coma flotante desempaquetado. El nmero se
almacena como una cadena

Tipo de
Campo
Tamao de
Almacenamiento
TINYINT 1 byte
SMALLINT 2 bytes
MEDIUMINT 3 bytes
INT 4 bytes
INTEGER 4 bytes
BIGINT 8 bytes
FLOAT(X) 4 8 bytes
FLOAT 4 bytes
DOUBLE 8 bytes
DOUBLE
PRECISION
8 bytes
REAL 8 bytes

Tipos fecha:

A la hora de almacenar fechas, hay que tener en cuenta que Mysql no comprueba de una
manera estricta si una fecha es vlida o no. Simplemente comprueba que el mes esta
comprendido entre 0 y 12 y que el da esta comprendido entre 0 y 31.

Date: tipo fecha, almacena una fecha. El rango de valores va desde el 1 de enero del 1001
al 31 de diciembre de 9999. El formato de almacenamiento es de ao-mes-dia

DateTime: Combinacin de fecha y hora. El rango de valores va desde el 1 de enero del
1001 a las 0 horas, 0 minutos y 0 segundos al 31 de diciembre del 9999 a las 23 horas, 59
minutos y 59 segundos. El formato de almacenamiento es de ao-mes-dia
horas:minutos:segundos

TimeStamp: Combinacin de fecha y hora. El rango va desde el 1 de enero de 1970 al ao
2037. El formato de almacenamiento depende del tamao del campo:

Tamao Formato
14
AoMesDiaHoraMinutoSegundo
aaaammddhhmmss
12
AoMesDiaHoraMinutoSegundo
aammddhhmmss
8 oMesDia aaaammdd
6 AoMesDia aammdd
4 AoMes aamm
2 Ao aa

10

Time: almacena una hora. El rango de horas va desde -838 horas, 59 minutos y 59
segundos a 838, 59 minutos y 59 segundos. El formato de almacenamiento es de
'HH:MM:SS'

Year: almacena un ao. El rango de valores permitidos va desde el ao 1901 al ao 2155. El
campo puede tener tamao dos o tamao 4 dependiendo de si queremos almacenar el ao
con dos o cuatro dgitos.

Tipo de
Campo
Tamao de
Almacenamiento
DATE 3 bytes
DATETIME 8 bytes
TIMESTAMP 4 bytes
TIME 3 bytes
YEAR 1 byte

Tipos de cadena:

Char(n): almacena una cadena de longitud fija. La cadena podr contener desde 0 a 255
caracteres.

VarChar(n): almacena una cadena de longitud variable. La cadena podr contener desde 0
a 255 caracteres.

Vemos un ejemplo que muestra la diferencia de almacenamiento entre los tipos Char y
VarChar que son los ms usados comnmente.

Valor CHAR(4)
Almace
namiento
VARCHAR(4)
Almace
namiento
'' '' 4 bytes " 1 byte
'ab' 'ab' 4 bytes 'ab' 3 bytes
'abcd' 'abcd' 4 bytes 'abcd' 5 bytes
'abcdefgh' 'abcd' 4 bytes 'abcd' 5 bytes
Blob y Text: un texto con un mximo de 65535 caracteres.
La diferencia entre un tipo y otro es el tratamiento que reciben a la hora de realizar
ordenamientos y comparaciones. Mientras que el tipo text se ordena sin tener en cuenta las
Maysculas y las minsculas, el tipo BLOB se ordena tenindolas en cuenta.
Los tipos BLOB se utilizan para almacenar datos binarios como pueden ser archivos.

TinyText y TinyBlob: Columna con una longitud mxima de 255 caracteres.
MediumBlob y MediumText: un texto con un mximo de 16.777.215 caracteres.


11
LongBlob y LongText: un texto con un mximo de caracteres 4.294.967.295. Hay que
tener en cuenta que debido a los protocolos de comunicacin los paquetes pueden tener un
mximo de 16 Mb.

Enum: campo que puede tener un valor permitido de una lista que se especifica. El tipo
Enum acepta hasta 65535 valores distintos. Se almacena un nmero que es un ndice de la
lista.

Set: un campo que puede contener ninguno, uno varios valores de una lista. La lista
puede tener un mximo de 64 valores. Se almacena un nmero que es un ndice de la lista
pero con un formato diferente al anterior.

Tipo de campo Tamao de Almacenamiento
CHAR(n) n bytes
VARCHAR(n) n +1 bytes
TINYBLOB, TINYTEXT Longitud+1 bytes
BLOB, TEXT Longitud +2 bytes
MEDIUMBLOB,
MEDIUMTEXT
Longitud +3 bytes
LONGBLOB, LONGTEXT Longitud +4 bytes
ENUM('value1','value2',...)
1 dos bytes dependiendo del nmero
de valores
SET('value1','value2',...)
1, 2, 3, 4 8 bytes, dependiendo del
nmero de valores


12
3-3 Trabajar con el cliente mysql

Introduccin

El objetivo de este tpico es mostrar el uso del programa cliente mysql para crear y usar una
sencilla base de datos. mysql (algunas veces referido como "monitor mysql") es un programa
interactivo que permite conectarnos a un servidor MySQL, ejecutar algunas consultas, y ver
los resultados. mysql puede ser usado tambin en modo batch: es decir, se pueden colocar
toda una serie de consultas en un archivo, y posteriormente decirle a mysql que ejecute
dichas consultas.

Para ver la lista de opciones proporcionadas por mysql, lo invocamos con la opcin --help:

shell> mysql help

A continuacin se describe el proceso completo de creacin y uso de una base de datos en
MySQL.

Puesto que es imposible que se describan en detalle muchos de los tpicos cubiertos aqu, se
recomienda que se consulte el manual de MySQL para obtener ms informacin al respecto.

Conectndose y desconectndose al servidor MySQL

Para conectarse al servidor, usualmente necesitamos de un nombre de usuario (login) y de
una contrasea (password), y si el servidor al que nos deseamos conectar est en una
mquina diferente de la nuestra, tambin necesitamos indicar el nombre o la direccin IP de
dicho servidor. Una vez que conocemos estos tres valores, podemos conectarnos de la
siguiente manera:

shell> mysql -h NombreDelServidor -u NombreDeUsuario p

Cuando ejecutamos este comando, se nos pedir que proporcionemos tambin la contrasea
para el nombre de usuario que estamos usando.

Si la conexin al servidor MySQL se pudo establecer de manera satisfactoria, recibiremos el
mensaje de bienvenida y estaremos en el prompt de mysql:

shell>mysql -h casita -u root -p

Enter password: ******

Your MySQL connection id is 5563 to server version: 3.23.41


mysql>


13
Este prompt nos indica que mysql est listo para recibir comandos.

Algunas instalaciones permiten que los usuarios se conecten de manera annima al servidor
corriendo en la mquina local. Si es el caso de nuestra mquina, debemos de ser capaces de
conectarnos al servidor invocando a mysql sin ninguna opcin:

shell> mysql

Despus de que nos hemos conectado de manera satisfactoria, podemos desconectarnos en
cualquier momento al escribir "quit", "exit", o presionar CONTROL+D.

La mayora de los ejemplos siguientes asume que estamos conectados al servidor, lo cual se
indica con el prompt de mysql.

Si Ud. Instal el software de Appserv, y no se ejecuta el comando mysql, pruebe indicando el
path como C:\AppServ\mysql\bin\mysql. El path real depender donde fue instalado el
software de Appserv.

C:\>C:\AppServ\mysql\bin\mysql -u root -p
Enter password:


Por defecto root no tiene asignada una clave, en la instalacin de AppServ, por lo tanto
simplemente debe activar la tecla Enter cuando se solicita el password de root.

Ejecutar algunas consultas

En este momento debimos de haber podido conectarnos ya al servidor MySQL, an cuando
no hemos seleccionado alguna base de datos para trabajar. Lo que haremos a continuacin
es escribir algunos comandos para irnos familiarizando con el funcionamiento de mysql

mysql> SELECT VERSION(), CURRENT_DATE;

+-----------+--------------+
| VERSION() | CURRENT_DATE |
+-----------+--------------+
| 3.23.41 | 2002-10-01 |
+-----------+--------------+

1 row in set (0.03 sec)

mysql>

Este comando ilustra distintas cosas acerca de mysql:

Un comando normalmente consiste de un sentencia SQL seguida por un punto y coma.

14
Cuando emitimos un comando, mysql lo manda al servidor para que lo ejecute, nos muestra
los resultados y regresa el prompt indicando que est listo para recibir ms consultas.

mysql muestra los resultados de la consulta como una tabla (filas y columnas). La primera
fila contiene etiquetas para las columnas. Las filas siguientes muestran los resultados de la
consulta. Normalmente las etiquetas de las columnas son los nombres de los campos de las
tablas que estamos usando en alguna consulta. Si lo que estamos recuperando es el valor de
una expresin (como en el ejemplo anterior) las etiquetas en las columnas son la expresin
en s.

mysql muestra cuntas filas fueron regresadas y cuanto tiempo tard en ejecutarse la
consulta, lo cual puede darnos una idea de la eficiencia del servidor, aunque estos valores
pueden ser un tanto imprecisos ya que no se muestra la hora del CPU, y porque pueden
verse afectados por otros factores, tales como la carga del servidor y la velocidad de
comunicacin en una red.
Las palabras clave pueden ser escritas usando maysculas y minsculas.

Las siguientes consultas son equivalentes:

mysql> SELECT VERSION(), CURRENT_DATE;
mysql> select version(), current_date;
mysql> SeLeCt vErSiOn(), current_DATE;

Aqu est otra consulta que demuestra como se pueden escribir algunas expresiones
matemticas y trigonomtricas:

mysql> SELECT SIN(PI()/4), (4+1)*5;

+-------------+---------+
| SIN(PI()/4) | (4+1)*5 |
+-------------+---------+
| 0.707107 | 25 |
+-------------+---------+

Aunque hasta este momento se han escrito sentencias sencillas de una sla lnea, es posible
escribir ms de una sentencia por lnea, siempre y cuando estn separadas por punto y
coma:

mysql> SELECT VERSION(); SELECT NOW();

+-----------+
| VERSION() |
+-----------+
| 3.23.41 |
+-----------+


+---------------------+

15
| NOW() |
+---------------------+
| 2002-10-28 14:26:04 |
+---------------------+


Un comando no necesita ser escrito en una sla lnea, as que los comandos que requieran
de varias lneas no son un problema. mysql determinar en donde finaliza la sentencia
cuando encuentre el punto y coma, no cuando encuentre el fin de lnea.

Aqu est un ejemplo que muestra un consulta simple escrita en varias lneas:

mysql> SELECT
-> USER(),
->CURRENT_DATE;

+----------------+--------------+
| USER() | CURRENT_DATE |
+----------------+--------------+
| root@localhost | 2002-09-14 |
+----------------+--------------+


mysql>

En este ejemplo debe notarse como cambia el prompt (de mysql> a ->) cuando se escribe
una consulta en varias lneas. Esta es la manera en cmo mysql indica que est esperando a
que finalice la consulta. Sin embargo si deseamos no terminar de escribir la consulta,
podemos hacerlo al escribir \c como se muestra en el siguiente ejemplo:

mysql> SELECT
-> USER(),
-> \c
mysql>

De nuevo, se nos regresa el comando el prompt mysql> que nos indica que mysql est listo
para una nueva consulta.

En la siguiente tabla se muestran cada uno de los prompts que podemos obtener y una
breve descripcin de su significado para mysql:

Prompt Significado
mysql> Listo para una nueva consulta.
-> Esperando la lnea siguiente de una consulta multi-lnea.

16
'>
Esperando la siguiente lnea para completar una cadena que comienza con una
comilla sencilla (').
">
Esperando la siguiente lnea para completar una cadena que comienza con una
comilla doble (").

Los comandos multi-lnea comnmente ocurren por accidente cuando tecleamos ENTER,
pero olvidamos escribir el punto y coma. En este caso mysql se queda esperando para que
finalicemos la consulta:

mysql> SELECT USER()
->

Si esto llega a suceder, muy probablemente mysql estar esperando por un punto y coma,
de manera que si escribimos el punto y coma podremos completar la consulta y mysql podr
ejecutarla:

mysql> SELECT USER()
-> ;

+----------------+
| USER() |
+----------------+
| root@localhost |
+----------------+


mysql>

Los prompts '> y "> ocurren durante la escritura de cadenas. En mysql podemos escribir
cadenas utilizando comillas sencillas o comillas dobles (por ejemplo, 'hola' y "hola"), y mysql
nos permite escribir cadenas que ocupen mltiple lneas. De manera que cuando veamos el
prompt '> o "> , mysql nos indica que hemos empezado a escribir una cadena, pero no la
hemos finalizado con la comilla correspondiente.

Aunque esto puede suceder si estamos escribiendo una cadena muy grande, es ms
frecuente que obtengamos alguno de estos prompts si inadvertidamente escribimos alguna
de estas comillas.

Por ejemplo:

mysql> SELECT * FROM mi_tabla WHERE nombre = "Juan AND edad < 30;
">

Si escribimos esta consulta SELECT y entonces presionamos ENTER para ver el resultado, no
suceder nada. En lugar de preocuparnos porque la consulta ha tomado mucho tiempo,

17
debemos notar la pista que nos da mysql cambiando el prompt. Esto nos indica que mysql
est esperando que finalicemos la cadena iniciada ("Juan ..).

En este caso, qu es lo que debemos hacer? . La cosa ms simple es cancelar la consulta o
terminarla en la forma correcta.

">";

Sin embargo, si queremos anularla, no basta con escribir \c, ya que mysql interpreta esto
como parte de la cadena que estamos escribiendo. En lugar de esto, debemos escribir antes
la comilla correspondiente y despus \c :

mysql> SELECT * FROM mi_tabla WHERE nombre = "Juan AND edad < 30;
"> " \c
mysql>

El prompt cambiar de nuevo al ya conocido mysql>, indicndonos que mysql est listo para
una nueva consulta.

Es sumamente importante conocer lo que significan los prompts '> y ">, ya que si en algn
momento nos aparece alguno de ellos, todas la lneas que escribamos a continuacin sern
consideradas como parte de la cadena, inclusive cuando escribimos QUIT. Esto puede ser
confuso, especialmente si no sabemos que es necesario escribir la comilla correspondiente
para finalizar la cadena, para que podamos escribir despus algn otro comando, o terminar
la consulta que deseamos ejecutar.

Crear y usar una base de datos

Ahora que conocemos como escribir y ejecutar sentencias, es tiempo de accesar a una base
de datos.

Supongamos que tenemos diversas mascotas en casa (nuestro pequeo zoolgico) y
deseamos tener registros de los datos acerca de ellas. Podemos hacer esto al crear tablas
que guarden esta informacin, para que posteriormente la consulta de estos datos sea
bastante fcil y de manera muy prctica. Esta seccin muestra como crear una base de
datos, crear una tabla, incorporar datos en una tabla, y recuperar datos de las tablas de
diversas maneras.

La base de datos "zoolgico" ser muy simple (deliveradamente), pero no es difcil pensar de
situaciones del mundo real en la cual una base de datos similar puede ser usada.
Primeramente usaremos la sentencia SHOW para ver cules son las bases de datos
existentes en el servidor al que estamos conectados:

mysql> SHOW DATABASES;

+----------+
| Database |
+----------+
| mysql |

18
| test |
+----------+


mysql>

Es probable que la lista de bases de datos que veamos sea diferente en nuestro caso, pero
seguramente las bases de datos "mysql" y "test" estarn entre ellas. En particular, la base de
datos "mysql" es requerida, ya que sta tiene la informacin de los privilegios de los usuarios
de MySQL. La base de datos "test" es creada durante la instalacin de MySQL con el
propsito de servir como rea de trabajo para los usuarios que inician en el aprendizaje de
MySQL.

Se debe anotar tambin que es posible que no veamos todas las bases de datos si no
tenemos el privilegio SHOW DATABASES. Se recomienda revisar la seccin del manual de
MySQL dedicada a los comandos GRANT y REVOKE.

Si la base de datos "test" existe, hay que intentar accesar a ella:

mysql> USE test
Database changed
mysql>

Observar que USE, al igual que QUIT, no requieren el uso del punto y coma, aunque si se
usa ste, no hay ningn problema. El comando USE es especial tambin de otra manera:
ste debe ser usado en una sla lnea.

Podramos usar la base de datos "test" (si tenemos acceso a ella) para los ejemplos que
vienen a continuacin, pero cualquier cosa que hagamos puede ser eliminada por cualquier
otro usuario que tenga acceso a esta base de datos. Por esta razn, es recomendable que
preguntemos al administrador MySQL acerca de la base de datos que podemos usar.
Supongamos que deseamos tener una base de datos llamada "zoologico" (ntese que no se
est acentuando la palabra) a la cual slo nosotros tengamos acceso, para ello el
administrador necesita ejecutar un comando como el siguiente:

mysql> GRANT ALL on zoologico.* TO MiNombreUsuario@MiComputadora
->IDENTIFIED BY 'MiContrasea';

en donde MiNombreUsuario es el nombre de usuario asignado dentro del contexto de
MySQL, MiComputadora es el nombre o la direccin IP de la computadora desde la que nos
conectamos al servidor MySQL, y MiContrasea es la contrasea que se nos ha asignado,
igualmente, dentro del ambiente de MySQL exclusivamente. Ambos, nombre de usuario y
contrasea no tienen nada que ver con el nombre de usuario y contrasea manejados por el
sistema operativo (si es el caso).

Si el administrador cre la base de datos al momento de asignar los permisos, podemos
hacer uso de ella. De otro modo, nosotros debemos crearla:

19

mysql> USE zoologico
ERROR 1049: Unknown database 'zoologico'
mysql>

El mensaje anterior indica que la base de datos no ha sido creada, por lo tanto necesitamos
crearla.

mysql> CREATE DATABASE zoologico;
Query OK, 1 row affected (0.00 sec)

mysql> USE zoologico
Database changed
mysql>

Bajo el sistema operativo Unix, los nombres de las bases de datos son sensibles al uso de
maysculas y minsculas (no como las palabras clave de SQL), por lo tanto debemos de
tener cuidado de escribir correctamente el nombre de la base de datos. Esto es cierto
tambin para los nombres de las tablas.

Al crear una base de datos no se selecciona sta de manera autmatica; debemos hacerlo de
manera explcita, por ello usamos el comando USE en el ejemplo anterior.

La base de datos se crea slo una vez, pero nosotros debemos seleccionarla cada vez que
iniciamos una sesin con mysql. Por ello es recomendable que se indique la base de datos
sobre la que vamos a trabajar al momento de invocar al monitor de MySQL. Por ejemplo:

shell>mysql -h casita -u blueman -p zoologico


Type 'help;' or '\h' for help. Type '\c' to clear the buffer

mysql>

Observar que "zoologico" no es la contrasea que se est proporcionando desde la lnea de
comandos, sino el nombre de la base de datos a la que deseamos acceder. Si deseamos
proporcionar la contrasea en la lnea de comandos despus de la opcin "-p", debemos de
hacerlo sin dejar espacios (por ejemplo, -phola123, no como -p hola123). Sin embargo,
escribir nuestra contrasea desde la lnea de comandos no es recomendado, ya que es
bastante inseguro.

Crear una tabla

Crear la base de datos es la parte ms fcil, pero en este momento la base de datos est
vaca, como lo indica el comando SHOW TABLES:

20

mysql> SHOW TABLES;

La parte un tanto complicada es decidir la estructura que debe tener nuestra base de datos:
qu tablas se necesitan y qu columnas estarn en cada tabla.

En principio, necesitamos una tabla que contenga un registro para cada una de nuestras
mascotas. sta puede ser una tabla llamada mascotas, y debe contener por lo menos el
nombre de cada uno de nuestros animalitos. Ya que el nombre en s no es muy interesante,
la tabla debe contener alguna otra informacin. Por ejemplo, si ms de una persona en
nuestra familia tiene una mascota, es probable que tengamos que guardar la informacin
acerca de quien es el dueo de cada mascota. As mismo, tambin sera interesante contar
con alguna informacin ms descriptiva tal como la especie, y el sexo de cada mascota.

Y que sucede con la edad?. Esto puede ser tambin de inters, pero no es una buena idea
almacenar este dato en la base de datos. La edad cambia conforme pasa el tiempo, lo cual
significa que debemos de actualizar los registros frecuentemente. En vez de esto, es una
mejor idea guardar un valor fijo, tal como la fecha de nacimiento. Entonces, cuando
necesitemos la edad, la podemos calcular como la diferencia entre la fecha actual y la fecha
de nacimiento. MySQL proporciona funciones para hacer operaciones entre fechas, as que
no hay ningn problema.

Al almacenar la fecha de nacimiento en lugar de la edad tenemos algunas otras ventajas:

Podemos usar la base de datos para tareas tales como generar recordatorios para cada
cumpleaos prximo de nuestras mascotas. Podemos calcular la edad en relacin a otras
fechas que la fecha actual. Por ejemplo, si almacenamos la fecha en que muri nuestra
mascota en la base de datos, es fcil calcular que edad tena nuestro animalito cuando
falleci. Es probable que estemos pensando en otro tipo de informacin que sera igualmente
til en la tabla "mascotas", pero para nosotros ser suficiente por ahora contar con
informacin de nombre, propietario, especie, nacimiento y fallecimiento.

Usaremos la sentencia CREATE TABLE para indicar como estarn conformados los registros
de nuestras mascotas.

mysql> CREATE TABLE mascotas(
-> nombre VARCHAR(20), propietario VARCHAR(20),
-> especie VARCHAR(20), sexo CHAR(1), nacimiento DATE,
-> fallecimento DATE);
Query OK, 0 rows affected (0.02 sec)

mysql>

VARCHAR es una buena eleccin para los campos nombre, propietario, y especie, ya que los
valores que almacenarn son de longitud variable. No es necesario que la longitud de estas
columnas sea la misma, ni tampoco que sea de 20. Se puede especificar cualquier longitud
entre 1 y 255, lo que se considere ms adecuado. Si resulta que la eleccin de la longitud de

21
los campos que hemos hecho no result adecuada, MySQL proporciona una sentencia ALTER
TABLE que nos puede ayudar a solventar este problema.

El campo sexo puede ser representado en una variedad de formas, por ejemplo, "m" y "f", o
tal vez "masculino" y "femenino", aunque resulta ms simple la primera opcin.

El uso del tipo de dato DATE para los campos nacimiento y fallecimento debe de resultar
obvio.

Ahora que hemos creado la tabla, la sentencia SHOW TABLES debe producir algo como:

mysql> SHOW TABLES;

+---------------------+
| Tables_in_zoologico |
+---------------------+
| mascotas |
+---------------------+


mysql>

Para verificar que la tabla fu creada como nosotros esperabamos, usaremos la sentencia
DESCRIBE:

mysql> DESCRIBE mascotas;

+--------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| nombre | varchar(20) | YES | | NULL | |
| propietario | varchar(20) | YES | | NULL | |
| especie | varchar(20) | YES | | NULL | |
| sexo | char(1) | YES | | NULL | |
| nacimiento | date | YES | | NULL | |
| fallecimento | date | YES | | NULL | |
+--------------+-------------+------+-----+---------+-------+


mysql>

Podemos hacer uso de la sentencia DESCRIBE en cualquier momento, por ejempo, si
olvidamos los nombres el tipo de las columnas en la tabla.

Cargando datos en una tabla


22
Despus de haber creado la tabla, ahora podemos incorporar algunos datos en ella, para lo
cual haremos uso de las sentencias INSERT y LOAD DATA.

Supongamos que los registros de nuestras mascotas pueden ser descritos por los datos
mostrados en la siguiente tabla.

Nombre Propietario Especie Sexo Nacimiento Fallecimento
Fluffy Arnoldo Gato f 1999-02-04 \N
Mau Juan Gato m 1998-03-17 \N
Buffy Arnoldo Perro f 1999-05-13 \N
FanFan Benito Perro m 2000-08-27 \N
Kaiser Diana Perro m 1998-08-31 1997-07-29
Chispa Omar Ave f 1998-09-11 \N
Wicho Toms Ave 2000-02-09 \N
Skim Benito Serpiente m 2001-04-29 \N

Debemos observar que MySQL espera recibir fechas en el formato YYYY-MM-DD, que puede
ser diferente a lo que nosotros estamos acostumbrados.

Ya que estamos iniciando con una tabla vaca, la manera ms fcil de poblarla es crear un
archivo de texto que contenga un registro por lnea para cada uno de nuestros animalitos
para que posteriormente carguemos el contenido del archivo en la tabla nicamente con una
sentencia.

Por tanto, debemos de crear un archivo de texto "mascotas.txt" que contenga un registro
por lnea con valores separados por tabuladores, cuidando que el orden de las columnas sea
el mismo que utilizamos en la sentencia CREATE TABLE. Para valores que no conozcamos
podemos usar valores nulos (NULL). Para representar estos valores en nuestro archivo
debemos usar \N.
Para cargar el contenido del archivo en la tabla mascotas, usaremos el siguiente comando:

mysql> LOAD DATA LOCAL INFILE "mascotas.txt" INTO TABLE mascotas;

La sentencia LOAD DATA nos permite especificar cul es el separador de columnas, y el
separador de registros, por default el tabulador es el separador de columnas (campos), y el
salto de lnea es el separador de registros, que en este caso son suficientes para que la
sentencia LOAD DATA lea correctamente el archivo "mascotas.txt".

Si lo que deseamos es aadir un registro a la vez, entonces debemos hacer uso de la
sentencia INSERT. En la manera ms simple, debemos proporcionar un valor para cada
columna en el orden en el cual fueron listados en la sentencia CREATE TABLE. Supongamos
que compramos un nuevo hamster nombrado Pelusa.

Podemos usar la sentencia INSERT para agregar su registro en nuestra base de datos.


23
mysql> INSERT INTO mascotas
->VALUES('Pelusa','Diana','Hamster','f','2000-03-30',NULL);

Notar que los valores de cadenas y fechas deben estar encerrados entre comillas.

Tambin, con la sentencia INSERT podemos insertar el valor NULL directamente para
representar un valor nulo, un valor que no conocemos. En este caso no se usa \N como en el
caso de la sentencia LOAD DATA.

De este ejemplo, debemos ser capaces de ver que es un poco ms la tarea que se tiene que
realizar si inicialmente cargamos los registros con varias sentencias INSERT en lugar de una
nica sentencia LOAD DATA.

Recuperar informacin de una tabla

La sentencia SELECT es usada para obtener la informacin guardada en una tabla. La forma
general de esta sentencia es:

SELECT LaInformacinQueDeseamos FROM DeQueTabla WHERE CondicinASatisfacer

Aqu, LaInformacinQueDeseamos es la informacin que queremos ver. Esta puede ser una
lista de columnas, o un * para indicar "todas las columnas". DeQueTabla indica el nombre de
la tabla de la cual vamos a obtener los datos. La clasula WHERE es opcional.

Si est presente, la CondicinASatisfacer especifica las condiciones que los registros deben
satisfacer para que puedan ser mostrados.

Seleccionando todos los datos

La manera ms simple de la sentencia SELECT es cuando se recuperan todos los datos de
una tabla:

mysql> SELECT * FROM mascotas;

+--------+-------------+-----------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+-----------+------+------------+---------------+
| Fluffy | Arnoldo | Gato | f | 1999-02-04 | NULL |
| Mau | Juan | Gato | m | 1998-03-17 | NULL |
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
| FanFan | Benito | Perro | m | 2000-08-27 | NULL |
| Kaiser | Diana | Perro | m | 1998-08-31 | 1997-07-29 |
| Chispa | Omar | Ave | f | 1998-09-11 | NULL |
| Wicho | Toms | Ave | NULL | 2000-02-09 | NULL |
| Skim | Benito | Serpiente | m | 2001-04-29 | NULL |
| Pelusa | Diana | Hamster | f | 2000-03-30 | NULL |
+--------+-------------+-----------+------+------------+---------------+



24
Esta forma del SELECT es til si deseamos ver los datos completos de la tabla, por ejemplo,
para asegurarnos de que estn todos los registros despus de la carga de un archivo.

Por ejemplo, en este caso que estamos tratando, al consultar los registros de la tabla, nos
damos cuenta de que hay un error en el archivo de datos (mascotas.txt): parece que Kaiser
ha nacido despus de que ha fallecido!. Al revisar un poco el pedigree de Kaiser
encontramos que la fecha correcta de nacimiento es el ao 1989, no 1998.

Hay por lo menos un par de maneras de solucionar este problema:

Editar el archivo "mascotas.txt" para corregir el error, eliminar los datos de la tabla mascotas
con la sentencia DELETE, y cargar los datos nuevamente con el comando LOAD DATA:

mysql> DELETE FROM mascotas;

mysql> LOAD DATA LOCAL INFILE "mascotas.txt" INTO TABLE mascotas;

Sin embargo, si hacemos esto, debemos ingresar los datos de Pelusa, la mascota de nuestra
hermana Diana.

La segunda opcin consiste en corregir slo el registro errneo con una sentencia UPDATE:

mysql> UPDATE mascotas SET nacimiento="1989-08-31" WHERE nombre="Kaiser";

Como se mostr anteriormente, es muy fcil recuperar los datos de una tabla completa.

Pero tpicamente no deseamos hacer esto, particularmente cuando las tablas son demasiado
grandes. En vez de ello, estaremos ms interesados en responder preguntas particulares, en
cuyo caso debemos especificar algunas restricciones para la informacin que deseamos ver.

Seleccionando registros particulares

Podemos seleccionar slo registros particulares de una tabla. Por ejemplo, si deseamos
verificar el cambio que hicimos a la fecha de nacimiento de Kaiser, seleccionamos slo el
registro de Kaiser de la siguiente manera:

mysql> SELECT * FROM mascotas WHERE nombre="Kaiser";

+--------+-------------+---------+------+------------+--------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimento |
+--------+-------------+---------+------+------------+--------------+
+--------+-------------+---------+------+------------+--------------+


La salida mostrada confirma que el ao ha sido corregido de 1998 a 1989.

La comparacin de cadenas es normalmente no sensitiva, as que podemos especificar el
nombre como "kaiser", "KAISER", etc. El resultado de la consulta ser el mismo.

25

Podemos adems especificar condiciones sobre cualquier columna, no slo el "nombre". Por
ejemplo, si deseamos conocer qu mascotas nacieron despus del 2000, tendramos que
usar la columna "nacimiento":

mysql> SELECT * FROM mascotas WHERE nacimiento >= "2000-1-1";

+--------+-------------+-----------+------+------------+---------------+
+--------+-------------+-----------+------+------------+---------------+
| FanFan | Benito | Perro | m | 2000-08-27 | NULL |
+--------+-------------+-----------+------+------------+---------------+


Podemos tambin combinar condiciones, por ejemplo, para localizar a los perros hembras:

mysql> SELECT * FROM mascotas WHERE especie="Perro" AND sexo="f";

+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+


La consulta anterior usa el operador lgico AND. Hay tambin un operador lgico OR:

mysql> SELECT * FROM mascotas WHERE especie = "Ave" OR especie = "Gato";

+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+

El operador AND y el operador OR pueden ser intercambiados. Si hacemos esto, es buena
idea usar parntesis para indicar como deben ser agrupadas las condiciones:

mysql> SELECT * FROM mascotas WHERE (especie = "Gato" AND sexo = "m")
->OR (especie = "Perro" AND sexo = "f");

+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+

26
+--------+-------------+---------+------+------------+---------------+


Seleccionando columnas particulares

Si no deseamos ver los registros completos de una tabla, entonces tenemos que usar los
nombres de las columnas en las que estamos interesados separndolas por coma. Por
ejemplo, si deseamos conocer la fecha de nacimiento de nuestras mascotas, debemos
seleccionar la columna "nombre" y "nacimiento":

mysql> SELECT nombre, nacimiento FROM mascotas;

+--------+------------+
| nombre | nacimiento |
+--------+------------+
| Fluffy | 1999-02-04 |
| Mau | 1998-03-17 |
| Buffy | 1999-05-13 |
| FanFan | 2000-08-27 |
| Kaiser | 1989-08-31 |
| Chispa | 1998-09-11 |
| Wicho | 2000-02-09 |
| Skim | 2001-04-29 |
| Pelusa | 2000-03-30 |
+--------+------------+


Para conocer quin tiene alguna mascota, usaremos la siguiente consulta:

mysql> SELECT propietario FROM mascotas;

+-------------+
| propietario |
+-------------+
| Arnoldo |
| Juan |
| Arnoldo |
| Benito |
| Diana |
| Omar |
| Toms |
| Benito |
| Diana |
+-------------+


Sin embargo, debemos notar que la consulta recupera el nombre del propietario de cada
mascota, y algunos de ellos aparecen ms de una vez. Para minimizar la salida, agregaremos
la palabra clave DISTINCT:


27
mysql> SELECT DISTINCT propietario FROM mascotas;

+-------------+
| propietario |
+-------------+
| Arnoldo |
| Juan |
| Benito |
| Diana |
| Omar |
| Toms |
+-------------+


Se puede usar tambin una clasula WHERE para combinar seleccin de filas con seleccin
de columnas. Por ejemplo, para obtener la fecha de nacimiento de los perritos y los gatitos,
usaremos la siguiente consulta:

mysql> SELECT nombre, especie, nacimiento FROM mascotas
->WHERE especie = "perro" OR especie = "gato";

+--------+---------+------------+
| nombre | especie | nacimiento |
+--------+---------+------------+
| Fluffy | Gato | 1999-02-04 |
| Mau | Gato | 1998-03-17 |
| Buffy | Perro | 1999-05-13 |
| FanFan | Perro | 2000-08-27 |
| Kaiser | Perro | 1989-08-31 |
+--------+---------+------------+


Ordenando registros

Se debe notar en los ejemplos anteriores que las filas regresadas son mostradas sin ningn
orden en particular. Sin embargo, frecuentemente es ms fcil examinar la salida de una
consulta cuando las filas son ordenadas en alguna forma til. Para ordenar los resultados,
tenemos que usar una clusula ORDER BY.

Aqu aparecen algunos datos ordenados por fecha de nacimiento:

mysql> SELECT nombre, nacimiento FROM mascotas ORDER BY nacimiento;

+--------+------------+
+--------+------------+
| Kaiser | 1989-08-31 |
| Mau | 1998-03-17 |
| Chispa | 1998-09-11 |
| Fluffy | 1999-02-04 |
| Buffy | 1999-05-13 |
| Wicho | 2000-02-09 |
| Pelusa | 2000-03-30 |

28
| FanFan | 2000-08-27 |
| Skim | 2001-04-29 |
+--------+------------+


En las columnas de tipo caracter, el ordenamiento es ejecutado normalmente de forma no
sensitiva, es decir, no hay diferencia entre maysculas y minsculas. Sin embargo, se puede
forzar un ordenamiento sensitivo al usar el operador BINARY.

Para ordenar en orden inverso, debemos agregar la palabra clave DESC al nombre de la
columna que estamos usando en el ordenamiento:

mysql> SELECT nombre, nacimiento FROM mascotas ORDER BY
-> nacimiento DESC;

+--------+------------+
+--------+------------+
| Skim | 2001-04-29 |
| FanFan | 2000-08-27 |
| Pelusa | 2000-03-30 |
| Wicho | 2000-02-09 |
| Buffy | 1999-05-13 |
| Fluffy | 1999-02-04 |
| Chispa | 1998-09-11 |
| Mau | 1998-03-17 |
| Kaiser | 1989-08-31 |
+--------+------------+


Podemos ordenar mltiples columnas. Por ejemplo, para ordenar por tipo de animal, y poner
al inicio los animalitos ms pequeos de edad, usaremos la siguiente consulta:

mysql> SELECT nombre, especie, nacimiento FROM mascotas
-> ORDER BY especie, nacimiento DESC;

+--------+-----------+------------+
| nombre | especie | nacimiento |
+--------+-----------+------------+
| Wicho | Ave | 2000-02-09 |
| Chispa | Ave | 1998-09-11 |
| Fluffy | Gato | 1999-02-04 |
| Mau | Gato | 1998-03-17 |
| Pelusa | Hamster | 2000-03-30 |
| FanFan | Perro | 2000-08-27 |
| Buffy | Perro | 1999-05-13 |
| Kaiser | Perro | 1989-08-31 |
| Skim | Serpiente | 2001-04-29 |
+--------+-----------+------------+


29

Notar que la palabra clave DESC aplica slo a la columna nombrada que le precede.

Clculos con fechas

MySQL proporciona diversas funciones que se pueden usar para efectuar clculos sobre
fechas, por ejemplo, para calcular edades o extraer partes de una fecha (da, mes, ao, etc).

Para determinar la edad de cada una de nuestras mascotas, tenemos que calcular la
diferencia de aos de la fecha actual y la fecha de nacimiento, y entonces substraer uno si la
fecha actual ocurre antes en el calendario que la fecha de nacimiento. Las siguientes
consultas muestran la fecha actual, la fecha de nacimiento y la edad para cada mascota.

mysql> SELECT nombre, nacimiento, CURRENT_DATE,
-> (YEAR(CURRENT_DATE) - YEAR(nacimiento))
-> AS edad FROM mascotas;

+--------+------------+--------------+------+
| nombre | nacimiento | CURRENT_DATE | edad |
+--------+------------+--------------+------+
| Fluffy | 1999-02-04 | 2002-12-23 | 3 |
| Mau | 1998-03-17 | 2002-12-23 | 4 |
| Buffy | 1999-05-13 | 2002-12-23 | 3 |
| FanFan | 2000-08-27 | 2002-12-23 | 2 |
| Kaiser | 1989-08-31 | 2002-12-23 | 13 |
| Chispa | 1998-09-11 | 2002-12-23 | 4 |
| Wicho | 2000-02-09 | 2002-12-23 | 2 |
| Skim | 2001-04-29 | 2002-12-23 | 1 |
| Pelusa | 2000-03-30 | 2002-12-23 | 2 |
+--------+------------+--------------+------+


Dado que la expresin en s es bastante fea, se ha usado un alias (edad) que es el que
aparece como etiqueta en la columna que muestra el resultado de la consulta.

Esta consulta debe trabajar bien, pero el resultado puede ser de alguna manera ms til si
las filas son presentadas en algn orden. Para ello haremos uso de la clusula ORDER BY.

Por ejemplo, para ordenar por nombre, usaremos la siguiente consulta:

-> AS edad FROM mascotas ORDER BY nombre;

+--------+------------+--------------+------+
+--------+------------+--------------+------+
| Buffy | 1999-05-13 | 2002-12-23 | 3 |
| Chispa | 1998-09-11 | 2002-12-23 | 4 |
| FanFan | 2000-08-27 | 2002-12-23 | 2 |
| Fluffy | 1999-02-04 | 2002-12-23 | 3 |
| Kaiser | 1989-08-31 | 2002-12-23 | 13 |

30
| Mau | 1998-03-17 | 2002-12-23 | 4 |
| Pelusa | 2000-03-30 | 2002-12-23 | 2 |
| Skim | 2001-04-29 | 2002-12-23 | 1 |
| Wicho | 2000-02-09 | 2002-12-23 | 2 |
+--------+------------+--------------+------+


Para ordenar por edad en lugar de nombre, nicamente tenemos que usar una clusula
ORDER BY diferente:

-> AS edad FROM mascotas ORDER BY edad;

+--------+------------+--------------+------+
+--------+------------+--------------+------+
| Skim | 2001-04-29 | 2002-12-23 | 1 |
| FanFan | 2000-08-27 | 2002-12-23 | 2 |
| Wicho | 2000-02-09 | 2002-12-23 | 2 |
| Pelusa | 2000-03-30 | 2002-12-23 | 2 |
| Fluffy | 1999-02-04 | 2002-12-23 | 3 |
| Buffy | 1999-05-13 | 2002-12-23 | 3 |
| Mau | 1998-03-17 | 2002-12-23 | 4 |
| Chispa | 1998-09-11 | 2002-12-23 | 4 |
| Kaiser | 1989-08-31 | 2002-12-23 | 13 |
+--------+------------+--------------+------+


Una consulta similar puede ser usada para determinar la edad que tena una mascota
cuando falleci. Para determinar que animalitos ya fallecieron, la condicin es que el valor en
el campo fallecimiento no sea nulo (NULL). Entonces, para los registros con valor no-nulo,
calculamos la diferencia entre los valores fallecimiento y nacimiento.

mysql> SELECT nombre, nacimiento, fallecimiento,
-> (YEAR(fallecimiento) - YEAR(nacimiento))
-> AS edad FROM mascotas WHERE fallecimiento IS NOT NULL;

+--------+------------+---------------+------+
| nombre | nacimiento | fallecimiento | edad |
+--------+------------+---------------+------+
| Kaiser | 1989-08-31 | 1997-07-29 | 7 |
+--------+------------+---------------+------+


La consulta usa fallecimiento IS NOT NULL, en vez de falleciimiento < > NULL porque NULL
es una valor especial. Esto ser explicando ms a detalle posteriormente.

Qu sucede si deseamos conocer cules de nuestras mascotas cumplen aos el prximo
mes? Para este tipo de clculos, el ao y el da son irrelevantes; simplemente tenemos que

31
extraer el valor del mes en la columna nacimiento. Como se mencion anteriormente, MySQL
proporciona diversas funciones para trabajar y manipular fechas, en este caso haremos uso
de la funcin MONTH( ). Para ver como trabaja, vamos a ejecutar una consulta muy simple
que muestra tanto el valor de una fecha como el valor que regresa la funcin MONTH( ).

mysql> SELECT nombre, nacimiento, MONTH(nacimiento) FROM mascotas;

+--------+------------+-------------------+
| nombre | nacimiento | MONTH(nacimiento) |
+--------+------------+-------------------+
| Fluffy | 1999-02-04 | 2 |
| Mau | 1998-03-17 | 3 |
| Buffy | 1999-05-13 | 5 |
| FanFan | 2000-08-27 | 8 |
| Kaiser | 1989-08-31 | 8 |
| Chispa | 1998-09-11 | 9 |
| Wicho | 2000-02-09 | 2 |
| Skim | 2001-04-29 | 4 |
| Pelusa | 2000-03-30 | 3 |
+--------+------------+-------------------+


Encontrar los animalitos cuyo cumpleaos es el prximo mes es muy sencillo. Suponiendo
que el mes actual es Abril (valor 4), entonces tenemos que buscar los registros cuyo valor de
mes sea 5 (Mayo).

mysql> SELECT nombre, nacimiento FROM mascotas WHERE MONTH(nacimiento) =
5;

+--------+------------+
+--------+------------+
| Buffy | 1999-05-13 |
+--------+------------+


Aqu habr por supuesto una complicacin si el mes actual es Diciembre. No podemos
simplemente agregar uno al nmero del mes (12) y buscar los registros cuyo mes de
nacimiento sea 13 porque dicho mes no existe. En vez de esto, tenemos que buscar los
animalitos que nacieron en Enero (mes 1).

Sin embargo, lo mejor es que podemos escribir una consulta que funcione no importando
cul sea el mes actual. La funcin DATE_ADD( ) nos permite agregar un intervalo de tiempo
a una fecha dada. Si agregamos un mes al valor regresado por la funcin NOW( ), y
entonces extraemos el valor del mes con la funcin MONTH( ), el resultado es que siempre
obtendremos el mes siguiente.

La consulta que resuelve nuestro problema queda as:

mysql> SELECT nombre, nacimiento FROM mascotas

32
-> WHERE MONTH(nacimiento) = MONTH(DATE_ADD(NOW(), INTERVAL 1 MONTH));

Trabajar con valores nulos

El valor NULL puede sorprendermos mientras no hayamos trabajado con l.
Conceptualmente, NULL significa un valor que hace falta, o un valor desconocido, y es
tratado de una manera diferente a otros valores. Para verificar si un valor es NULL no
podemos usar los operadores de comparacin tales como =, > o <.

Para probar esto ejecutemos la siguiente consulta:

mysql> SELECT 1 = NULL, 1 <> NULL, 1 < NULL, 1 > NULL;

+----------+-----------+----------+----------+
| 1 = NULL | 1 <> NULL | 1 < NULL | 1 > NULL |
+----------+-----------+----------+----------+
| NULL | NULL | NULL | NULL |
+----------+-----------+----------+----------+


Claramente observamos que no obtenemos resultados con algn significado con estos
operadores. Es por ello que tenemos que usar los operadores IS NULL e IS NOT NULL:

mysql> SELECT 1 IS NULL, 1 IS NOT NULL;

+-----------+---------------+
| 1 IS NULL | 1 IS NOT NULL |
+-----------+---------------+
| 0 | 1 |
+-----------+---------------+


En MySQL, 0 o NULL significan falso y cualquier otro valor significa verdadero. El valor que
se considera verdadero por default es 1.

Cuando se usa un ORDER BY, los valores NULL son siempre ordenados primero, an cuando
se use la clusula DESC.

Coincidencia de patrones

MySQL proporciona mtodos de coincidencia de patrones basados en SQL estndar, as
como tambin basados en expresiones regulares, de manera similar a las utileras de Unix
tales como vi, grep y sed.

La coincidencia de patrones basada en SQL nos permite usar _ (guin bajo) para un solo
caracter y % para un arbitrario nmero de caracteres. En MySQL, los patrones SQL no son
sensibles al uso de maysculas y minsculas.


33
Es importante notar que no se usan los operadores =, < o > cuando se usan los patrones
SQL; en su lugar se usan los operadores LIKE y NOT LIKE.

A continuacin se presentan algunos ejemplos.

Para encontrar los nombres que comienzan con b:

mysql> SELECT * FROM mascotas WHERE nombre LIKE "b%";

+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+


Para encontrar los nombres que finalizan con fy:

mysql> SELECT * FROM mascotas WHERE nombre LIKE "%fy";

+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+


Para encontrar nombres que contienen una s:

mysql> SELECT * FROM mascotas WHERE nombre LIKE "%s%";

+--------+-------------+-----------+------+------------+---------------+
+--------+-------------+-----------+------+------------+---------------+
+--------+-------------+-----------+------+------------+---------------+


El otro tipo de coincidencia de patrones proporcionado por MySQL hace uso de expresiones
regulares. Para hacer uso de estos tipos de patrones se tienen que usar los operadores
REGEXP y NOT REGEXP ( o RLIKE y NOT RLIKE, los cules son sinnimos).
Algunas caractersticas de las expresiones regulares son:

El caracter punto (.) coincide con cualquier caracter.


34
Una clase de caracteres [...] coincide con cualquier caracter dentro de los parntesis
cuadrados. Por ejemplo, [abc] coincide con a, b o c. Para nombrar un rango de
caracteres, se usa el guin. [a-z] coincide con cualquier letra minscula, mientras que
[0-9] coincide con cualquier digito.

El caracter asterisco (*) coincide con cero o ms instancias de lo que le preceda. Por
ejemplo, x* coincide con cualquier nmero de caracteres x, [0-9]* coincide con
cualquier nmero de digitos, y .* (punto asterisco) coincide con cualquier cosa.

El patrn coincide si ste ocurre en cualquier parte del valor que est siendo
evaluado. (Los patrones SQL coinciden nicamente en los valores completos.)

Para indicar el inicio o el final de un valor que est siendo evaluado se usan los
caracteres ^ y $ respectivamente.

Para demostrar como se usan las expresiones regulares, se van a mostrar los ejemplos
presentados anteriormente con el operador LIKE, ahora con el operador REGEXP.

Para encontrar los nombre que inician con b:

mysql> SELECT * FROM mascotas WHERE nombre REGEXP "^b";


Antes de la versin 3.23.4 de MySQL, el operador REGEXP era sensible al uso de maysculas
y minsculas, as que dependiendo de la versin de MySQL con la que se est trabajando
puede que obtengamos o no algn resultado en la consulta anterior. Se puede usar tambin
la siguiente consulta para buscar los nombres que inician con la letra b, no importando si es
mayscula o minscula.

mysql> SELECT * FROM mascotas WHERE nombre REGEXP "^[bB]";

+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+


Desde la versin 3.23.4, para forzar que el operador REGEXP sea sensible al uso de
maysculas y minsculas, se tiene que usar la palabra clave BINARY para hacer de una de
las cadenas, una cadena binaria. Observar los resultados de la siguientes consultas.

mysql> SELECT * FROM mascotas WHERE nombre REGEXP BINARY "^b";
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+

35

mysql> SELECT * FROM mascotas WHERE nombre REGEXP BINARY "^B";

+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+


Para encontrar los nombres que finalizan con la palabra fy, haremos uso del caracter $.

mysql> SELECT * FROM mascotas WHERE nombre REGEXP "fy$";

+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+


Para encontrar los nombres que contienen una letra s, la consulta sera:

mysql> SELECT * FROM mascotas WHERE nombre REGEXP "s";

+--------+-------------+-----------+------+------------+---------------+
+--------+-------------+-----------+------+------------+---------------+
+--------+-------------+-----------+------+------------+---------------+


Conteo de filas

Las bases de datos son usadas frecuentemente para responder una pregunta, "Con qu
frecuencia ocurre un cierto tipo de dato en una tabla?". Por ejemplo, tal vez queremos
conocer cuntas mascotas tenemos, o cuntas mascotas tiene cada uno de los propietarios.

Contar el nmero total de animalitos que tenemos es lo mismo que hacer la siguiente
pregunta "Cuntas filas hay en la tabla mascotas?" ya que hay un registro por mascota. La
funcin COUNT( ) es la que nos ayuda en esta situacin.

mysql> SELECT COUNT(*) FROM mascotas;

+----------+
| COUNT(*) |

36
+----------+
| 9 |
+----------+


Si deseamos conocer cuntas mascotas tiene cada uno de los propietarios, la consulta es la
siguiente:

mysql> SELECT propietario, COUNT(*) FROM mascotas GROUP BY propietario ;

+-------------+----------+
| propietario | COUNT(*) |
+-------------+----------+
| Arnoldo | 2 |
| Benito | 2 |
| Diana | 2 |
| Juan | 1 |
| Omar | 1 |
| Toms | 1 |
+-------------+----------+


Se debe notar que se ha usado una clusula GROUP BY para agrupar todos los registros de
cada propietario. Si no hacemos esto, obtendremos un mensaje de error:

mysql> SELECT propietario, COUNT(*) FROM mascotas;

ERROR 1140: Mixing of GROUP columns (MIN(),MAX(),COUNT()...) with no
GROUP columns is illegal if there is no GROUP BY clause

En efecto, el uso de la funcin COUNT( ) en conjunto con la clusula GROUP BY es muy til
en diversas situaciones. A continuacin se muestran algunos ejemplos.

El nmero de animalitos por especie:

mysql> SELECT especie, COUNT(*) FROM mascotas GROUP BY especie ;

+-----------+----------+
| especie | COUNT(*) |
+-----------+----------+
| Ave | 2 |
| Gato | 2 |
| Hamster | 1 |
| Perro | 3 |
| Serpiente | 1 |
+-----------+----------+


El nmero de animalitos por sexo:


37
mysql> SELECT sexo, COUNT(*) FROM mascotas GROUP BY sexo;

+------+----------+
| sexo | COUNT(*) |
+------+----------+
| NULL | 1 |
| f | 4 |
| m | 4 |
+------+----------+


El nmero de animalitos por combinacin de especie y sexo:

mysql> SELECT especie, sexo, COUNT(*) FROM mascotas GROUP BY especie, sexo ;

+-----------+------+----------+
| especie | sexo | COUNT(*) |
+-----------+------+----------+
| Ave | NULL | 1 |
| Ave | f | 1 |
| Gato | f | 1 |
| Gato | m | 1 |
| Hamster | f | 1 |
| Perro | f | 1 |
| Perro | m | 2 |
| Serpiente | m | 1 |
+-----------+------+----------+


No es necesario que se obtengan todos los datos de una tabla cuando se usa la funcin
COUNT( ). Por ejemplo, en la consulta anterior, para ver nicamente los datos de perritos y
gatitos, la consulta queda de la siguiente manera:

mysql> SELECT especie, sexo, COUNT(*) FROM mascotas
-> WHERE especie="Perro" OR especie="Gato"
-> GROUP BY especie, sexo;

+---------+------+----------+
+---------+------+----------+
| Gato | f | 1 |
| Gato | m | 1 |
| Perro | f | 1 |
| Perro | m | 2 |
+---------+------+----------+


O bien, si deseamos el nmero de animalitos por sexo, y cuyo sexo es conocido:

mysql> SELECT especie, sexo, COUNT(*) FROM mascotas
-> WHERE sexo IS NOT NULL

38
-> GROUP BY especie, sexo ;

+-----------+------+----------+
+-----------+------+----------+
| Ave | f | 1 |
| Gato | f | 1 |
| Gato | m | 1 |
| Hamster | f | 1 |
| Perro | f | 1 |
| Perro | m | 2 |
| Serpiente | m | 1 |
+-----------+------+----------+


Usar ms de una tabla

La tabla mascotas nos ha servido hasta este momento para tener guardados los datos acerca
de los animalitos que tenemos. Si deseamos guardar algn otro tipo de informacin acerca
de ellos, tal como los eventos en sus vidas -visitas al veterinario, nacimientos de una
camada, etc- necesitaremos de otra tabla. Cmo deber estar conformada esta tabla?. Lo
que necesitamos es:

El nombre de la mascota para saber a cul de ellas se refiere el evento.
Una fecha para saber cuando ocurri el evento.
Una descripcin del evento.
Un campo que indique el tipo de evento, si deseamos categorizarlos.

Dadas estas condiciones, la sentencia para crear la tabla eventos queda de la siguiente
manera:

mysql> CREATE TABLE eventos(nombre varchar(20), fecha date,
-> tipo varchar(15), descripcion varchar(255));

De manera similar a la tabla mascotas, es ms fcil cargar los datos de los registros iniciales
al crear un archivo de texto delimitado por tabuladores en el que se tenga la siguiente
informacin: nombre fecha tipo descripcin

Fluffy 2001-05-15 camada 4 gatitos, 3 hembras, 1 macho
Buffy 2001-06-23 camada 5 perritos, 2 hembras, 3 machos
Buffy 2002-06-19 camada 2 perritos, 1 hembra, 1 macho
Chispa 2000-03-21 veterinario Una pata lastimada
FanFan 2001-08-27 cumpleaos Primera vez que se enfermo de la panza
FanFan 2002-08-03 veterinario Dolor de panza
Whicho 2001-02-09 cumpleaos Remodelacin de casa

Cargamos los datos en este archivo con la siguiente sentencia:


39
mysql> LOAD DATA LOCAL INFILE "eventos.txt" INTO TABLE eventos;
Records: 7 Deleted: 0 Skipped: 0 Warnings: 0

Tomando en cuenta lo que hemos aprendido en la ejecucin de consultas sobre la tabla
mascotas, debemos de ser capaces de recuperar algunos datos de la tabla eventos; los
principios son los mismos. Sin embargo puede suceder que la tabla eventos por s misma sea
insuficiente para darnos las respuestas que necesitamos.

Supongamos que deseemos conocer la edad de cada mascota cuando tuvieron una camada.
La tabla eventos indica cuando ocurri dicho evento, pero para calcular la edad de la madre,
necesitamos sin duda su fecha de nacimiento. Dado que este dato est almacenado en la
tabla mascotas, necesitamos de ambas tablas para realizar esta consulta.

mysql> SELECT mascotas.nombre,
-> (TO_DAYS(fecha) - TO_DAYS(nacimiento))/365 AS edad,
-> descripcion FROM mascotas, eventos
-> WHERE mascotas.nombre=eventos.nombre
-> AND tipo='camada';

+--------+------+---------------------------------+
| nombre | edad | descripcion |
+--------+------+---------------------------------+
| Fluffy | 2.28 | 4 gatitos, 3 hembras, 1 macho |
| Buffy | 2.12 | 5 perritos, 2 hembras, 3 machos |
| Buffy | 3.10 | 2 perritos, 1 hembra, 1 macho |
+--------+------+---------------------------------+


Hay diversas cosas que notar acerca de esta consulta:

La clusula FROM lista dos tablas dado que la consulta necesita informacin que se
encuentra en ambas tablas.
Cuando se combina (junta o join) informacin de mltiples tablas, es necesario
especificar los registros de una tabla que pueden coincidir con los registros en la otra
tabla. En nuestro caso, ambas columnas tienen una columna "nombre". La consulta
usa la clusula WHERE para obtener los registros cuyo valor en dicha columna es el
mismo en ambas tablas.
Dado que la columna "nombre" ocurre en ambas tablas, debemos de especificar a
cul de las columnas nos referimos. Esto se hace al anteponer el nombre de la tabla
al nombre de la columna.
Nota: La funcin TO_DAYS( ) regresa el nmero de das transcurridos desde el ao 0 hasta
la fecha dada.

No es necesario que se tengan dos tablas diferentes para que se puedan juntar. Algunas
veces es til juntar una tabla consigo misma si se desean comparar registros de la misma
tabla. Por ejemplo, para encontrar las posibles parejas entre nuestras mascotas de acuerdo a
la especie, la consulta sera la siguiente:


40
mysql> SELECT m1.nombre, m1.sexo, m2.nombre, m2.sexo, m1.especie
-> FROM mascotas AS m1, mascotas AS m2
-> WHERE m1.especie=m2.especie AND m1.sexo="f" AND m2.sexo="m";

+--------+------+--------+------+---------+
| nombre | sexo | nombre | sexo | especie |
+--------+------+--------+------+---------+
| Fluffy | f | Mau | m | Gato |
| Buffy | f | FanFan | m | Perro |
| Buffy | f | Kaiser | m | Perro |
+--------+------+--------+------+---------+


En esta consulta se ha especificado un alias para el nombre de la tabla, y es ste el que se
utiliza para referirse a las columnas.

Usar mysql en modo batch

En todos los ejemplos mostrados anteriormente, hemos usado mysql de manera interactiva
para ejecutar algunas consultas y ver los resultados. Sin embargo, es posible usar mysql en
modo batch. Para hacer esto tenemos que poner los comandos que deseamos ejecutar
dentro de un archivo, y entonces decirle a mysql que lea los comandos de dicho archivo:

shell> mysql < archivo-batch

Si se usa mysql de esta manera, se est creando un pequeo script, y posteriormente se
est ejecutando dicho script. Al ejecutar las sentencias y comandos que se encuentran en el
script, es posible que suceda algn error. Si se desea que se continuen ejecutando las dems
sentencias, a pesar de que haya ocurrido un error, se tiene que usar la opcin --force

shell> mysql --force < archivo-batch

As mismo, es posible especificar los parmetros de conexin desde la lnea de comandos.
Por ejemplo:

shell> mysql -h pc1 -u alumno1 -p < archivo-batch

Por qu usar un script?

Aqu hay algunas cuantas razones:

Si se ejecutan un cierto nmero de consultas frecuentemente (cada da, o cada semana), al
hacer un script nos evitamos tener que volver a teclear cada una de las consultas.

Se pueden generar nuevas consultas que sean similares a las existentes al copiar y editar
estos scripts.

Al escribir consultas de varias lneas, los scripts ayudan bastante para que no se tengan que
escribir todas las lneas nuevamente si se comete algn error.

41

En Linux, si se estn ejecutando consultas que producen una gran cantidad de datos, es
posible usar un paginador para examinar los resultados de una mejor manera.

shell> mysql < archivo-batch | less
Se puede guardar la salida en un archivo para revisarla posteriormente.
shell> mysql < archivo-batch > salida-del-script.txt

Se pueden distribuir los scripts a otras personas para que puedan ejecutar tambin nuestros
comandos y sentencias.

En algunas situaciones no se permite el uso interactivo de mysql. Por ejemplo cuando se
ejecuta un cron (en Linux). En este caso, es indispensable usar el modo batch.

Cabe mencionar que el formato de la salida es diferente (ms conciso) cuando se ejecuta
mysql en modo batch, que cuando se usa de manera interactiva.

Veamos el siguiente ejemplo.

La consulta es: SELECT DISTINCT especie FROM mascotas.

Si se ejecuta en modo interactivo:

mysql> SELECT DISTINCT especie FROM mascotas;

+-----------+
| especie |
+-----------+
| Gato |
| Perro |
| Ave |
| Serpiente |
+-----------+


Si se ejecuta en modo batch:

shell> mysql -u alumno1 -p <especies-distintas.sql

especie
Gato
Perro
Ave
Serpiente

Donde el archivo especies-distintas.sql contiene la consulta a ejecutar. Si se desea obtener la
salida que proporciona el modo interactivo, se tiene que usar la opcin -t.


42
shell> mysql -t -u alumno1 -p <especies-distintas.sql

+-----------+
| especie |
+-----------+
| Gato |
| Perro |
| Ave |
| Serpiente |
+-----------+

Si queremos evitar que nos pida el password tenemos que indicarlo en el comando de la
siguiente manera:

mysql -t -u alumno1 -palumno <especies-distintas.sql

43
3-4 Funciones PHP de acceso a MySQL

En esta leccin vamos a ver todas la funciones que provee PHP para el manejo de bases de
datos MySQL. Los ejemplos del manejo de las funciones, los veremos a lo largo del curso.

Las siguientes explicaciones referentes a las funciones ms usadas para trabajar con una
base de datos MySQL mediante PHP, pueden dejarse de lado en una primera lectura de este
apuntes. Su uso est pensado como una referencia para consultas.

mysql_affected_rows

int mysql_affected_rows(int [link_identifier] );

mysql_affected_rows devuelve el nmero de filas afectado en el ltimo SELECT, UPDATE o
DELETE (consulta en el servidor asociado con el identificador de conexin especificado). Si
no se especifica un identificador de conexin, se asume le de la ltima conexin abierta.

Esta orden no es eficaz para las instrucciones SELECT, slo en instrucciones que modifican
archivos. Para recuperar el nmero de filas vuelto de un SELECT, usa mysql_num_rows.

mysql_close

int mysql_close(int [link_identifier] );

Devuelve: TRUE si se ha cerrado correctamente, FALSE en caso de errror.

mysql_close cierra la conexin a la base de datos MySQL asociada al idenficador de conexin
especificado. Si no se e especifica un identificador de conexin, se asume le de la ltima
conexin abierta.

Note que esta funcin no es normalmente necesaria en conexiones no-persistentes
(abiertas con mysql_connect()) ya que sta se cerrar automticamente al final de la
ejecucin del script o pgina. La funcin mysql_close no cierra una conexin persistente
(abierta con mysql_pconnect()).
Ver tambien: mysql_connect y mysql_pconnect.

mysql_connect

int mysql_connect(string [hostname] , string [username] , string [password] );

Devuelve: un identificador de conexin, o FALSE en caso de error.

sql_connect establece una conexin a un servidor de MySQL. Todos los argumentos son
optativos, y si no se especifican, los valores por defecto son ('localhost', nombre del usuario
que posee el proceso del servidor, la contrasea vaca). La cadena hostname tambin puede
incluir un nmero del puerto, "hostname:port".

44
En caso de realizar una segunda llamada a mysql_connect con los mismos argumentos, no
se establecer ninguna nueva conexin, sino se devolver el identificador de conexin de la
ya existente.
La conexin al servidor se cerrar en cuanto la ejecucin del script acabe, a menos que la
cerremos antes con la funcin mysql_close.
Ver tambin: mysql_pconnect y mysql_close.

mysql_create_db

int mysql_create_db(string database name, int [link_identifier] );

La funcin mysql_create_db intenta crear una nueva base de datos en el servidor asociado
con el identificado de conexin especificado.
Ver tambin: mysql_drop_db.

mysql_data_seek

int mysql_data_seek(int result_identifier, int row_number);

Devuelve: TRUE si toda ha ido bien, y FALSE en caso de error.

La funcin mysql_data_seek mueve el puntero que indica la fila actual al nmero de fila de la
consulta que indica el identificador. La prxima llamada al mysql_fetch_row o
mysql_fetch_array devolvera esa fila.

mysql_dbname

string mysql_dbname(string result, int i);

mysql_dbname devuelve el nombre de la base de datos guardado en posicin i de los
resultados del indicador de consulta devuelto por la funcin del mysql_list_dbs. La funcin
del mysql_num_rows puede usarse para determinar cuntos nombres de bases de datos
estn disponibles.

mysql_db_query

int mysql_db_query(string database, string query, int link_identifier);

Devuelve: un identificador de conexin, o FALSE en caso de error.

Ejecuta una consulta en una base de datos. Si el identificador no se especifica, la funcin
intenta encontrar una conexin abierta con el servidor. Si no encuentra una conexin,
intentar crear una (similar a mysql_connect( ) sin argumentos).
Ver tambin mysql_connect.

mysql_drop_db

int mysql_drop_db(string database_name, int [link_identifier] );


45
Devuelve: TRUE si toda ha ido bien, y FALSE en caso de error.

Elimina una base de datos del servidor asociado al identificador de conexin.
Ver tambin: mysql_create_db

mysql_errno

int mysql_errno();

Devuelve el nmero de error asociado a la ltima operacin realizada.

Ver tambin: mysql_error

mysql_error

string mysql_error();

Devuelve el texto asociado al error producido en la ltima operacin realizada por la base de
datos.

<?php
mysql_connect("marliesle");
echo mysql_errno().": ".mysql_error()."<BR>";
mysql_select_db("algunadb");
echo mysql_err_db("algunadb");
$conn = mysql_query("SELECT * FROM algunatabla");
?>

Ver tambin: mysql_errno

mysql_fetch_array

array mysql_fetch_array(int result);

Devuelve un array con la informacin correspondiente al resultado de una consulta
especificado por su identificador o 'false' si ya no hay ms filas.

Es una versin extendida de mysql_fetch_row (). Adems de almacenar los datos a travs de
ndices numricos del array, tambin lo hace a travs de ndices asociativos, utilizando los
nombres de los campos como claves.

Si dos o ms columnas del resultado tienen el mismo nombre de campo, la ltima es la que
tiene preferencia.

Ejemplo de mysql fetch array
<?php
mysql_connect($servidor,$usuario,$password);

46
$result = mysql_db_query("base","select * from tabla");
while($row = mysql_fetch_array($result)) {
echo $row["usuario_id"];
echo $row["nombre"];
}
mysql_free_result($result);
?>

mysql_fetch_field

object mysql_fetch_field(int result, int [field_offset] );

Devuelve un objeto que contiene la informacin de los campos que componen un resultado
de una consulta. Si no se especifica 'offset', devuelve informacin sobre el siguiente campo
que todava no ha sido devuelto.

Propiedades del objeto devuelto:

name - nombre del campo
table - nombre de la tabla a la que pertenece el campo
max_length - longitud mxima que puede tomar el campo
not_null - 1 si el campo no puede tomar valores nulos
primary_key - 1 si el campo es una clave principal (primary key)
unique_key - 1 si el campo tiene restriccin de unicidad
multiple_key - 1 si el campo no tiene rest
multiple_key - 1 si el campo no tiene restriccin de unicidad
numeric - 1 si el campo es numrico
blob - 1 si el campo es BLOB
type - tipo de dato (del campo)
unsigned - 1 si el campo es 'unsigned'
zerofill - 1 si el campo es rellenado con ceros

Ver tambin: mysql_field_seek

mysql_fetch_lengths

int mysql_fetch_lengths(int result);

Devuelve: una tabla o FALSE si hay error.

mysql_fetch_lengths almacena en una tabla la longitud de cada campo de una consulta
realizada con mysql_fetch_row o mysql_fetch_array. El ndice de la tabla comienza en 0.
Ver tambin: mysql_fetch_row.

mysql_fetch_object

int mysql_fetch_object(int result);


47
Devuelve: un objeto o FALSE en caso de error.

Esta funcin es similar a mysql_fetch_array, solo que los resultados de una consulta, en
lugar de una tabla, los devuelve como un objeto. En este caso, slo se puede acceder a los
datos a travs de los nombres de sus campos. La velocidad de ejecucin es idntica a la de
mysql_fetch_array. Para referenciar el valor de un campo debemos utilizar el operador
tpicos de los objetos (->).
Ver tambin: mysql_fetch_array y mysql_fetch_row.

mysql_fetch_row

array mysql_fetch_row(int result);

Devuelve: una tabla o FALSE si hay error.

Devuelve un tabla con los valores de los campos de la fila actual, de la consulta que se
especifica con el indicador (result) , y mueve el puntero interno que marca la fila actual a la
siguiente fila, si no hay mas filas devuelve FALSE. El ndice de la tabla comienza en 0.

Ver tambin: mysql_fetch_array, mysql_fetch_object, mysql_data_seek,
mysql_fetch_lengths, y mysql_result.

mysql_field_name

string mysql_field_name(string result, int i);

Devuelve el nombre del campo especificado por el ndice.

mysql_field_seek

int mysql_field_seek(int result, int field_offset);

Mueve el puntero del campo actual hacia delante, las posiciones indicadas por 'offset'.
Ver tambin: mysql_fetch_field.

mysql_field_table

string mysql_field_table(int result, int field_offset);

Devuelve el nombre de la tabla que almacena el campo especificado por el ndice
('field_offset').

mysql_field_type

string mysql_field_type(string result, int field_offset);

Devuelve el tipo del campo del indice especificado.

mysql_field_flags

48

string mysql_field_flags(string result, int field_offset);

Devuelve los especificadores (flags) del campo especificado, como una cadena de texto en la
que cada especificador se corresponde con una palabra, y stas van separadas mediante un
espacio simple. Se puede analizar la cadena utilizando explode( )

Los especificadores son:
"not_null", "primary_key", "unique_key", "multiple_key", "blob", "unsigned", "zerofill",
"binary", "enum", "auto_increment", "timestamp".

mysql_field_len

int mysql_field_len(string result, int field_offset);

Devuelve la longitud del campo especificado

mysql_free_result

int mysql_free_result(int result);

Slo debera ser utilizada si la cantidad de memoria utilizada para almacenar el resultado de
una consulta es muy grande. Cuando se ejecuta esta funcin, toda la memoria asociada al
resultado se libera.

mysql_insert_id

int mysql_insert_id(void);

Esta funcin devuelve el ID (identificador) generado para los campos autonumricos
(AUTO_INCREMENT). El ID devuelto es el correspondiente al de la ltima operacin INSERT.

mysql_list_fields

int mysql_list_fields(string database, string tablename);

Devuelve informacin sobre la tabla. El valor resultante puede ser utilizado con
mysql_field_flags(), mysql_field_len(), mysql_field_name(), mysql_field_type().

El identificador que devuelve es un entero positivo o '-1' en caso de error. El texto que
describe el error se encuentra en $phperrmsg.

mysql_list_dbs

int mysql_listdbs(void);

Devuelve un puntero que contiene las bases de datos disponibles para el servidor actual
(msql daemon). Este valor se utiliza con la funcin mysql_dbname( ).


49
mysql_list_tables

int mysql_list_tables(string database, int [link_identifier]);

Devuelve un identificar, el cual pasaremos a la funcin mysql_tablename() para extraer el
nombre de las tablas de la base de datos especificada.

mysql_num_fields

int mysql_num_fields(int result);

mysql_num_fields devuelve en nmero de campos de una consulta.
Ver tambin: mysql_db_query, mysql_query, mysql_fetch_field, mysql_num_rows.

mysql_num_rows

int mysql_num_rows(string result);

Devuelve el nmero de filas del resultado de una consulta.

Ver tambin: mysql_db_query, mysql_query and, mysql_fetch_row.query, mysql_query,
mysql_fetch_row.

mysql_pconnect

int mysql_pconnect(string [hostname] , string [username] , string [password] );

Devuelve un identificador de conexin persistente o 'falso' en caso de error. Las diferencias
con respecto a mysql_connect( ) son:

Primero, la funcin intenta encontrar una conexin persistente que ya est abierta con la
misma mquina, usuario y password. Si es encontrada, devuelve el identificador de la
misma, en lugar de crear una nueva conexin.

Segundo, la conexin al servidor SQL no ser cerrada cuando finalice la ejecucin del script,
sino que permanece abierta para un uso posterior.

La funcin mysql_close no cierra una conexin abierta con mysql_pconnect. Las conexiones
abierta con esta funcin se llaman "persistentes".

mysql_query

int mysql_query(string query, int [link_identifier] );

Ejecuta una consulta a la base de datos activa en el servidor asociado al identificador de
conexin. Si no se especifica, se utiliza la ltima conexin abierta. Si no hay conexiones
abiertas la funcin intenta establecer una.


50
Esta funcin devuelve TRUE o FALSE para indicar si las operaciones UPDATE, INSERT o
DELETE han tenido xito. Para la operacin SELECT devuelve un nuevo identificador de
resultado o FALSE si hay error.

Ver tambin: mysql_db_query, mysql_select_db, mysql_connect.

mysql_result

int mysql_result(int result, int row, mixed field);

Devuelve el contenido de la celda de un resultado. El argumento 'field' puede ser un ndice o
el nombre del campo correspondiente o el nombre del campo de la forma: tabla.campo. Si la
columna tiene un alias ('select foo as bar from...') se utiliza el alias en lugar del nombre de la
columna.

En lugar de esta funcin es preferible usar mysql_fetch_row(), mysql_fetch_array(),
mysql_fetch_object(), con la que obtendremos mejor rendimiento.

mysql_select_db

int mysql_select_db(string database_name, int [link_identifier] );

Devuelve: true si no hay error, false en caso contrario.

Establece la base de datos activa en el servidor. Si no se especifica identificador de conexin
se utiliza la ltima conexin abierta. Si no hay conexiones activas, la funcin intenta
establecer una. A partir de la llamada a mysql_select_db las llamadas a mysql_query( )
actan sobre la nueva base de datos activa.

Ver tambin: mysql_connect, mysql_pconnect, mysql_query

mysql_tablename

string mysql_tablename(int result, int i);

Toma como argumento un puntero devuelto por la funcin mysql_list_tables( ) y devuelve el
nombre de la tabla asociada al indice i. La funcin mysql_num_rows( ) puede ser utilizada
para determinar el nmero de tablas.

<?php
mysql_connect ("localhost:3306");
$result = mysql_list_tables ("basededatos");
$i = 0;
while ($i < mysql_num_rows ($result)) {
$tb_nombres[$i] = mysql_tablename ($result, $i);
echo $tb_nombres[$i] . "<BR>";
$i++;
}
?>

51


52
3-5 Trabajar con PHP y MySQL

Conectar a MySQL desde PHP

Veremos la tareas bsicas de manejo de datos en una base MySQL.

Crear la base de datos
Como ya vimos, el comando para crear una base de datos MySQL es el siguiente:
mysql>create database base_datos;

Con este comando conseguimos crear una base de datos llamada base_datos en el
servidor de bases de datos.

Otorgamos a la cuenta alumno1 todos los privilegios sobre la base de datos base_datos.

grant all on base_datos.* to alumno1@localhost;

Una vez conseguido esto debemos crear las tablas en la base de datos. La descripcin de las
tablas contienen la estructura de la informacin que almacenaremos en ellas. Para lo cual
usaremos en lenguaje de consultas SQL comn para todas las bases de datos relacionales.

En este ejemplo creamos una tabla llamada prueba con 3 campos: un campo identificador,
que nos servir para identificar unvocamente una fila con el valor de dicho campo, otro
campo con el nombre de una persona y por ltimo un campo con el apellido de la persona.

Para crear la tabla puede usar la herramienta de administracin de MySQL de su servidor
web como por ejemplo el programa webmin en Linux, o MySQLcc en Windows como
veremos luego, o puede escribir un archivo de texto con el contenido de la sentencia SQL
equivalente y luego decirle al motor de base de datos que la ejecute con la siguiente
instruccin:

mysql -u alumno1 -palumno base_datos <prueba.sql

El archivo de texto plano prueba.sql es el siguiente:

CREATE TABLE prueba (ID_Prueba int(11) primary key auto_increment,Nombre
varchar(100),Apellidos varchar(100));

Conexin a la base de datos

Una vez que tenemos creada la base de datos en nuestro servidor, el siguiente paso es
conectarnos a la misma desde una pgina PHP. Para ello PHP nos proporciona una serie de
instrucciones para acceder a bases de datos MySQL.

<html>

53
<head>
<title>Ejemplo de PHP</title>
</head>
<body>
<?php
function Conectarse()
{
if (!($link=mysql_connect("localhost","alumno1","alumno")))
{
echo "Error conectando a la base de datos.";
exit();
}
if (!mysql_select_db("base_datos",$link))
{
echo "Error seleccionando la base de datos.";
exit();
}
return $link;
}

$link=Conectarse();
echo "Conexin con la base de datos conseguida.<br>";

mysql_close($link); //cierra la conexin
?>
</body>
</html>

Al ejecutar la instruccin mysql_connect creamos un vnculo entre la base de datos y la
pagina PHP, este vnculo ser usado posteriormente en las consultas que hagamos a la base
de datos.

Finalmente, una vez que hemos terminado de usar el vnculo con la base de datos, lo
liberaremos con la instruccin mysql_close para que la conexin no quede ocupada.

Consultas a la base de datos

Una vez que nos hemos conectado con el servidor de bases de datos, ya podemos realizar
consultas a las tablas de la base de datos.

Para facilitar la programacin hemos separado la funcin de conexin en una librera a parte,
de tal manera que la incluiremos en todas las pginas que accedan a la base de datos.

El contenido del archivo conex.php, que contiene el cdigo de conexin es el siguiente:

<?php
function Conectarse()
{
if (!($link=mysql_connect("localhost","alumno1","alumno")))

54
{
echo "Error conectando a la base de datos.";
exit();
}
if (!mysql_select_db("base_datos",$link))
{
echo "Error seleccionando la base de datos.";
exit();
}
return $link;
}
?>

Un ejemplo de cdigo para acceder a la base de datos y listar el contenido de una tabla,
podra ser el siguiente:
<html>
<head>
</head>
<body>
<H1>Ejemplo de uso de bases de datos con PHP y MySQL</H1>
<?php
include("conex.php");
$link=Conectarse();
$result=mysql_query("select * from prueba",$link);
?>
<TABLE BORDER=1 CELLSPACING=1 CELLPADDING=1>
<TR><TD> Nombre</TD><TD> Apellidos </TD></TR>
<?php

printf("<tr><td> %s</td><td> %s </td></tr>",
$row["Nombre"],$row["Apellidos"]);
}
mysql_close($link);
?>
</table>
</body>
</html>

En este ejemplo hemos utilizado 4 instrucciones: mysql_query, mysql_fetch_array
,mysql_free_result y mysql_close.

Con la instruccin mysql_query hemos hecho una consulta a la base de datos en el
lenguaje de consultas SQL.

Con la instruccin mysql_fetch_array extraemos los datos de la consulta a un array.

55

Con mysql_free_result liberamos la memoria usada en la consulta.

Con mysql_close cerramos la base de datos.

Insercin de registros

Hasta ahora nos hemos conectado a una base de datos y hemos hecho consultas a la
misma, ahora presentaremos como introducir nuevo registros en la base de datos.

Para ello usaremos un formulario y en el ACTION del FORM <FORM
ACTION="programa.PHP"> indicaremos que debe ser procesada una pagina PHP. Esta
pgina introducir los datos del formulario en la base de datos.

El siguiente archivo ej8 insertar registros.php contiene el cdigo para enviar los datos y
luego leer el contenido de la tabla:

<html>
<head>
</head>
<body>

<H1>Ejemplo de uso de bases de datos con PHP y MySQL</H1>

<FORM ACTION="procesar.php">

<TABLE>

<TR>
<TD>Nombre:</TD>
<TD><INPUT TYPE="text" NAME="nombre" SIZE="20" MAXLENGTH="30"></TD>
</TR>

<TR>
<TD>Apellidos:</TD>
<TD><INPUT TYPE="text" NAME="apellidos" SIZE="20" AXLENGTH="30"></TD>
</TR>

</TABLE>

<INPUT TYPE="submit" NAME="accion" VALUE="Grabar">
</FORM>

<hr>

<?php
$link=Conectarse();

56
?>
<TR>
<TD> <B>Nombre</B></TD>
<TD> <B>Apellidos</B> </TD>
</TR>

<?php
printf("<tr><td> %s</td> <td> %s </td></tr>",
row["Nombre"], $row["Apellidos"]);
}
mysql_close($link);
?>
</table>
</body>
</html>

El siguiente cdigo muestra el contenido del archivo procesar.php que recibe los datos y los
inserta a la tabla.

<?
$link=Conectarse();
mysql_query("insert into prueba (Nombre,Apellidos) values
('$nombre','$apellidos')",$link);
header("Location: ej8 insertar registros.php");
?>

La pgina ej8 insertar registros.php es un formulario que nos permite introducir nombre y
apellido para aadirlo a la base de datos, seguido de una consulta que nos muestra el
contenido de la tabla prueba. El formulario llama a la pagina procesar.php que aadir los
datos a la tabla.
La segunda pgina procesar.php se conecta a la base de datos y aade un nuevo registro
con la instruccin insert del lenguaje de base de datos SQL. Una vez que el registro se ha
aadido se vuelve a cargar la pgina ej8 insertar registros.php
Borrado de registros

Y finalmente, para cerrar el ciclo, nos queda el borrado de registros. El borrado de registros
el uno de los procesos ms sencillos. Para indicar que elemento que vamos a borrar hemos

57
usado un enlace a la pgina borra.php pasndole el ID_Prueba de cada registro, de esta
manera la pgina borra.php sabe que elemento de la tabla ha de borrar.

El cdigo del archivo ej9 borrar registros.php que muestra el contenido de la tabla y permite
indicar que registros se deben borrar es el siguiente:

<html>
<head>
</head>
<body>
<H1>Borrar registros</H1>

<?php
$link=Conectarse();
?>
<TR><TD> <B>Nombre</B></TD>
<TD> <B>Apellidos</B> </TD>
<TD> <B>Borrar</B> </TD></TR>
<?php
printf("<tr><td> %s</td><td> %s </td><td><a
href=\"borra.php?id=%d\">Borra</a></td></tr>",
$row["Nombre"],$row["Apellidos"],$row["ID_Prueba"]);
}
mysql_close($link);
?>
</table>
</body>
</html>

El cdigo del archivo borra.php es el siguiente:

<?php
$link=Conectarse();
mysql_query("delete from prueba where ID_Prueba = $id",$link);

header("Location: ej9 borrar registros.php");
?>

La pgina borra.php se conecta a la base de datos y borra el registro indicado en la variable
$id que ha sido pasado desde la pgina ej9 borrar registros.php. Una vez el registro se ha
borrado se vuelve a cargar la pgina ej9 borrar registros.php.

58
3-6 Administracin de MySQL en Windows

Mysqladmin

Es una herramienta que viene con la distribucin de MySQL y permite realizar tareas
administrativas en el servidor, algunas que tambin se pueden realizar con el cliente mysql,
como crear base de datos. Otras tareas son ms especficas de manejo de servidor como
modificar variables del servidor, arrancar y detener el servidor, etc. Veamos algunos
ejemplos.

shell> mysqladmin [opciones] comando

Los comandos ms importantes son:

create db_name : Permite crear una base de datos.

drop db_name: Permite eliminar una base de datos.

flush-hosts: Actualiza en disco las variables del servidor que se encuentran en el
cache.

password "nuevo_ password: Permite cambiar el password del usuario actual.

ping : Permite verificar si el servidor est activo.

reload: El servidor lee las tablas de privilegios de los usuarios.

refresh: Actualiza las tablas en disco desde el cache

shutdown: Detiene al servidor

start: Arranca al servidor

status: Nuestra el estado del servidor.

variables Muestra las variables del servidor.

version: Muestra la versin del servidor

Las opciones ms importantes son:

--help: Es la ayuda de Mysqladmin

-u nombre del usuario: Para indicar el nombre del usuario

-ppaswword: Para indicar la password del usuario

Ejemplos de uso de Mysqladmin:

59

C:\>appserv\mysql\bin\Mysqladmin u alumno1 ppassword create base1

Vemos que debemos indicar el nombre y la clave si lo pide la configuracin del
servidor MySQL, madiante las opciones del comando.

C:\AppServ\mysql\bin>mysqladmin -u root -ppassword ping
mysqld is alive

C:\AppServ\mysql\bin>mysqladmin -u root -ppassword status
Uptime: 160 Threads: 1 Questions: 5 Slow queries: 0 Opens: 6 Flush tables:
1 Open tables: 0 Queries per second avg: 0.031


60
Mysql Control Center

MyCC es una potente consola de Administracin para Mysql, que permite realizar todas las
tareas de administracin y trabajo de Mysql mediante un interface grfico, y que viene a
cubrir una de las mayores objeciones que los usuarios tenan de Mysql.

Para Utilizarlo, primero lo tendrs que descargar de Mysql.com. Existen actualmente
versiones disponibles para Linux y para Windows. Para poder trabajar con un servidor de
Mysql, primero lo tendrs que dar de alta mediante el icono de Resgitrar servidor.

Aparece un cuadro de dilogo en el cal se pueden configurar todos los parmetros de
acesso al servidor, como son nombre del servidor, nombre de usuario, contrasea, puerto
etc. Una vez conectado a un servidor se podr acceder a las tareas de administracin de los
usuarios de Mysql, administrador del gestor, y administracin de las tablas.

61

Administrador de Usuarios

Desde el se pueden aadir, borrar y modificar las propiedades de los usuarios de Mysql. Al
hacer click sobre un usuario aparece la ventana de configuracin del usuario.

En ella se pueden configurar el nombre de usuario, la contrasea. Respecto a los permisos,
permite establecer un sistema de permisos general o individualizado para cada una de las

62
tablas. Adems permite darle permiso al usuario para que se lo ceda a otros (GRANT
OPTIONS). Uno de los puntos fuertes respecto a la seguridad es que al definir un usuario,
hay que especificar el servidor desde al cual acceder, limitando de esta forma, los riesgos
de acceso indebido.

Administracin del servidor
La ventana de Administracin del servidor consta de tres pestaas desde la cual se pueden
acceder a la lista de procesos, las variables de estado del servidor y las variables de
configuracin.

Desde esta ventana adems se puede hacer un Ping al servidor, detenerlo, o guardar el
contenido de las variables de estado. Desde la pestaa de procesos se puede ver el estado
de cada uno de los procesos activos, viendo sus propiedades y con la opcin de detenerlos
mediante un Kill. Desde la pestaa de estado, se puede ver el contenido de cada una de las
variables de estado, y se puede personalizar para mostrar simplemente las que te interesen.
Desde la pestaa de variables se puede acceder al valor de cada una de las variables de
configuracin del servidor de Mysql.

Ventana de Base de Datos

63

Al seleccionar una base de datos dentro de la seccin de bases de datos, aparece la ventana
de base de datos, en ella se puede ver informacin relacionada con la base de datos, como
puede ser nmero de tablas, el nmero de consultas por segundo, el tiempo que lleva en
funcionamiento etc. Al seleccionar una base de datos, se pueden ver los nombres de las
tablas que contiene, el nmero de registros que contiene. Las tablas se pueden eliminar,
vaciar y renombrar. Cuando se selecciona una tabla, se pueden ver el nombre de los
campos, los tipos de datos y los parmetros opcionales de cada uno de ellos.

Esta ventana permite crear nuevos campos, eliminarlos o modificar sus propiedades. Adems
mediante el icono de herramientas, se puede analizar la tabla, optimizarla y repararla. Al
hacer doble clic sobre una tabla se muestran en la ventana los datos que contiene. Haciendo
clic sobre cualquiera de los campos, se accede a la estructura de la misma. Para cada campo
se puede elegir el tipo de datos, el tamao, si es clave o no, el valor predeterminado del
mismo.

64

Dentro de la tabla, existe un cuadro para configurar los ndices que tiene.

Desde ella se pueden seleccionar los campos que lo contienen, as como el tipo de ndice que
se desea crear. Desde la pestaa de propiedades de la tabla se acceden a los atributos de la
misma, como pueden ser el tipo de tabla, el modo de escritura, el tamao mximo de cada
fila etc.


65

En fin como puedes ver esta es la consola de acceso al servidor de Mysql que llevabamos
tiempo esperando. El producto se distribuye como software libre, as que tanto la descarga
como la utilizacin ilimitada es gratuita. Dispone de versiones Linux y Windows y se puede
encontrar mucha ms informacin, as como la ltima versin en la direccin
www.mysql.com/products/mysqlcc/.

66
phpMyAdmin

phpMyAdmin es un programa de libre distribucin en PHP, creado por una comunidad sin
nimo de lucro, que slo trabaja en el proyecto por amor al arte. Es una herramienta muy
completa que permite acceder a todas las funciones tpicas de la base de datos MySQL a
travs de una interfaz web muy intuitiva.
La aplicacin en si no es ms que un conjunto de archivos escritos en PHP que podemos
copiar en un directorio de nuestro servidor web, de modo que, cuando accedemos a esos
archivos, nos muestran unas pginas donde podemos encontrar las bases de datos a las que
tenemos acceso en nuestro servidor de bases de datos y todas sus tablas. La herramienta
nos permite crear tablas, insertar datos en las tablas existentes, navegar por los registros de
las tablas, editarlos y borrarlos, borrar tablas y un largo etctera, incluso ejecutar sentencias
SQL y hacer un backup de la base de datos.

La pgina de inicio del proyecto es http://www.phpmyadmin.net/. Desde all podemos
descargar los archivos de la ltima versin de la aplicacin, que posteriormente debemos
colocar en nuestro servidor web. Tambin podemos encontrar a phpMyAdmin dentro de la
red Sourceforge.net, que es un sitio que recoge multitud de proyectos "Open Source"
(cdigo abierto).
Hay varias versiones disponibles, pero es recomendable escoger la que nos aconsejen como
la ltima versin estable (The last stable versin).

Instalar phpMyAdmin

Una vez descargada la ltima versin la tenemos que descomprimir, con lo que obtendremos
los archivos PHP que conforman la herramienta y colocarlos dentro del directorio de
publicacin de nuestro servidor web.

Nota: recordamos que phpMyAdmin es un proyecto escrito en PHP, por lo que
necesitaremos colocar los archivos en un servidor web que permita programacin
de pginas PHP. Adems, deberemos acceder a la herramienta a travs de la
direccin del servidor web, seguida del directorio en el que tenemos los archivos
que hemos descomprimido. Por ejemplo, si nuestro servidor es el PWS y hemos
colocado los archivos dentro del directorio de publicacin (Generalmente
C:\Inetpub\wwwroot), en el subdirectorio phpMyAdmin, debemos escribir algo
como http://localhost/phpMyAdmin.

Si tuviramos instalado un servidor Apache los colocaramos en la carpeta que
hayamos indicado como "documentRoot", que suele ser htdocs.

Lo primero que podemos leer es el archivo de la documentacin, que encontramos junto con
los archivos de phpMyAdmin. Explica datos generales del programa, como sus
requerimientos, instrucciones de instalacin, configuracin, preguntas frecuentes, etc.

67
Posteriormente, tal como explica la documentacin, hay que editar el archivo config.inc.php
para cambiar los valores de host que contiene a la base de datos y el usuario y password
con el que nos conectamos. Lo ms simple es copiar el archivo config.default.php que viene
con la distribucin con el nombre config.inc.php en el mismo directorio. Luego modificar este
archivo con ela contrasea de root correspondiente.

Se pueden configurar muchos aspectos en la herramienta, aunque ahora solo comentar los
que he encontrado esenciales para hacerla funcionar, en la documentacin tenemos un
apartado dedicado por completo a especificar el sentido de cada variable.

$cfgPmaAbsoluteUri
Debemos asignarlo a la ruta completa necesaria para acceder a phpMyAdmin. Podra ser algo
como http://localhost/phpMyAdmin o http://www.midominio.com/phpMyAdmin.

$cfgServers[$i]['host'] string

El nombre del host de la base de datos. Por ejemplo localhost, si es que es el mismo
computador donde estamos instalandos phpMyAdmin y la base de datos. Tambin podra ser
la direccin IP del computador al que nos conectamos.

$cfgServers[$i]['user'] string
$cfgServers[$i]['password'] string

El par usuario/contrasea que debe utilizar phpMyAdmin para conectarse con el servidor
MySQL.

68

Con estas sencillas configuraciones ya podemos acceder a phpMyAdmin y trabajar con
nuestra base de datos a golpe de ratn, que resulta muy de agradecer teniendo en cuenta
que, en caso de no tener esta herramienta u otra parecida, la otra opcin consistira en
utilizar el lenguaje SQL, y, en caso de que la base de datos est alojada remotamente en
Internet, no podramos hacerlo sino es con acceso por TELNET al servidor de la base de
datos.

La siguiente figura muestra la pantalla que permite administrar las tablas de la base de datos
Alumno1. All podemos editar los datos, insertar nuevos registros, eliminar registros, modificar la
estructura de la tabla, etc.

La siguiente pantalla permite exportar el contenido de una base de datos mediante la
generacin de un script que contiene los comandos necesarios para crear las estructuras e
insertar los datos. Podemos enviar por mail o insertar el contenido del script en algn archivo
de texto, y luego extraer su contenido y ejecutarlo con la herramienta adecuada, para
generar nuevamente la base de datos y su contenido en otro servidor MySQL.


69

La salida de este procedimiento de exportacin es el siguiente:

-- phpMyAdmin SQL Dump
-- version 2.7.0-pl2
-- http://www.phpmyadmin.net
--
-- Servidor: localhost
-- Tiempo de generacin: 18-01-2006 a las 13:13:14
-- Versin del servidor: 4.0.24
-- Versin de PHP: 4.3.11
--
-- Base de datos: àlumno1`
--
CREATE DATABASE àlumno1`;
USE alumno1;

-- --------------------------------------------------------

--
-- Estructura de tabla para la tabla èventos`
--

CREATE TABLE èventos` (
`nombre` varchar(20) default NULL,
`fecha` date default NULL,

70
`tipo` varchar(15) default NULL,
`descripcion` varchar(255) default NULL
) TYPE=MyISAM;

--
-- Volcar la base de datos para la tabla èventos`
--

INSERT INTO èventos` VALUES ('Fluffy', '2001-05-15', 'camada', '4 gatitos 3 hembras 1
macho');
INSERT INTO èventos` VALUES ('Buffy', '2001-06-23', 'camada', '5 perritos 2 hembras 3
machos');
INSERT INTO èventos` VALUES ('Buffy', '2002-06-19', 'camada', '2 perritos 1 hembra 1
macho');
INSERT INTO èventos` VALUES ('Chispa', '2000-03-21', 'veterinario', 'Una pata lastimada');
INSERT INTO èventos` VALUES ('FanFan', '2001-08-27', 'cumpleanos', 'Primera vez que se
enfermo de la panza');
INSERT INTO èventos` VALUES ('FanFan', '2002-08-03', 'veterinario', 'Dolor de panza');
INSERT INTO èventos` VALUES ('Whicho', '2001-02-09', 'cumpleanos', 'Remodelacion de
casa');

-- --------------------------------------------------------

--
-- Estructura de tabla para la tabla `mascotas`
--

CREATE TABLE `mascotas` (
`nombre` varchar(20) default NULL,
`propietario` varchar(20) default NULL,
èspecie` varchar(20) default NULL,
`sexo` char(1) default NULL,
`nacimiento` date default NULL,
`fallecimiento` date default NULL
) TYPE=MyISAM;

--
-- Volcar la base de datos para la tabla `mascotas`
--

INSERT INTO `mascotas` VALUES ('Fluffy', 'Arnoldo', 'Gato', 'f', '1999-02-04', '0000-00-00');
INSERT INTO `mascotas` VALUES ('Mau', 'Juan', 'Gato', 'm', '1998-03-17', '0000-00-00');
INSERT INTO `mascotas` VALUES ('Buffy', 'Arnoldo', 'Perro', 'f', '1999-05-13', '0000-00-00');
INSERT INTO `mascotas` VALUES ('FanFan', 'Benito', 'Perro', 'm', '2000-08-27', '0000-00-
00');
INSERT INTO `mascotas` VALUES ('Kaiser', 'Diana', 'Perro', 'm', '1989-08-31', '1997-07-29');
INSERT INTO `mascotas` VALUES ('Chispa', 'Omar', 'Ave', 'f', '1998-09-11', '0000-00-00');
INSERT INTO `mascotas` VALUES ('Wicho', 'Toms', 'Ave', '', '2000-02-09', '0000-00-00');

71
INSERT INTO `mascotas` VALUES ('Skim', 'Benito', 'Serpiente', 'm', '2001-04-29', '0000-00-
00');
--
-- Base de datos: `base_datos`
--
CREATE DATABASE `base_datos`;
USE base_datos;

-- --------------------------------------------------------

--
-- Estructura de tabla para la tabla `prueba`
--

CREATE TABLE `prueba` (
ÌD_Prueba` int(11) NOT NULL auto_increment,
`Nombre` varchar(100) default NULL,
Àpellidos` varchar(100) default NULL,
PRIMARY KEY (ÌD_Prueba`)
) TYPE=MyISAM AUTO_INCREMENT=4 ;

--
-- Volcar la base de datos para la tabla `prueba`
--

INSERT INTO `prueba` VALUES (1, 'dd', 'ff');
--
-- Base de datos: `test`
--
CREATE DATABASE `test`;
USE test;

3-7 Interconectar con otras bases de datos

Instalar el driver ODBC para conectar con una base de datos MySQL

Instalar este driver sirve para que desde un sistema Microsoft Windows se pueda acceder a
una base de datos MySQL. Las aplicaciones son variadas, por ejemplo podemos utilizarlo
para crear un DSN asociado a una base de datos MySQL, de modo que nuestras pginas PHP
podran acceder a dicha base de datos. Otra aplicacin es acceder desde Access a la base
de datos MySQL y exportar o importar datos (migrar los datos desde Access a MySQL y
desde MySQL a Access), incluso para crear un back-end de nuestra base MySQL en
interfaz Access.

Lo primero que hay que hacer en el computador que tiene el sistema Windows XX y Access
2000 es actualizar la versin de Microsoft Jet:
http://support.microsoft.com/


72
Una vez se ha hecho esto, hay que descargar la ltima versin de Myodbc de la pgina de
Mysql: http://www.mysql.com/downloads/

Cuando ya tenemos todo, instalamos la actualizacin de Microsoft Jet, y descomprimimos e
instalamos el driver OBDC de Mysql. Cuando pregunta en la pantalla de Data Sources hay
que hacer clic en Close para terminar.

Una vez se ha instalado el driver ODBC, acceder al panel de control de OBDC de 32 Bits
(Botn Inicio-> Configuracin-> Panel de control-> Fuentes de datos ODBC 32 bits).

En este punto, tendrs que elegir si quieres utilizar el driver para un solo usuario (DSN de
usuario), o para cualquier usuario del computador (DSN de Sistema). Una vez hayas elegido
uno, haz clic en el botn de Agregar para aadir una nueva fuente de datos y a
continuacin, selecciona el driver de Mysql. Aparecer la siguiente pantalla:

En ella tendrs que rellenar los siguientes campos:

Data Source Name: Nombre de la fuente de datos que estar disponible desde Windows.

Server Nombre o direccin IP del computador donde se encuentra instalado el servidor
Mysql.

Database: Nombre de la base de datos con la que se trabajar desde la fuente de datos

User: Nombre de usuario con el que se acceder al servidor de bases de datos.

73

Password: Contrasea del usuario.

Una vez estn estas opciones configuradas, se puede hacer clic en "OK" para cerrar las
ventanas.

74
Exportar datos de MySQL a Microsoft Access 2000

Migrar datos de una base de datos a otra es algo a lo que muchos de nosotros hemos tenido
que confrontarnos en algn momento. A continuacin explicamos cmo recuperar
informacin almacenada en un servidor de datos Mysql hacia una base Access 2000.

Para importar una tabla de Mysql a Microsoft Access, desde Access, y con la base de datos
en la que se quieren importar los datos abierta, seleccionar el men Archivo->Obtener datos
Externos->Importar. En la pantalla de Importar datos, en la opcin Tipo de archivo
seleccionar ODBC databases().

Seleccionar origen de datos de equipo, y dentro de esta, el nombre de la fuente de datos
que hemos creado anteriormente. Una vez la has seleccionado, y has hecho clic sobre
"Aceptar", aparecer la pantalla de configuracin del driver por si deseas marcar para esta
accin en concreto, algunas de las opciones de configuracin que aparecen en el driver
ODBC, si no deseas marcar ninguna, clic sobre "OK".

Aparecer una ventana donde pregunta qu tabla de Mysql se desea exportar a Access:

75

Selecciona la tabla , y haz clic sobre "OK"

De esta forma queda la tabla MySQL incorporada a una base de ACCESS.

Nota: si estamos exportando los datos hacia o desde un servidor de bases de
datos alojado en algn proveedor de Hosting, tenemos que tener en cuenta que
estos no siempre incluyen en su paquete bsico el acceso remoto al servidor de
base de datos, o requiere de un aviso explicito por parte del cliente para su
configuracin.


76
Exportar datos de Access 2000 a MySQL

Para exportar una tabla a Mysql, hay que abrir la base de datos y seleccionar la tabla.
Despus, hacer clic sobre Archivo->Exportar. En la pantalla de exportar, en la opcin
Guardar como tipo, seleccionar ODBC databases().

Una vez se ha hecho esto, aparece una ventana que nos pregunta el nombre que le
queremos dar a la tabla en Mysql, por defecto aparece el mismo.

Haz clic sobre "Aceptar", y aparecer la pantalla en la que se pide que selecciones el origen
de datos ODBC:

Seleccionar origen de datos de equipo, y dentro de esta el nombre de la fuente de datos que
hemos creado anteriormente. Una vez la has seleccionado y has hecho clic sobre "Aceptar",
aparecer la pantalla de configuracin del driver por si deseas marcar para esta accin en
concreto algunas de las opciones de configuracin que aparecen en el driver ODBC. Si no
deseas marcar ninguna, haz clic sobre "OK" y los datos comenzarn a exportarse.

77
Administrar y actualizar una base de datos MySQL desde Access

Uno de los mayores problemas de los que adolece actualmente Mysql es el no poseer un
entorno grfico que satisfaga a la mayor parte de los usuarios. Existen magnficos proyectos
a travs de pgina Web, como PHPmysqlAdmin o Mycc, pero muchas veces te encuentras
con gente que le gustara tener algo parecido a un Access, posibilidad de incluir formularios
para la entrada de datos, o de informes sobre los datos almacenados dentro de una tabla.

Dado que no existe hoy en da ninguna herramienta parecida al Access para trabajar con
Mysql, el presente artculo expondr la forma de trabajar con las bases de datos de Mysql
utilizando el entorno grfico de Access. Al terminarlo, podrs utilizar los formularios,
consultas e informes de Access con los datos de los archivos de Mysql.

De esta forma, el encargado de actualizar los datos de una pgina, podr trabajar desde
Access, con la comodidad de los formularios, los mens desplegables etc., y los datos sern
enviados automticamente a Mysql. En la siguiente figura se muestra un reporte que podra
obtenerse con Access.

Formulario de Access que accede a una base de datos MySQL
Una vez que tenemos el driver MyODBC instalado, lo primero que hay que hacer es crear
una base de datos en blanco desde la cual se vincularn las tablas. Una vez creada, se hace
clic sobre la opcin de crear nueva tabla. Aparecer la siguiente ventana en la que se
seleccionar crear nueva tabla vinculada:

78

Aparece la ventana de vincular una tabla de una base de datos, en la parte inferior se
selecciona en tipo de archivo:

fuente de datos ODBC()

Al hacer clic sobre Vincular, aparece la ventana para seleccionar un Origen de datos, se
selecciona dentro de la pestaa de fuentes de datos del Equipo, la fuente de datos que
creamos para este fin:

Una vez se selecciona, se hace clic sobre Aceptar, y aparece la ventana de configuracin de
la fuente de datos ODBC de Mysql. Si ya esta configurada, hacemos clic sobre Aceptar, y
aparecer la ventana en la que se pueden elegir entre las tablas que contiene la base de
datos para la cual hemos configurado la fuente de datos ODBC.


79

Se seleccionan las tablas, y a continuacin aparecer una ventana donde deberemos
especificar los campos que forman parte de la clave.

Se seleccionan los campos, y se hace clic sobre aceptar.

Aparecer una nueva tabla dentro de la base de datos de Access. A diferencia del resto de
tablas, esta no existe fsicamente dentro del archivo de Access, sino que todas las

80
modificaciones que se realizan sobre la misma, se envan a travs de ODBC al archivo
MYSQL.

A partir de ahora, se podrn crear formularios, consultas e informes sobre esta tabla tal y
como se hace normalmente desde Access.


81
3-8 Copias de seguridad en MySQL

El gestor de Bases de datos MySQL incluye varias herramientas para la realizacin de copias
de seguridad de la base de datos. Mediante ellas podremos poner a salvo nuestros datos,
para que, en el eventual caso de que se pierdan, poderlos recuperar.

A la hora de hacer una copia de seguridad, lo primero que se hay que tener en cuenta es la
integridad de los datos que se estn guardando. En todos los casos es necesario que haya
integridad en los datos de una tabla, con esto quiero decir que todos los datos de la tabla
debern estar escritos en la misma, esto puede sonar un poco raro, pero tal y como pasa
con todos los gestores de bases de datos, Mysql dispone de diversas "caches" en las que se
almacenan datos temporalmente con el objetivo de mejorar en rendimiento, de forma que
por ejemplo, una vez hecha una modificacin en una tabla, puede ser que los datos no se
guarden inmediatamente en disco, hasta que termine, por ejemplo, una consulta que se
estaba ejecutando. Por esto, es necesario "forzar" a Mysql a escribir todos los datos en el
disco, mediante la sentencia "Flush Tables".

Adems es necesario que no se escriba en las tablas mientras se esta haciendo la copia de
seguridad de la base de datos, que se consigue con el comando "lock tables", seguido del
nombre de la tabla. Puede haber bases de datos en las que sea necesario bloquear todas las
tablas al mismo tiempo antes de hacer la copia de seguridad.

Existen varias opciones para realizar la copia de seguridad de una base de datos de Mysql:

En primer lugar, se podra utilizar alguna herramienta comercial que gestione todo el
proceso, esto tiene como ventaja la simplicidad del mtodo, y como inconveniente,
que no suelen ser gratis, sino que hay que pagar licencia por la utilizacin de los
mismos. Estas herramientas no se cubrirn en este reportaje.
En segundo lugar, y a partir de la versin 3.23.25 y posteriores, existe la posibilidad
de realizar una copia de seguridad a travs de la sentencia sql "backup table".
Como tercera opcin, es posible realizar copias de seguridad a travs de las
herramientas que nos proporciona el propio gestor de base de datos, como pueden
ser mysqldump mysqlhotcopy.


82
Backup MySQL mediante Sentencias Sql

Veremos cmo realizar una copia de seguridad de la tabla y su recuperacin a partir de
sentencias SQL.

Backup de los datos

Este comando nos permite hacer una copia de los archivos de las tablas de las cuales
queremos hacer un backup, actualmente solo funciona con tablas de tipo MyIsam, y copia
tanto los archivos .frm que contienen la definicin de la tabla, como los archivos .myd, que
contienen los datos.

Antes de ejecutarse, guarda todos los cambios que pudiera haber en memoria de la tabla, de
forma que quede de una manera consistente. Asimismo, durante la ejecucin del comando,
bloquea la tabla sobre la que se est haciendo la copia de seguridad para que los datos sean
consistentes en la tabla. Hay que tener en cuenta que este comando va bloqueando una a
una las tablas, segn va haciendo la copia de seguridad. Esto podra provocar inconsistencia
de datos a nivel de base de datos, si es necesario hacer un backup de todas las tablas en un
instante, en cuyo caso habra que utilizar el comando "lock tables" para bloquear todas las
tablas antes de comenzar la copia de seguridad.

Al finalizar el comando devuelve una tabla, que contiene los campos:

Columna Valores
Table Nombre de la tabla
Op Siempre pone "backup"
Msg_type Puede contener status, error, info o warning.
Msg_text Mensaje descriptivo del resultado de la operacin

Y en la que hay un registro por cada tabla que sobre la que se ha hecho backup.

Para realizar una copia de una tabla llamada mascotas, a la carpeta Backups:

mysql> BACKUP TABLE mascotas TO 'c:/appserv/mysql/backups';
+-------------------------+---------+------------+------------+
| Table | Op | Msg_type | Msg_text |
+-------------------------+---------+------------+------------+
| alumno1.mascotas | backup | status | OK |
+-------------------------+---------+------------+------------+

Recuperacin de datos

Para complementar la sentencia "Backup table", Mysql dispone de la sentencia "Restore
table", que permite restaurar una tabla a partir de una copia de seguridad que se ha
realizado con el comando "Backup Table".

Esta opcin solo se puede utilizar si la tabla que se pretende restaurar no se encuentra en la

83
base de datos, ya que en caso afirmativo mostrar un mensaje de error. Al igual que el
comando de Backup, esta opcin slo esta disponible para las tablas de tipo MyIsam, y a
partir de la versin 3.23.25.

Como el comando de backup, no copia los archivos de ndices, el comando para recuperar
los datos, vuelve a reindexar todos los campos que contienen ndices, creando los archivos
correspondientes. Al igual que el comando para hacer copias de seguridad, invocar al
comando "Restore table" devuelve una tabla, con un registro por cada tabla sobre la que se
ha hecho la base de datos, y que contiene la siguiente informacin:

Columna Valores
Table Nombre de la tabla
Op Siempre pone "restore"
Msg_type Puede contener status, error, info o warning.
Msg_text Mensaje descriptivo del resultado de la operacin

Para restaurar una tabla llamada mascotas de la carpeta Backups a la base de datos:

mysql> restore TABLE mascotas from 'c:/appserv/mysql/backups';
+-----------------------+---------+-------------+------------+
| Table | Op | Msg_type | Msg_text |
+-----------------------+---------+-------------+------------+
| alumno1.mascotas | restore | status | OK |
+-----------------------+---------+-------------+------------+


84
Backup MySQL con mysqldump

Este comando permite hacer la copia de seguridad de una o mltiples bases de datos.
Adems permite que estas copias de seguridad se puedan restaurar en distintos tipos de
gestores de bases de datos, sin la necesidad de que se trate de un gestor de mysql. Esto lo
consigue creando unos archivos, que contienen todas las sentencias sql necesarias para
poder restaurar la tabla, que incluyen desde la sentencia de creacin de la tabla, hasta una
sentencia insert por cada uno de los registros que forman parte de la misma.

El comando dispone de una amplia variedad de opciones que nos permitir realizar la copia
de la forma ms conveniente para el propsito de la misma.

Para poder restaurar la copia de seguridad, bastar con ejecutar todas las sentencias sql que
se encuentran dentro del archivo, bien desde la lnea de comandos de mysql, o desde la
pantalla de ejecucin de sentencias sql de cualquier entorno grfico como puede ser el Mysql
Control Center.

Las limitaciones de la restauracin dependern de las opciones que se han especificado a la
hora de hacer la copia de seguridad, por ejemplo, si se incluye la opcin --add-drop-table al
hacer la copia de seguridad, se podrn restauran tablas que existen actualmente en el
servidor (borrndolas primero). Por lo que es necesario estudiar primero los procedimientos
que se utilizarn tanto en la copia como en la restauracin, para que todo salga correcto!

Algunas de las opciones que tiene son:

--add-locks
Aade LOCK TABLES antes, y UNLOCK TABLE despus de la copia de cada tabla.

--add-drop-table
Aade un drop table antes de cada sentencia create

-A, --all-databases
Copia todas las bases de datos. Es lo mismo que utilizar --databases seleccionando todas.

-a, --all
Incluye todas las opciones de creacin especficas de Mysql.

--allow-keywords
Permite la creacin de nombres de columnas que son palabras clave, esto se realiza
poniendo de prefijo a cada nombre de columna, el nombre de la tabla

-c, --complete-insert
Utiliza inserts incluyendo los nombres de columna en cada sentencia (incrementa bastante el
tamao del archivo)

-C, --compress
Comprime la informacin entre el cliente y el servidor, si ambos soportan compresin.


85
-B, --databases
Para copiar varias bases de datos. En este caso, no se especifican tablas. El nombre de los
argumentos se refiere a los nombres de las bases de datos. Se incluir USE db_name en la
salida antes de cada base de datos.

--delayed
Inserta las filas con el comando INSERT DELAYED.

-e, --extended-insert
Utiliza la sintaxis de INSERT multilnea. (Proporciona sentencias de insert ms compactas y
rpidas.)

-#, --debug[=option_string]
Utilizacin de la traza del programa (para depuracin).

--help
Muestra mensaje de ayuda y termina.

--fields-terminated-by=...
--fields-enclosed-by=...
--fields-optionally-enclosed-by=...
--fields-escaped-by=...
--lines-terminated-by=...
Estas opciones se utilizan con la opcin -T y tienen el mismo significado que la
correspondiente clusula LOAD DATA INFILE.

-F, --flush-logs
Escribe en disco todos los logs antes de comenzar con la copia

-f, --force,
Contina aunque se produzca un error de SQL durante la copia.

-h, --host=..
Copia los datos del servidor de Mysql especificado. El servidor por defecto es localhost.

-l, --lock-tables.
Bloquea todas las tablas antes de comenzar con la copia. Las tablas se bloquean con READ
LOCAL para permitir inserts concurrentes en caso de las tablas MyISAM. Cuando se realiza la
copia de mltiples bases de datos, --lock-tables bloquear la copia de cada base de datos
por separado. De forma que esta opcin no garantiza que las tablas sern consistentes
lgicamente entre distintas bases de datos. Las tablas en diferentes bases de datos se
copiarn en estados completamente distintos.

-K, --disable-keys
Se inluir en la salida /*!40000 ALTER TABLE tb_name DISABLE KEYS */; y /*!40000 ALTER
TABLE tb_name ENABLE KEYS */; Esto har que carga de datos en un servidor MySQL 4.0
se realice ms rpido debido a que los ndices se crearn despus de que todos los datos
hayan sido restaurados.


86
-n, --no-create-db
No se incluir en la salida CREATE DATABASE /*!32312 IF NOT EXISTS*/ db_name; Esta
lnea se incluye si la opcin --databases o --all-databases fue seleccionada.

-t, --no-create-info
No incluir la informacin de creacin de la tabla (sentencia CREATE TABLE).

-d, --no-data
No incluir ninguna informacin sobre los registros de la tabla. Esta opcin sirve para crear
una copia de slo la estructura de la base de datos.

--opt
Lo mismo que --quick --add-drop-table --add-locks --extended-insert --lock-tables. Esta
opcin le debera permitir realizar la copia de seguridad de la base de datos de la forma ms
rpida y efectiva.

-pyour_pass, --password[=your_pass]
Contrasea utilizada cuando se conecta con el servidor. Si no se especifica, `=your_pass',
mysqldump preguntar la contrasea.

-P, --port=...
Puerto utilizado para las conexiones TCP/IP

--protocol=(TCP | SOCKET | PIPE | MEMORY)
Especifica el protocolo de conexin que se utilizar.

-q, --quick
No almacena en el buffer la sentencia, la copia directamente a la salida. Utiliza
mysql_use_result() para realizarlo.

-Q, --quote-names
Entrecomilla las tablas y nombres de columna con los caracteres ``'.

-r, --result-file=...
Redirecciona la salida al archivo especificado. Esta opcin se debera utilizar en MSDOS,
porque previene la conversin de nueva lnea `\n' en nueva lnea y retorno de carro`\n\r'.

--single-transaction
Utiliza el comando BEGIN antes de realizar la copia desde el servidor. Es muy til con las
tables InnoDB y el nivel de transaccin READ_COMMITTED, porque en este modo realizar la
copia de seguridad en un estado consistente sin necesidad de bloquear las aplicaciones.
Consultar el manual para ms detalles.

-S /path/to/socket, --socket=/path/to/socket
El archivo de sockets que se especifica al conectar al localhost (que es el host
predeterminado).

--tables
sobreescribe la opcin --databases (-B).

87

-T, --tab=path-to-some-directory
Crea un archivo table_name.sql, que contiene la sentencia de creacin de SQL, y un archivo
table_name.txt, que contiene los datos de cada tabla. El formato del archivo `.txt' se realiza
de acuerdo con las opciones --fields-xxx y --lines--xxx options. Nota: Esta opcin slo
funciona si el comando mysqldump se ejecuta en la misma mquina que el demonio mysqld,
el usuario deber tener permisos para crear y escribir el archivo en la ubicacin especificada

-u nombre_usuario, --user=nombre_usuario
El nombre de usuario que se utilizar cuando se conecte con el servidor, el valor
predeterminado es el del usuario actual.

-v, --verbose
Va mostrando informacin sobre las acciones que se van realizando (ms lento)

-w, --where='clusula where'
Sirve para realizar la copia de determinados registros

-X, --xml
Realiza la copia de seguridad en un documento xml

-x, --first-slave
Bloquea todas las tablas de todas las bases de datos

Ejemplo:
Para realizar la copia se seguridad de la base de datos alumno1 al archivo
copia_seguridad.sql

C:\AppServ\mysql\bin>mysqldump -u root -ppasword --opt alumno1 >
C:\Appserv\mysql\backups\copia_seguridad.sql

El contenido del archivo copia_seguridad.sql tendr el siguiente contenido que al ejecutarlo
permitir la recuperacin de los datos.

-- MySQL dump 9.11
--
-- Host: localhost Database: alumno1
-- ------------------------------------------------------
-- Server version 4.0.24-nt

--
-- Table structure for table èventos`
--

DROP TABLE IF EXISTS eventos;
CREATE TABLE eventos (
nombre varchar(20) default NULL,
fecha date default NULL,
tipo varchar(15) default NULL,
descripcion varchar(255) default NULL
) TYPE=MyISAM;

--

88
-- Dumping data for table èventos`
--

/*!40000 ALTER TABLE eventos DISABLE KEYS */;
LOCK TABLES eventos WRITE;
INSERT INTO eventos VALUES ('Fluffy','2001-05-15','camada','4 gatitos 3 hembras 1
macho'),('Buffy','2001-06-23','camada','5 perritos 2 hembras 3
machos'),('Buffy','2002-06-19','camada','2 perritos 1 hembra 1
macho'),('Chispa','2000-03-21','veterinario','Una pata
lastimada'),('FanFan','2001-08-27','cumpleanos','Primera vez que se enfermo de la
panza'),('FanFan','2002-08-03','veterinario','Dolor de panza'),('Whicho','2001-02-
09','cumpleanos','Remodelacion de casa');
UNLOCK TABLES;
/*!40000 ALTER TABLE eventos ENABLE KEYS */;

--
-- Table structure for table `mascota`
--

DROP TABLE IF EXISTS mascota;
CREATE TABLE mascota (
propietario varchar(20) default NULL,
especie varchar(20) default NULL,
sexo char(1) default NULL,
nacimiento date default NULL,
fallecimiento date default NULL
) TYPE=MyISAM;

--
-- Dumping data for table `mascota`
--

/*!40000 ALTER TABLE mascota DISABLE KEYS */;
LOCK TABLES mascota WRITE;
INSERT INTO mascota VALUES ('Fluffy','Arnoldo','Gato','f','1999-02-04','0000-00-
00'),('Mau','Juan','Gato','m','1998-03-17','0000-00-
00'),('Buffy','Arnoldo','Perro','f','1999-05-13','0000-00-
00'),('FanFan','Benito','Perro','m','2000-08-27','0000-00-
00'),('Kaiser','Diana','Perro','m','1989-08-31','1997-07-
29'),('Chispa','Omar','Ave','f','1998-09-11','0000-00-
00'),('Wicho','Toms','Ave','','2000-02-09','0000-00-
00'),('Skim','Benito','Serpiente','m','2001-04-29','0000-00-00');
UNLOCK TABLES;
/*!40000 ALTER TABLE mascota ENABLE KEYS */;

--
-- Table structure for table `mascotas`
--

DROP TABLE IF EXISTS mascotas;
CREATE TABLE mascotas (
propietario varchar(20) default NULL,
especie varchar(20) default NULL,
sexo char(1) default NULL,
nacimiento date default NULL,
fallecimiento date default NULL
) TYPE=MyISAM;


89
--
-- Dumping data for table `mascotas`
--

/*!40000 ALTER TABLE mascotas DISABLE KEYS */;
LOCK TABLES mascotas WRITE;
INSERT INTO mascotas VALUES ('Fluffy','Arnoldo','Gato','f','1999-02-04','0000-00-
00'),('Mau','Juan','Gato','m','1998-03-17','0000-00-
00'),('Buffy','Arnoldo','Perro','f','1999-05-13','0000-00-
00'),('FanFan','Benito','Perro','m','2000-08-27','0000-00-
00'),('Kaiser','Diana','Perro','m','1989-08-31','1997-07-
29'),('Chispa','Omar','Ave','f','1998-09-11','0000-00-
00'),('Wicho','Toms','Ave','','2000-02-09','0000-00-
00'),('Skim','Benito','Serpiente','m','2001-04-29','0000-00-00');
UNLOCK TABLES;
/*!40000 ALTER TABLE mascotas ENABLE KEYS */;

90
3-9 Subir una aplicacin PHP al servidor

Veremos en que consiste la puesta en marcha de una aplicacin, programada en local, y
enviada a nuestro servidor de hosting, es decir, subir todos los archivos PHP y la base de
datos a nuestro espacio en el servidor web contratado en un proveedor de alojamiento.

Subir los archivos

Nuestro servidor web debe tener un directorio para la publicacin de las pginas web. Ese
sera el lugar donde hay que subir los archivos .php.

Dependiendo del proveedor con el que trabajemos, el directorio de publicacin puede variar.
Generalmente, cuando contratamos un alojamiento, nos proporcionan una cuenta de FTP
con la que conectarnos al servidor web y transferir los archivos de nuestro sitio.
Adems los datos para la conexin, que sern el nombre del servidor y el usuario y
contrasea para el acceso al FTP.

Al conectarnos al servidor con los datos del FTP, que deben ser proporcionados por nuestro
proveedor, accederemos a un directorio. Este directorio podra ser el de publicacin, aunque
generalmente no es as, sino que suele ser un subdirectorio llamado "HTML" o "docs" o algo
similar, que cuelga del directorio de inicio en nuestra conexin FTP. Como deca, este
directorio puede tener nombres distintos en proveedores distintos, aunque, en cualquier
caso, con una simple pregunta a nuestro proveedor resolveremos esa duda.

Los archivos se deben subir al directorio de publicacin, o a cualquier subdirectorio de este.
En definitiva, los tendremos que alojar por ah dentro y para acceder a ellos bastara con
escribir el nombre del dominio o URL de nuestro alojamiento, seguido del nombre del
archivo. Si tuvisemos un archivo llamado hola.php y nuestro alojamiento se ha contratado
para el dominio www.midominio.com, deberamos subir ese archivo al directorio de
publicacin y accederamos al archivo escribiendo:

http://www.midominio.com/hola.php

Si creamos subdirectorios dentro del directorio de publicacin podremos acceder a ellos
escribiendo el nombre del dominio o URL de nuestro alojamiento, seguido del nombre del
directorio y el nombre del archivo. Por ejemplo, si creamos un subdirectorio llamado paginas
y tenemos dentro un archivo llamado pag1.php, podramos acceder a l de la siguiente
manera.

http://www.midominio.com/paginas/pag1.php

Referencia: hay otro concepto interesante que deberamos conocer llegados a
este punto, que es el "documento por defecto". ste no es ms que el archivo que
se enva al navegador si en la URL accedida no se especificaba ningn archivo.
Suele llamarse index.html o index.php (o index.asp si nuestro servidor soporta
programacin en ASP), aunque puede variar de un proveedor a otro.

91

Colocar los archivos PHP fuera del directorio de publicacin

Por decir algo ms sobre el tema de colocar los archivos, quera sealar que cualquier cosa
que pongamos fuera del directorio de publicacin no podr ser accedida a travs del
navegador. Es decir, si creamos un directorio que se llame funciones_php en el mismo nivel
que el directorio de publicacin (fuera del directorio de publicacin) no podremos acceder
con el explorador a los archivos que coloquemos dentro de ninguna de las maneras. Esto es
as porque la URL de inicio de nuestro alojamiento corresponde con ese directorio y no
podemos movernos hacia debajo de ese directorio con las URLs, que son la manera de
especificar al navegador los recursos a los que se quiere acceder.

No sera posible salir del directorio de publicacin con una URL como esta, por mucho que
utilicemos el operador .. (que sirve para acceder al directorio padre).

http://www.midominio.com/../funciones_php/archivo_inalcanzable.php

Sin embargo, colocar algunos contenidos fuera del directorio de publicacin puede ser muy
til. Por ejemplo, podramos colocar all copias de seguridad de algunos archivos o
documentos que simplemente queremos guardar en el servidor para acceder a ellos desde
cualquier parte y con nuestro programa de FTP.

Hay otra utilidad ms interesante sobre colocar archivos fuera del directorio de publicacin.
Se trata de que muchas veces utilizamos en nuestros programas trozos de cdigo
repetidamente, por ejemplo, para abrir y cerrar bases de datos, para mostrar la cabecera de
nuestro portal, para comprobar que un email escrito en un formulario es correcto, etc.

Es muy til separar estos trozos de cdigo (libreras) en un archivo diferente y llamar a este
archivo con las funciones PHP include() o require(). As, si un da modificamos la cabecera de
nuestro portal, slo lo tendremos que modificar en un archivo, o, si cambia la base de datos
que utilizamos slo tendramos que modificar el archivo que hace la conexin a la base de
datos una vez, en lugar de ir cambindolo en todas las pginas PHP que abran las bases de
datos.

Estos archivos no son pginas independientes, sino trozos. Seguramente, si los ejecutamos
por separado no mostraran ningn resultado vlido, incluso podran dar mensajes de error.
Por esta razn merece la pena colocarlos en un lugar donde nadie pueda tener acceso: fuera
del directorio de publicacin. Con PHP si que podremos acceder a ese directorio para incluir
esos archivos. Solamente deberamos utilizar las funciones PHP include() o require()
indicando la ruta para acceder a los archivos.

En el caso de que tengamos una pgina llamada hola.php en el directorio de publicacin y
un archivo, que se llama abre_base_datos.php, en el directorio funciones_php, que est
fuera del directorio de publicacin, si quisiramos acceder (desde hola.php) al archivo que
abre la base de datos lo haramos as.

include("../funciones_php/abre_base_datos.php")

92

Desde PHP s que podemos acceder a los archivos que se encuentran fuera del directorio de
publicacin. Para ello especificamos la ruta adecuada, en la que utilizamos el operador ..
para bajar al directorio padre.

Nada ms que decir sobre la colocacin de los archivos: una vez situados en el directorio de
publicacin se podr acceder a ellos con nuestro navegador y se deberan ejecutar
perfectamente.

Cabe sealar que, tanto PHP como el servidor donde trabajemos, pueden tener
configuraciones distintas y puede que algn detalle de la programacin de nuestras pginas
no funcione correctamente.

Por ejemplo, nuestro PHP puede declarar o no automticamente las variables que llegan a
travs de un formulario. Si en local estaba configurado para hacer esto y en remoto no,
deberamos localizar los lugares donde recogemos las variables y utilizar las variables de
entorno correctas.

Aunque este no es un caso habitual, podemos ponernos en contacto con nuestro proveedor
de alojamiento para ver si pueden ayudarnos configurando el sistema o indicando los pasos
a seguir para solventar en nuestros scripts el asunto.

Subir una base de datos al servidor de Internet

Aparte de los archivos de la pgina, debemos subir la base de datos con la que tenemos que
trabajar. Las bases de datos con las que trabaja PHP son muy variadas y en distintos casos
podemos utilizar una u otra, por lo que los modos de subir la base de datos tambin pueden
variar.

Es muy corriente que nuestro proveedor de hosting ofrezca junto con PHP la base de datos
MySQL, as que las explicaciones para subir esa base de datos al servidor van encaminadas a
ofrecer soluciones para esa base de datos.

La base de datos MySQL no se puede subir por FTP, como se hace con los archivos del
cdigo PHP.

Para subirla tendremos que utilizar otros mecanismos. Voy a distinguir entre tres casos
distintos en los que nos podramos encontrar en este momento:

1. La base de datos que pretendemos subir est vaca. Tan slo hemos creado las
tablas, pero no hemos introducido datos en ellas o, a lo sumo, tienen algn dato que
hemos introducido de pruebas.

2. La base de datos que queremos subir est completa y es una base de datos MySQL.
En este caso tenemos creada la base de datos en local y con toda la informacin
dentro y, por supuesto, queremos que esa informacin quede tambin en la base de
datos remota.


93
3. La base de datos est completa (como el caso anterior), pero no es una base de
datos MySQL. En este caso estaramos haciendo una migracin de la base de datos
de un sistema gestor a otro.

Veremos los tres casos por separado en adelante, aunque, antes de ello, vamos a recordar
unas herramientas que nos servirn de mucha ayuda para la administracin de cualquier
base de datos remota.

PhpMyAdmin. Una aplicacin creada en PHP que podemos instalar en nuestro espacio de
alojamiento para administrar la base de datos.

Mysql Control Center (MyCC). Una aplicacin Windows que permite conectarse a mltiples
bases de datos MySQL, que se encuentren en local o en remoto.

Access. Tambin permite administrar una base de datos MySQL conectada en local o en
remoto. En este caso se utiliza una interfaz que muchos ya conocen, como es Access, para
administrar una base de datos que nada tiene que ver con dicho programa.

En los tres casos lo que nos permite realizar el software de administracin son tareas de
todo tipo sobre la base de datos, como pueden ser crear tablas, modificarlas, insertar datos,
borrarlos, editarlos. Modificar o borrar tablas o campos de las mismas, etc.

La eleccin de una herramienta o de otra pasa por los recursos que nos permitan utilizar en
nuestro proveedor. Bsicamente, lo que nos puede derivar a una opcin u otra, es si
permiten o no conectar de manera remota la base de datos MySQL.

Si no permiten conectarnos remotamente nos inclinaremos por PhpMyAdmin, pues es una
aplicacin PHP que se conecta en local y a la que se accede desde una pgina web y eso lo
permiten todos los proveedores, incluso hay muchos que tienen instalado ya este software
para administrar las bases de datos.

En caso de que s nos permitan conectarnos remotamente con la base de datos, elegiremos
MyCC o Access, que son aplicaciones Windows mucho ms potentes y rpidas que las que
utilizan interfaz web, como PhpMyAdmin. Es preferible utilizar MyCC porque est
especialmente desarrollado para conectar y operar con bases de datos MySQL.

Subir base de datos MySQL vaca al servidor

Es muy normal que hayamos diseado una base de datos para nuestro proyecto desde 0,
definiendo las distintas entidades de nuestro modelo de datos, junto con sus campos y sus
tipos.

En estos casos lo ms probable es que la base de datos est vaca, o bien contenga datos
que hayamos introducido a modo de prueba y que no queramos conservar cuando subamos
la aplicacin a Internet.

La opcin ms interesante entonces podra ser crear otra vez las tablas que tenemos en
local en la base de datos remota. Para ello tenemos dos posibilidades.

94

a) Si tenemos pocas tablas y bastante sencillas

Las podemos crear en remoto con alguna herramienta como PhpMyAdmin o MyCC.

b) Si tiene muchas tablas y/o muy complicadas

La recomendacin sera hacer un backup de la estructura en local y restaurarla en remoto.
Esto nos evitar tener que volver a crear todas las tablas y definir todos sus campos y sus
tipos. Puede ser un poco ms complicado pero sin duda nos ahorrar tiempo.

Para hacer el backup de la estructura en local podemos utilizar alguna herramienta como
PhpMyAdmin, o bien utilizar el comando mysqldump desde lnea de comandos de MS-
DOS.

Con PHPMYADMIN

95

96

Herramienta de backup de PhpMyAdmin. Est marcada la opcin de extraer la estructura
de las tablas y los datos. Si marcamos adems la casilla "Enviar", nuestro navegador se
descargar el backup en un archivo de texto. Si no lo pulsamos simplemente se visualizar.

Si lo que tenemos que hacer en este caso es un backup solamente de la estructura de la
base de datos, es decir, los "create tables" o sentencias SQL para crear las tablas no
marcamos la casilla de Datos. Al hacer clic en Continuar grabamos el archivo.

Sera un montn de sentencias con esta forma como ya vimos en ejemplos anteriores:

# --------------------------------------------------------
#
# Table structure for table 'comentario'
#

CREATE TABLE comentario (
id_comentario int(5) unsigned NOT NULL auto_increment,
id_articulo int(4) DEFAULT '0' NOT NULL,
comentario text NOT NULL,
fecha int(14) unsigned DEFAULT '0' NOT NULL,
revisado tinyint(1) DEFAULT '0' NOT NULL,
nombre_comentario varchar(100) DEFAULT 'Nombre no especificado' NOT NULL,
email_comentario varchar(100) DEFAULT 'Email sin especificar' NOT NULL,
tipo tinyint(1) unsigned DEFAULT '1' NOT NULL,
PRIMARY KEY (id_comentario)
);

Para restaurar estas sentencias tenemos opciones tanto dentro de PhpMyAdmin como de
MyCC. En ambos casos lo que tenemos que hacer es ejecutar estas sentencias en el servidor
MySQL remoto. En PhpMyAdmin tenemos un campo para introducir sentencias SQL y
tambin otro campo para seleccionar un archivo de texto con todas las sentencias SQL, para

97
ejecutarlas una detrs de otra. En MyCC tenemos un botn que nos permite abrir una
consola donde introducir una o varias sentencias SQL y ejecutarlas.

Subir una base de datos MySQL con la estructura y los datos
Si la base de datos que deseamos subir est llena de informacin y deseamos que se
conserve una vez subida la base de datos a remoto, tenemos que realizar un backup de la
base de datos y restaurarlo en remoto.

En este caso el procedimiento sera muy parecido al de subir una base de datos vaca,
relatado anteriormente, con la salvedad de que ahora debemos extraer no solo la estructura
de la base de datos, sino tambin los registros que contiene.

Para ello podemos utilizar mysqldump o bien PhpMyAdmin, seleccionando la opcin que
indica que el backup contenga la estructura y los datos.

La estructura y los datos vendrn en un archivo de texto con una serie de sentencias SQL
para crear las tablas y los insert necesarios para introducir cada uno de los datos.

Para restaurar la base de datos lo haremos tal como se ha relatado para el caso de que la
base de datos estuviera vaca, con la ayuda de una instalacin de PhpMyAdmin en remoto o
un MyCC que se conecte a la base de datos contratada en el servidor de Internet.

Si tenemos problemas para subir el archivo de backup de la base de datos es posible que en
nuestro proveedor de alojamiento nos pueda ayudar a subir el archivo y restaurarlo.

Como el proveedor dispone de los servidores en sus propias instalaciones, tiene muchas ms
posibilidades que nosotros para trabajar con las bases de datos, sin temor a que las lentas
comunicaciones por Internet arrojen errores en la restauracin de los datos.

Si nuestro proveedor no puede ayudarnos, seguramente disponga y nos indique algn
mecanismo para realizar la tarea sin lugar a errores. Puede ocurrir con algn proveedor que
nos diga que se encarga de todo pero nos exija el pago de las horas de trabajo del
informtico que va a restaurar el backup de la base de datos.

Migrar una base de datos a MySQL

El ltimo caso en el que nos podemos encontrar a la hora de subir una base de datos a
nuestro proveedor de alojamiento es que la base de datos la tengamos creada en local, pero
en un sistema gestor distinto del que vamos a utilizar en remoto. En remoto suponemos
siempre que vamos a utilizar la base de datos MySQL. En local podramos disponer de una
base de datos Access, SQL Server o de otro sistema de base de datos.

El proceso de la migracin puede ser bastante complejo y, como hay tantas bases de datos
distintas, difcil de dar una receta que funcione en todos los casos. Adems, aparte de la
dificultad de transferir la informacin entre los dos sistemas gestores de base de datos,
tambin nos influir mucho en la complejidad del problema el tipo de los datos de las tablas
que estamos utilizando. Por ejemplo, las fechas, los campos numricos con decimales o los

98
booleanos pueden dar problemas al pasar de un sistema a otro porque pueden almacenarse
de maneras distintas o, en el caso de los nmeros, con una precisin distinta.

Recomendaciones para migrar de Access a MySQL

Si nuestra base de datos anterior estaba construida en Access lo tenemos bastante fcil
como ya vimos, gracias a que MySQL dispone de un driver ODBC para sistemas Windows,
que nos permite conectar Access con el propio MySQL y pasar informacin fcilmente.

Hay que indicar que si deseamos hacer una exportacin desde Access en local a MySQL en
remoto puede haber problemas porque no todos los alojadores permiten las conexiones en
remoto con la base de datos. Si no tenemos disponible una conexin en remoto con nuestro
servidor de bases de datos vamos a tener que cambiar la estrategia un poco.

La idea en este ltimo caso es instalar MySQL en local y realizar la migracin desde Access
en local a MySQL en local y luego podramos hacer un backup de la base de datos local y
subirla a remoto, tal y como se ha relatado antes.

Recomendaciones para migrar desde SQL Server a MySQL

Access permite seleccionar una base de datos SQL Server y trabajar desde la propia interfaz
de Access. La idea es que Access tambin permite trabajar con MySQL y posiblemente
haciendo un puente entre estos dos sistemas gestores podemos exportar datos de SQL
Server a MySQL.

Lo que es seguro que utilizando el propio Access de puente podramos realizar el trabajo.
Primero exportando de SQL Server a Acess y luego desde Access a MySQL.

Otras bases de datos u otras tcnicas

Si la base de datos origen dispone de un driver ODBC no habr (en teora) problema para
conectarla con Access, de manera similar a como se conecta con MySQL. Entonces
podramos utilizar Access para exportar los datos, porque desde all se podran acceder a los
dos sistemas gestores de bases de datos.

Si no tenemos Access, o la base de datos original no tiene driver ODBC, o bien no nos
funciona correctamente el proceso y no sabemos cmo arreglarlo, otra posibilidad es
exportar los datos a archivos de texto, separados por comas o algo parecido.

Muchas bases de datos tienen herramientas para exportar los datos de las tablas a archivos
de texto, los cuales se pueden luego introducir en nuestro sistema gestor destino (MySQL)
con la ayuda de alguna herramienta como PhpMyAdmin.

Modulo3 - Conectar PHP Con Base de Datos

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Modulo3 - Conectar PHP Con Base de Datos

Uploaded by

Copyright:

Available Formats

rea Tecnolgica de Educacin Virtual UTN FRC SEU

PHP, MySQL y E-Commerce Conectar PHP con base de datos

You might also like