Modulo3 Conectar PHP Con Base de Datos

PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
UNIVERSIDAD TECNOLÓGICA NACIONAL

Facultad Regional Córdoba
Secretaria de Extensión Universitaria
Área Tecnológica de Educación Virtual
Coordinador General de Educación Virtual: Magíster Leandro D.

Torres
Curso:
PHP, MySQL y E-Commerce
Módulo:
“Conectar PHP con base de datos”
Tutor: Ing. Oscar R. Espeche
Autor: Ing. Oscar R. Espeche

1
Módulo 3-Conectar PHP con Base de Datos

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 Administración de MySQL en Windows
3-7 Interconectar con otras bases de datos
3-8 Copias de seguridad en MySQL
3-9 Subir una aplicación PHP al servidor

2
3-1 Estructura de MySQL

PHP tiene posibilidades de conexión con varias base de datos. En esta primera parte
veremos las características de conexión 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 características de este administrador de base de datos.
Suponemos que ya tenemos instalado el servidor mysqld y el cliente mysql. A continuación

nos ocuparemos en detalle de los trabajos que podemos hacer desde el cliente mysql con los
datos del servidor.
En esta sección vamos a hacer un pequeño recorrido por MySQL, por su estructura y forma
de trabajar. Para ello suponemos que ya hemos conseguido (por fin...) instalar MySQL en
nuestra máquina. 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
cuál se componen de cinco tablas: host, user, db, tables_priv, colums_priv.
La tabla user contiene información sobre los usuarios, desde que máquinas pueden acceder
a nuestro servidor MySQL, su clave y de sus diferentes permisos.
La tabla host nos informa sobre que máquinas podrán acceder a nuestro sistema, así como
a las bases de datos que tendrán 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
3
Process_priv enum('N','Y') N
File_priv enum('N','Y') N
Grant_priv enum('N','Y') N
References_priv enum('N','Y') N
Index_priv enum('N','Y') N
Alter_priv enum('N','Y') N
El término 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 descripción de los diferentes permisos:
• Select_priv: Permite utilizar la sentencia SELECT

4
• 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
• 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 símbolo % en el
campo.
Administración básica 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 básicas 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.
5
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.
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';

6
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.
También le definimos la clave “alumno” a dicha cuenta. Este comando encripta la clave y la
almacena.
Todos estos datos son almacenados en la tabla “user” y “db” de la base de datos “mysql”.
Para más datos sobre tareas administrativas se deberá consultar al manual de MySQL.

7
3-2 Tipos de Datos de Mysql

Después de la fase de diseño 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 diseño de la base de datos, y conseguir un
almacenamiento óptimo con la menor utilización de espacio. El presente artículo describe
cada uno de los tipos de datos que puede tener un campo en Mysql, para la versión 4.xx.xx.
Los tipos de datos que puede haber en un campo, se pueden agrupar en tres grandes
grupos:
1. Tipos numéricos
2. Tipos de Fecha
3. Tipos de Cadena
Tipos numéricos:
Existen tipos de datos numéricos, que se pueden dividir en dos grandes grupos, los que
están en coma flotante (con decimales) y los que no.
TinyInt: es un número entero con o sin signo. Con signo el rango de valores válidos va
desde -128 a 127. Sin signo, el rango de valores es de 0 a 255
Bit ó Bool: un número entero que puede ser 0 ó 1
SmallInt: número 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: número 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: número 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: número 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: número pequeño en coma flotante de precisión simple. Los valores válidos van desde
-3.402823466E+38 a -1.175494351E-38, 0 y desde 1.175494351E-38 a 3.402823466E+38.
xReal, Double: número en coma flotante de precisión doble. Los valores permitidos van
desde -1.7976931348623157E+308 a -2.2250738585072014E-308, 0 y desde
2.2250738585072014E-308 a 1.7976931348623157E+308
8
Decimal, Dec, Numeric: Número en coma flotante desempaquetado. El número se

almacena como una cadena
Tipo de Tamaño de
Campo 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
8 bytes
PRECISION
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 válida o no. Simplemente comprueba que el mes esta
comprendido entre 0 y 12 y que el día 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 año-mes-dia
DateTime: Combinación 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 año-mes-dia
horas:minutos:segundos
TimeStamp: Combinación de fecha y hora. El rango va desde el 1 de enero de 1970 al año

2037. El formato de almacenamiento depende del tamaño del campo:
Tamaño Formato
AñoMesDiaHoraMinutoSegundo
14
aaaammddhhmmss

9
AñoMesDiaHoraMinutoSegundo
12
aammddhhmmss
8 ñoMesDia aaaammdd
6 AñoMesDia aammdd
4 AñoMes aamm
2 Año aa
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 año. El rango de valores permitidos va desde el año 1901 al año 2155. El
campo puede tener tamaño dos o tamaño 4 dependiendo de si queremos almacenar el año
con dos o cuatro dígitos.
Tipo de Tamaño de
Campo 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 más usados comúnmente.
Almace Almace
Valor CHAR(4) VARCHAR(4)
namiento 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
10
Blob y Text: un texto con un máximo 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
Mayúsculas y las minúsculas, el tipo BLOB se ordena teniéndolas en cuenta.
Los tipos BLOB se utilizan para almacenar datos binarios como pueden ser archivos.
TinyText y TinyBlob: Columna con una longitud máxima de 255 caracteres.

MediumBlob y MediumText: un texto con un máximo de 16.777.215 caracteres.
LongBlob y LongText: un texto con un máximo de caracteres 4.294.967.295. Hay que

tener en cuenta que debido a los protocolos de comunicación los paquetes pueden tener un
máximo 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 número 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 máximo de 64 valores. Se almacena un número que es un índice de la lista
pero con un formato diferente al anterior.
Tipo de campo Tamaño de Almacenamiento

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

11
3-3 Trabajar con el cliente mysql
Introducción
El objetivo de este tópico 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 también 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 opción --help:
shell> mysql –help
A continuación se describe el proceso completo de creación y uso de una base de datos en

MySQL.
Puesto que es imposible que se describan en detalle muchos de los tópicos cubiertos aquí, se
recomienda que se consulte el manual de MySQL para obtener más información al respecto.
Conectándose y desconectándose al servidor MySQL
Para conectarse al servidor, usualmente necesitamos de un nombre de usuario (login) y de

una contraseña (password), y si el servidor al que nos deseamos conectar está en una
máquina diferente de la nuestra, también necesitamos indicar el nombre o la dirección 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 también la contraseña
para el nombre de usuario que estamos usando.
Si la conexión 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

12
mysql>
Este prompt nos indica que mysql está listo para recibir comandos.
Algunas instalaciones permiten que los usuarios se conecten de manera anónima al servidor
corriendo en la máquina local. Si es el caso de nuestra máquina, debemos de ser capaces de
conectarnos al servidor invocando a mysql sin ninguna opción:
shell> mysql
Después de que nos hemos conectado de manera satisfactoria, podemos desconectarnos en

cualquier momento al escribir "quit", "exit", o presionar CONTROL+D.
La mayoría 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 instalación 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, aún cuando
no hemos seleccionado alguna base de datos para trabajar. Lo que haremos a continuación
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 |
+-----------+--------------+
13
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.

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 más 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 expresión (como en el ejemplo anterior) las etiquetas en las columnas son la expresión
en sí.
mysql muestra cuántas 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
comunicación en una red.
Las palabras clave pueden ser escritas usando mayúsculas y minúsculas.
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
matemáticas y trigonométricas:
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 sóla línea, es posible
escribir más de una sentencia por línea, siempre y cuando estén separadas por punto y
coma:
14
mysql> SELECT VERSION(); SELECT NOW();
+-----------+
| VERSION() |
+-----------+
| 3.23.41 |
+-----------+
+---------------------+
| NOW() |
+---------------------+
| 2002-10-28 14:26:04 |
+---------------------+
Un comando no necesita ser escrito en una sóla línea, así que los comandos que requieran
de varias líneas no son un problema. mysql determinará en donde finaliza la sentencia
cuando encuentre el punto y coma, no cuando encuentre el fin de línea.
Aquí está un ejemplo que muestra un consulta simple escrita en varias líneas:
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 líneas. Esta es la manera en cómo 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:
15
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 descripción de su significado para mysql:
Prompt Significado
mysql> Listo para una nueva consulta.
-> Esperando la línea siguiente de una consulta multi-línea.
Esperando la siguiente línea para completar una cadena que comienza con una
'>
comilla sencilla (').
Esperando la siguiente línea para completar una cadena que comienza con una
">
comilla doble (").
Los comandos multi-línea comúnmente 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 |
+----------------+

16
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 múltiple líneas. 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 más
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,
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 más 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 después \c :
mysql> SELECT * FROM mi_tabla WHERE nombre = "Juan AND edad < 30;
"> " \c
mysql>
El prompt cambiará de nuevo al ya conocido mysql>, indicándonos que mysql está listo para
una nueva consulta.
Es sumamente importante conocer lo que significan los prompts '> y ">, ya que si en algún
momento nos aparece alguno de ellos, todas la líneas que escribamos a continuación serán
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 después algún otro comando, o terminar
la consulta que deseamos ejecutar.
17
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 pequeño zoológico) y

deseamos tener registros de los datos acerca de ellas. Podemos hacer esto al crear tablas
que guarden esta información, para que posteriormente la consulta de estos datos sea
bastante fácil y de manera muy práctica. Esta sección 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 "zoológico" será muy simple (deliveradamente), pero no es difícil pensar de
situaciones del mundo real en la cual una base de datos similar puede ser usada.
Primeramente usaremos la sentencia SHOW para ver cuáles son las bases de datos
existentes en el servidor al que estamos conectados:
mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| mysql |
| 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" estarán entre ellas. En particular, la base de
datos "mysql" es requerida, ya que ésta tiene la información de los privilegios de los usuarios
de MySQL. La base de datos "test" es creada durante la instalación de MySQL con el
propósito de servir como área de trabajo para los usuarios que inician en el aprendizaje de
MySQL.
Se debe anotar también que es posible que no veamos todas las bases de datos si no
tenemos el privilegio SHOW DATABASES. Se recomienda revisar la sección 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

18
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 ningún problema. El comando USE es especial también de otra manera:
éste debe ser usado en una sóla línea.
Podríamos usar la base de datos "test" (si tenemos acceso a ella) para los ejemplos que
vienen a continuación, pero cualquier cosa que hagamos puede ser eliminada por cualquier
otro usuario que tenga acceso a esta base de datos. Por esta razón, 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" (nótese que no se
está acentuando la palabra) a la cual sólo nosotros tengamos acceso, para ello el
administrador necesita ejecutar un comando como el siguiente:
mysql> GRANT ALL on zoologico.* TO MiNombreUsuario@MiComputadora

->IDENTIFIED BY 'MiContraseña';
en donde MiNombreUsuario es el nombre de usuario asignado dentro del contexto de

MySQL, MiComputadora es el nombre o la dirección IP de la computadora desde la que nos
conectamos al servidor MySQL, y MiContraseña es la contraseña que se nos ha asignado,
igualmente, dentro del ambiente de MySQL exclusivamente. Ambos, nombre de usuario y
contraseña no tienen nada que ver con el nombre de usuario y contraseña 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:
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
mayúsculas y minúsculas (no como las palabras clave de SQL), por lo tanto debemos de
19
tener cuidado de escribir correctamente el nombre de la base de datos. Esto es cierto

también para los nombres de las tablas.
Al crear una base de datos no se selecciona ésta de manera autómatica; debemos hacerlo de
manera explícita, por ello usamos el comando USE en el ejemplo anterior.
La base de datos se crea sólo una vez, pero nosotros debemos seleccionarla cada vez que
iniciamos una sesión 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 contraseña que se está proporcionando desde la línea de

comandos, sino el nombre de la base de datos a la que deseamos acceder. Si deseamos
proporcionar la contraseña en la línea de comandos después de la opción "-p", debemos de
hacerlo sin dejar espacios (por ejemplo, -phola123, no como -p hola123). Sin embargo,
escribir nuestra contraseña desde la línea de comandos no es recomendado, ya que es
bastante inseguro.
Crear una tabla
Crear la base de datos es la parte más fácil, pero en este momento la base de datos está
vacía, como lo indica el comando SHOW TABLES:
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 estarán 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 información. Por ejemplo, si más de una persona en
nuestra familia tiene una mascota, es probable que tengamos que guardar la información

20
acerca de quien es el dueño de cada mascota. Así mismo, también sería interesante contar
con alguna información más descriptiva tal como la especie, y el sexo de cada mascota.
¿Y que sucede con la edad?. Esto puede ser también de interés, 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 ningún 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
cumpleaños próximo de nuestras mascotas. Podemos calcular la edad en relación a otras
fechas que la fecha actual. Por ejemplo, si almacenamos la fecha en que murió nuestra
mascota en la base de datos, es fácil calcular que edad tenía nuestro animalito cuando
falleció. Es probable que estemos pensando en otro tipo de información que sería igualmente
útil en la tabla "mascotas", pero para nosotros será suficiente por ahora contar con
información de nombre, propietario, especie, nacimiento y fallecimiento.
Usaremos la sentencia CREATE TABLE para indicar como estarán 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 elección para los campos nombre, propietario, y especie, ya que los
valores que almacenarán 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 más adecuado. Si resulta que la elección de la longitud de
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 más simple la primera opción.
El uso del tipo de dato DATE para los campos nacimiento y fallecimento debe de resultar
obvio.

21
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
Después 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.

22
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 Tomás 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 vacía, la manera más fácil de poblarla es crear un
archivo de texto que contenga un registro por línea 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 línea 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 cuál es el separador de columnas, y el

separador de registros, por default el tabulador es el separador de columnas (campos), y el
salto de línea 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 añadir un registro a la vez, entonces debemos hacer uso de la

sentencia INSERT. En la manera más 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.
mysql> INSERT INTO mascotas

->VALUES('Pelusa','Diana','Hamster','f','2000-03-30',NULL);
23
Notar que los valores de cadenas y fechas deben estar encerrados entre comillas.
También, 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 más 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 información de una tabla
La sentencia SELECT es usada para obtener la información guardada en una tabla. La forma
general de esta sentencia es:
SELECT LaInformaciónQueDeseamos FROM DeQueTabla WHERE CondiciónASatisfacer
Aquí, LaInformaciónQueDeseamos es la información 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 claúsula WHERE es opcional.
Si está presente, la CondiciónASatisfacer especifica las condiciones que los registros deben
satisfacer para que puedan ser mostrados.
Seleccionando todos los datos
La manera más 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 | Tomás | 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 están todos los registros después 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 después de que ha fallecido!. Al revisar un poco el pedigree de Kaiser
encontramos que la fecha correcta de nacimiento es el año 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 opción consiste en corregir sólo el registro erróneo con una sentencia UPDATE:
mysql> UPDATE mascotas SET nacimiento="1989-08-31" WHERE nombre="Kaiser";
Como se mostró anteriormente, es muy fácil recuperar los datos de una tabla completa.
Pero típicamente no deseamos hacer esto, particularmente cuando las tablas son demasiado
grandes. En vez de ello, estaremos más interesados en responder preguntas particulares, en
cuyo caso debemos especificar algunas restricciones para la información que deseamos ver.
Seleccionando registros particulares
Podemos seleccionar sólo registros particulares de una tabla. Por ejemplo, si deseamos
verificar el cambio que hicimos a la fecha de nacimiento de Kaiser, seleccionamos sólo el
registro de Kaiser de la siguiente manera:
mysql> SELECT * FROM mascotas WHERE nombre="Kaiser";
+--------+-------------+---------+------+------------+--------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimento |
+--------+-------------+---------+------+------------+--------------+
+--------+-------------+---------+------+------------+--------------+

25
La salida mostrada confirma que el año ha sido corregido de 1998 a 1989.
La comparación de cadenas es normalmente no sensitiva, así que podemos especificar el

nombre como "kaiser", "KAISER", etc. El resultado de la consulta será el mismo.
Podemos además especificar condiciones sobre cualquier columna, no sólo el "nombre". Por
ejemplo, si deseamos conocer qué mascotas nacieron después del 2000, tendríamos que
usar la columna "nacimiento":
mysql> SELECT * FROM mascotas WHERE nacimiento >= "2000-1-1";
+--------+-------------+-----------+------+------------+---------------+
+--------+-------------+-----------+------+------------+---------------+
| FanFan | Benito | Perro | m | 2000-08-27 | NULL |
+--------+-------------+-----------+------+------------+---------------+
Podemos también 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 lógico AND. Hay también un operador lógico OR:
mysql> SELECT * FROM mascotas WHERE especie = "Ave" OR especie = "Gato";
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+

26
El operador AND y el operador OR pueden ser intercambiados. Si hacemos esto, es buena

idea usar paréntesis para indicar como deben ser agrupadas las condiciones:
mysql> SELECT * FROM mascotas WHERE (especie = "Gato" AND sexo = "m")
->OR (especie = "Perro" AND sexo = "f");
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
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 separándolas 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 quién tiene alguna mascota, usaremos la siguiente consulta:
mysql> SELECT propietario FROM mascotas;
+-------------+
| propietario |
+-------------+
| Arnoldo |
| Juan |

27
| Arnoldo |
| Benito |
| Diana |
| Omar |
| Tomás |
| Benito |
| Diana |
+-------------+
Sin embargo, debemos notar que la consulta recupera el nombre del propietario de cada
mascota, y algunos de ellos aparecen más de una vez. Para minimizar la salida, agregaremos
la palabra clave DISTINCT:
mysql> SELECT DISTINCT propietario FROM mascotas;
+-------------+
| propietario |
+-------------+
| Arnoldo |
| Juan |
| Benito |
| Diana |
| Omar |
| Tomás |
+-------------+
Se puede usar también una claúsula WHERE para combinar selección de filas con selección
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

28
Se debe notar en los ejemplos anteriores que las filas regresadas son mostradas sin ningún
orden en particular. Sin embargo, frecuentemente es más fácil examinar la salida de una
consulta cuando las filas son ordenadas en alguna forma útil. Para ordenar los resultados,
tenemos que usar una cláusula 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 |
| 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 mayúsculas y minúsculas. 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 |
+--------+------------+

29
Podemos ordenar múltiples columnas. Por ejemplo, para ordenar por tipo de animal, y poner
al inicio los animalitos más pequeños 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 |
+--------+-----------+------------+
Notar que la palabra clave DESC aplica sólo a la columna nombrada que le precede.
Cálculos con fechas
MySQL proporciona diversas funciones que se pueden usar para efectuar cálculos sobre
fechas, por ejemplo, para calcular edades o extraer partes de una fecha (día, mes, año, etc).
Para determinar la edad de cada una de nuestras mascotas, tenemos que calcular la
diferencia de años 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 |
30
| 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 expresión 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 más útil si
las filas son presentadas en algún orden. Para ello haremos uso de la cláusula 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 |
| 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 cláusula
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 |
31
| 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 tenía una mascota
cuando falleció. Para determinar que animalitos ya fallecieron, la condición 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 más a detalle posteriormente.
¿Qué sucede si deseamos conocer cuáles de nuestras mascotas cumplen años el próximo
mes? Para este tipo de cálculos, el año y el día son irrelevantes; simplemente tenemos que
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 función 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 función 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 |
+--------+------------+-------------------+
32
Encontrar los animalitos cuyo cumpleaños es el próximo 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 complicación si el mes actual es Diciembre. No podemos
simplemente agregar uno al número 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
cuál sea el mes actual. La función DATE_ADD( ) nos permite agregar un intervalo de tiempo
a una fecha dada. Si agregamos un mes al valor regresado por la función NOW( ), y
entonces extraemos el valor del mes con la función MONTH( ), el resultado es que siempre
obtendremos el mes siguiente.
La consulta que resuelve nuestro problema queda así:
mysql> SELECT nombre, nacimiento FROM mascotas

-> 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 comparación tales como =, > o <.
Para probar esto ejecutemos la siguiente consulta:
mysql> SELECT 1 = NULL, 1 <> NULL, 1 < NULL, 1 > NULL;
+----------+-----------+----------+----------+
33
| 1 = NULL | 1 <> NULL | 1 < NULL | 1 > NULL |

+----------+-----------+----------+----------+
| NULL | NULL | NULL | NULL |
+----------+-----------+----------+----------+
Claramente observamos que no obtenemos resultados con algún 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, aún cuando
se use la cláusula DESC.
Coincidencia de patrones
MySQL proporciona métodos de coincidencia de patrones basados en SQL estándar, así

como también basados en expresiones regulares, de manera similar a las utilerías de Unix
tales como vi, grep y sed.
La coincidencia de patrones basada en SQL nos permite usar _ (guión bajo) para un solo
caracter y % para un arbitrario número de caracteres. En MySQL, los patrones SQL no son
sensibles al uso de mayúsculas y minúsculas.
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 continuación se presentan algunos ejemplos.
Para encontrar los nombres que comienzan con b:
mysql> SELECT * FROM mascotas WHERE nombre LIKE "b%";
+--------+-------------+---------+------+------------+---------------+

34
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
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 cuáles son sinónimos).
Algunas características de las expresiones regulares son:
• El caracter punto (.) coincide con cualquier caracter.
• Una clase de caracteres [...] coincide con cualquier caracter dentro de los paréntesis
cuadrados. Por ejemplo, [abc] coincide con a, b o c. Para nombrar un rango de
caracteres, se usa el guión. [a-z] coincide con cualquier letra minúscula, mientras que
[0-9] coincide con cualquier digito.

35
• El caracter asterisco (*) coincide con cero o más instancias de lo que le preceda. Por
ejemplo, x* coincide con cualquier número de caracteres x, [0-9]* coincide con
cualquier número de digitos, y .* (punto asterisco) coincide con cualquier cosa.
• El patrón 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 versión 3.23.4 de MySQL, el operador REGEXP era sensible al uso de mayúsculas
y minúsculas, así que dependiendo de la versión de MySQL con la que se está trabajando
puede que obtengamos o no algún resultado en la consulta anterior. Se puede usar también
la siguiente consulta para buscar los nombres que inician con la letra b, no importando si es
mayúscula o minúscula.
mysql> SELECT * FROM mascotas WHERE nombre REGEXP "^[bB]";
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
Desde la versión 3.23.4, para forzar que el operador REGEXP sea sensible al uso de
mayúsculas y minúsculas, 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";


36
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 sería:
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 cuántas mascotas tenemos, o cuántas mascotas tiene cada uno de los propietarios.
Contar el número total de animalitos que tenemos es lo mismo que hacer la siguiente
pregunta "¿Cuántas filas hay en la tabla mascotas?" ya que hay un registro por mascota. La
función COUNT( ) es la que nos ayuda en esta situación.
mysql> SELECT COUNT(*) FROM mascotas;

37
+----------+
| COUNT(*) |
+----------+
| 9 |
+----------+
Si deseamos conocer cuántas 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 |
| Tomás | 1 |
+-------------+----------+
Se debe notar que se ha usado una cláusula 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 función COUNT( ) en conjunto con la cláusula GROUP BY es muy útil
en diversas situaciones. A continuación se muestran algunos ejemplos.
El número 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 |
38
+-----------+----------+
El número de animalitos por sexo:
mysql> SELECT sexo, COUNT(*) FROM mascotas GROUP BY sexo;
+------+----------+
| sexo | COUNT(*) |
+------+----------+
| NULL | 1 |
| f | 4 |
| m | 4 |
+------+----------+
El número de animalitos por combinación 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 función
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 |
39
| Perro | f | 1 |
| Perro | m | 2 |
+---------+------+----------+
O bien, si deseamos el número de animalitos por sexo, y cuyo sexo es conocido:
mysql> SELECT especie, sexo, COUNT(*) FROM mascotas

-> WHERE sexo IS NOT NULL
-> 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 más 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 algún otro tipo de información acerca
de ellos, tal como los eventos en sus vidas -visitas al veterinario, nacimientos de una
camada, etc- necesitaremos de otra tabla. ¿Cómo deberá estar conformada esta tabla?. Lo
que necesitamos es:
• El nombre de la mascota para saber a cuál de ellas se refiere el evento.

• Una fecha para saber cuando ocurrió el evento.
• Una descripción 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));

40
De manera similar a la tabla mascotas, es más fácil cargar los datos de los registros iniciales
al crear un archivo de texto delimitado por tabuladores en el que se tenga la siguiente
información: nombre fecha tipo descripción
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 cumpleaños Primera vez que se enfermo de la panza
FanFan 2002-08-03 veterinario Dolor de panza
Whicho 2001-02-09 cumpleaños Remodelación de casa
Cargamos los datos en este archivo con la siguiente sentencia:
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 ejecución 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:

41
• La cláusula FROM lista dos tablas dado que la consulta necesita información que se
encuentra en ambas tablas.
• Cuando se combina (junta o join) información de múltiples 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 cláusula 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
cuál de las columnas nos referimos. Esto se hace al anteponer el nombre de la tabla
al nombre de la columna.
Nota: La función TO_DAYS( ) regresa el número de días transcurridos desde el año 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 sería la siguiente:
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 pequeño script, y posteriormente se

está ejecutando dicho script. Al ejecutar las sentencias y comandos que se encuentran en el
42
script, es posible que suceda algún error. Si se desea que se continuen ejecutando las demás
sentencias, a pesar de que haya ocurrido un error, se tiene que usar la opción --force
shell> mysql --force < archivo-batch
Así mismo, es posible especificar los parámetros de conexión desde la línea 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 número de consultas frecuentemente (cada día, 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 líneas, los scripts ayudan bastante para que no se tengan que
escribir todas las líneas nuevamente si se comete algún error.
En Linux, si se están 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 también 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 (más 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:

43
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 opción -t.
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

44
3-4 Funciones PHP de acceso a MySQL
En esta lección 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 más 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 número de filas afectado en el último SELECT, UPDATE o

DELETE (consulta en el servidor asociado con el identificador de conexión especificado). Si
no se especifica un identificador de conexión, se asume le de la última conexión abierta.
Esta orden no es eficaz para las instrucciones SELECT, sólo en instrucciones que modifican
archivos. Para recuperar el número 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 conexión a la base de datos MySQL asociada al idenficador de conexión

especificado. Si no se e especifica un identificador de conexión, se asume le de la última
conexión abierta.
Note que esta función no es normalmente necesaria en conexiones no-persistentes

(abiertas con mysql_connect()) ya que ésta se cerrará automáticamente al final de la
ejecución del script o página. La función mysql_close no cierra una conexión 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 conexión, o FALSE en caso de error.
sql_connect establece una conexión a un servidor de MySQL. Todos los argumentos son
optativos, y si no se especifican, los valores por defecto son ('localhost', nombre del usuario
45
que posee el proceso del servidor, la contraseña vacía). La cadena hostname también puede
incluir un número del puerto, "hostname:port".
En caso de realizar una segunda llamada a mysql_connect con los mismos argumentos, no
se establecerá ninguna nueva conexión, sino se devolverá el identificador de conexión de la
ya existente.
La conexión al servidor se cerrará en cuanto la ejecución del script acabe, a menos que la
cerremos antes con la función mysql_close.
Ver también: mysql_pconnect y mysql_close.
mysql_create_db
int mysql_create_db(string database name, int [link_identifier] );
La función mysql_create_db intenta crear una nueva base de datos en el servidor asociado
con el identificado de conexión especificado.
Ver también: 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 función mysql_data_seek mueve el puntero que indica la fila actual al número de fila de la
consulta que indica el identificador. La próxima llamada al mysql_fetch_row o
mysql_fetch_array devolvería esa fila.
mysql_dbname
string mysql_dbname(string result, int i);
mysql_dbname devuelve el nombre de la base de datos guardado en posición i de los

resultados del indicador de consulta devuelto por la función del mysql_list_dbs. La función
del mysql_num_rows puede usarse para determinar cuántos nombres de bases de datos
están disponibles.
mysql_db_query
int mysql_db_query(string database, string query, int link_identifier);
Devuelve: un identificador de conexión, o FALSE en caso de error.
Ejecuta una consulta en una base de datos. Si el identificador no se especifica, la función

intenta encontrar una conexión abierta con el servidor. Si no encuentra una conexión,
intentará crear una (similar a mysql_connect( ) sin argumentos).
46
Ver también mysql_connect.
mysql_drop_db
int mysql_drop_db(string database_name, int [link_identifier] );
Devuelve: TRUE si toda ha ido bien, y FALSE en caso de error.
Elimina una base de datos del servidor asociado al identificador de conexión.

Ver también: mysql_create_db
mysql_errno
int mysql_errno();
Devuelve el número de error asociado a la última operación realizada.
Ver también: mysql_error
mysql_error
string mysql_error();
Devuelve el texto asociado al error producido en la última operación 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 también: mysql_errno
mysql_fetch_array
array mysql_fetch_array(int result);
Devuelve un array con la información correspondiente al resultado de una consulta

especificado por su identificador o 'false' si ya no hay más filas.

47
Es una versión extendida de mysql_fetch_row (). Además de almacenar los datos a través de
índices numéricos del array, también lo hace a través de índices asociativos, utilizando los
nombres de los campos como claves.
Si dos o más 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);
$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 información de los campos que componen un resultado
de una consulta. Si no se especifica 'offset', devuelve información sobre el siguiente campo
que todavía 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 máxima 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 restricción de unicidad
• multiple_key - 1 si el campo no tiene rest
• multiple_key - 1 si el campo no tiene restricción de unicidad
• numeric - 1 si el campo es numérico
• 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 también: mysql_field_seek
mysql_fetch_lengths
48
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 también: mysql_fetch_row.
mysql_fetch_object
int mysql_fetch_object(int result);
Devuelve: un objeto o FALSE en caso de error.
Esta función 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, sólo se puede acceder a los
datos a través de los nombres de sus campos. La velocidad de ejecución es idéntica a la de
mysql_fetch_array. Para referenciar el valor de un campo debemos utilizar el operador
típicos de los objetos (->).
Ver también: 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 también: 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);

49
Mueve el puntero del campo actual hacia delante, las posiciones indicadas por 'offset'.
Ver también: 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
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);
Sólo debería ser utilizada si la cantidad de memoria utilizada para almacenar el resultado de
una consulta es muy grande. Cuando se ejecuta esta función, toda la memoria asociada al
resultado se libera.
mysql_insert_id
int mysql_insert_id(void);
50
Esta función devuelve el ID (identificador) generado para los campos autonuméricos

(AUTO_INCREMENT). El ID devuelto es el correspondiente al de la última operación INSERT.
mysql_list_fields
int mysql_list_fields(string database, string tablename);
Devuelve información 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 función mysql_dbname( ).
mysql_list_tables
int mysql_list_tables(string database, int [link_identifier]);
Devuelve un identificar, el cual pasaremos a la función 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 número de campos de una consulta.

Ver también: mysql_db_query, mysql_query, mysql_fetch_field, mysql_num_rows.
mysql_num_rows
int mysql_num_rows(string result);
Devuelve el número de filas del resultado de una consulta.
Ver también: mysql_db_query, mysql_query and, mysql_fetch_row.query, mysql_query,

mysql_fetch_row.
mysql_pconnect
51
int mysql_pconnect(string [hostname] , string [username] , string [password] );
Devuelve un identificador de conexión persistente o 'falso' en caso de error. Las diferencias

con respecto a mysql_connect( ) son:
Primero, la función intenta encontrar una conexión persistente que ya esté abierta con la
misma máquina, usuario y password. Si es encontrada, devuelve el identificador de la
misma, en lugar de crear una nueva conexión.
Segundo, la conexión al servidor SQL no será cerrada cuando finalice la ejecución del script,
sino que permanece abierta para un uso posterior.
La función mysql_close no cierra una conexión abierta con mysql_pconnect. Las conexiones
abierta con esta función 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

conexión. Si no se especifica, se utiliza la última conexión abierta. Si no hay conexiones
abiertas la función intenta establecer una.
Esta función devuelve TRUE o FALSE para indicar si las operaciones UPDATE, INSERT o
DELETE han tenido éxito. Para la operación SELECT devuelve un nuevo identificador de
resultado o FALSE si hay error.
Ver también: 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 función 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] );

52
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 conexión

se utiliza la última conexión abierta. Si no hay conexiones activas, la función intenta
establecer una. A partir de la llamada a mysql_select_db las llamadas a mysql_query( )
actúan sobre la nueva base de datos activa.
Ver también: mysql_connect, mysql_pconnect, mysql_query
mysql_tablename
string mysql_tablename(int result, int i);
Toma como argumento un puntero devuelto por la función mysql_list_tables( ) y devuelve el

nombre de la tabla asociada al indice i. La función mysql_num_rows( ) puede ser utilizada
para determinar el número 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++;
}
?>

53
3-5 Trabajar con PHP y MySQL
Conectar a MySQL desde PHP
Veremos la tareas básicas 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 descripción de las
tablas contienen la estructura de la información que almacenaremos en ellas. Para lo cual
usaremos en lenguaje de consultas SQL común 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 unívocamente 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 administración 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
instrucción:
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));
Conexión a la base de datos

54
Una vez que tenemos creada la base de datos en nuestro servidor, el siguiente paso es
conectarnos a la misma desde una página PHP. Para ello PHP nos proporciona una serie de
instrucciones para acceder a bases de datos MySQL.
<html>
<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 "Conexión con la base de datos conseguida.<br>";
mysql_close($link); //cierra la conexión

?>
</body>
</html>
Al ejecutar la instrucción mysql_connect creamos un vínculo entre la base de datos y la

pagina PHP, este vínculo será usado posteriormente en las consultas que hagamos a la base
de datos.
Finalmente, una vez que hemos terminado de usar el vínculo con la base de datos, lo
liberaremos con la instrucción mysql_close para que la conexión 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.

55
Para facilitar la programación hemos separado la función de conexión en una librería a parte,
de tal manera que la incluiremos en todas las páginas que accedan a la base de datos.
El contenido del archivo conex.php, que contiene el código de conexión es el siguiente:
<?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;
}
?>
Un ejemplo de código para acceder a la base de datos y listar el contenido de una tabla,
podría 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"]);
}
56
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 instrucción mysql_query hemos hecho una consulta a la base de datos en el

lenguaje de consultas SQL.
Con la instrucción mysql_fetch_array extraemos los datos de la consulta a un array.
Con mysql_free_result liberamos la memoria usada en la consulta.
Con mysql_close cerramos la base de datos.
Inserción 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
página introducirá los datos del formulario en la base de datos.
El siguiente archivo ej8 insertar registros.php contiene el código 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>
57
</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();
?>
<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 código 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);
58
header("Location: ej8 insertar registros.php");

?>
La página ej8 insertar registros.php es un formulario que nos permite introducir nombre y
apellido para añadirlo 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 añadirá los
datos a la tabla.
La segunda página procesar.php se conecta a la base de datos y añade un nuevo registro

con la instrucción insert del lenguaje de base de datos SQL. Una vez que el registro se ha
añadido se vuelve a cargar la página 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 más sencillos. Para indicar que elemento que vamos a borrar hemos
usado un enlace a la página borra.php pasándole el ID_Prueba de cada registro, de esta
manera la página borra.php sabe que elemento de la tabla ha de borrar.
El código 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
59
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 código 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 página borra.php se conecta a la base de datos y borra el registro indicado en la variable

$id que ha sido pasado desde la página ej9 borrar registros.php. Una vez el registro se ha
borrado se vuelve a cargar la página ej9 borrar registros.php.

60
3-6 Administración de MySQL en Windows
Mysqladmin
Es una herramienta que viene con la distribución de MySQL y permite realizar tareas
administrativas en el servidor, algunas que también se pueden realizar con el cliente mysql,
como crear base de datos. Otras tareas son más específicas de manejo de servidor como
modificar variables del servidor, arrancar y detener el servidor, etc. Veamos algunos
ejemplos.
shell> mysqladmin [opciones] comando
Los comandos más 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 versión del servidor
Las opciones más importantes son:
--help: Es la ayuda de Mysqladmin
-u nombre del usuario: Para indicar el nombre del usuario

61
-ppaswword: Para indicar la password del usuario
Ejemplos de uso de Mysqladmin:
C:\>appserv\mysql\bin\Mysqladmin –u alumno1 –ppassword create base1
Vemos que debemos indicar el nombre y la clave si lo pide la configuración 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

62
Mysql Control Center

MyCC es una potente consola de Administración para Mysql, que permite realizar todas las
tareas de administración y trabajo de Mysql mediante un interface gráfico, y que viene a
cubrir una de las mayores objeciones que los usuarios tenían de Mysql.
Para Utilizarlo, primero lo tendrás que descargar de Mysql.com. Existen actualmente

versiones disponibles para Linux y para Windows. Para poder trabajar con un servidor de
Mysql, primero lo tendrás que dar de alta mediante el icono de Resgitrar servidor.
Aparece un cuadro de diálogo en el cúal se pueden configurar todos los parámetros de

acesso al servidor, como son nombre del servidor, nombre de usuario, contraseña, puerto
63
etc. Una vez conectado a un servidor se podrá acceder a las tareas de administración de los
usuarios de Mysql, administrador del gestor, y administración de las tablas.
Administrador de Usuarios
Desde el se pueden añadir, borrar y modificar las propiedades de los usuarios de Mysql. Al
hacer click sobre un usuario aparece la ventana de configuración del usuario.

64
En ella se pueden configurar el nombre de usuario, la contraseña. Respecto a los permisos,

permite establecer un sistema de permisos general o individualizado para cada una de las
tablas. Además 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.

65
Administración del servidor
La ventana de Administración del servidor consta de tres pestañas desde la cual se pueden
acceder a la lista de procesos, las variables de estado del servidor y las variables de
configuración.
Desde esta ventana además se puede hacer un Ping al servidor, detenerlo, o guardar el
contenido de las variables de estado. Desde la pestaña de procesos se puede ver el estado
de cada uno de los procesos activos, viendo sus propiedades y con la opción de detenerlos
mediante un Kill. Desde la pestaña 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 pestaña de variables se puede acceder al valor de cada una de las variables de
configuración del servidor de Mysql.
Ventana de Base de Datos
Al seleccionar una base de datos dentro de la sección de bases de datos, aparece la ventana
de base de datos, en ella se puede ver información relacionada con la base de datos, como
puede ser número de tablas, el número 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 número 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 parámetros opcionales de cada uno de ellos.

66
Esta ventana permite crear nuevos campos, eliminarlos o modificar sus propiedades. Además
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 tamaño, si es clave o no, el valor predeterminado del
mismo.

67
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 pestaña 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 tamaño máximo de cada
fila etc.

68
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 utilización ilimitada es gratuita. Dispone de versiones Linux y Windows y se puede
encontrar mucha más información, así como la última versión en la dirección
www.mysql.com/products/mysqlcc/.

69
phpMyAdmin
phpMyAdmin es un programa de libre distribución en PHP, creado por una comunidad sin
ánimo de lucro, que sólo trabaja en el proyecto por amor al arte. Es una herramienta muy
completa que permite acceder a todas las funciones típicas de la base de datos MySQL a
través de una interfaz web muy intuitiva.
La aplicación en si no es más 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 páginas 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 etcétera, incluso ejecutar sentencias
SQL y hacer un backup de la base de datos.
La página de inicio del proyecto es http://www.phpmyadmin.net/. Desde allí podemos

descargar los archivos de la última versión de la aplicación, que posteriormente debemos
colocar en nuestro servidor web. También podemos encontrar a phpMyAdmin dentro de la
red Sourceforge.net, que es un sitio que recoge multitud de proyectos "Open Source"
(código abierto).
Hay varias versiones disponibles, pero es recomendable escoger la que nos aconsejen como
la última versión estable (The last stable versión).
Instalar phpMyAdmin
Una vez descargada la última versión la tenemos que descomprimir, con lo que obtendremos
los archivos PHP que conforman la herramienta y colocarlos dentro del directorio de
publicación 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 programación
de páginas PHP. Además, deberemos acceder a la herramienta a través de la
dirección 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 publicación (Generalmente
C:\Inetpub\wwwroot), en el subdirectorio phpMyAdmin, debemos escribir algo
como http://localhost/phpMyAdmin.
Si tuviéramos instalado un servidor Apache los colocaríamos en la carpeta que

hayamos indicado como "documentRoot", que suele ser htdocs.
Lo primero que podemos leer es el archivo de la documentación, que encontramos junto con
70
los archivos de phpMyAdmin. Explica datos generales del programa, como sus
requerimientos, instrucciones de instalación, configuración, preguntas frecuentes, etc.
Posteriormente, tal como explica la documentación, 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 más simple es copiar el archivo config.default.php que viene
con la distribución con el nombre config.inc.php en el mismo directorio. Luego modificar este
archivo con ela contraseña 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 documentación 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. Podría 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. También podría ser
la dirección IP del computador al que nos conectamos.
71
$cfgServers[$i]['user'] string
$cfgServers[$i]['password'] string
El par usuario/contraseña que debe utilizar phpMyAdmin para conectarse con el servidor
MySQL.
Con estas sencillas configuraciones ya podemos acceder a phpMyAdmin y trabajar con

nuestra base de datos a golpe de ratón, que resulta muy de agradecer teniendo en cuenta
que, en caso de no tener esta herramienta u otra parecida, la otra opción consistiría en
utilizar el lenguaje SQL, y, en caso de que la base de datos esté alojada remotamente en
Internet, no podríamos 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

generación 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 algún archivo
72
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.
La salida de este procedimiento de exportación es el siguiente:
-- phpMyAdmin SQL Dump

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

73
--
-- Estructura de tabla para la tabla èventos`
--
CREATE TABLE èventos` (

`nombre` varchar(20) default NULL,
`fecha` date default NULL,
`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`
74
--
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', 'Tomás', 'Ave', '', '2000-02-09', '0000-00-00');
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

75
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 páginas PHP
podrían acceder a dicha base de datos. Otra aplicación 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 versión de Microsoft Jet:
http://support.microsoft.com/
Una vez se ha hecho esto, hay que descargar la última versión de Myodbc de la página de
Mysql: http://www.mysql.com/downloads/
Cuando ya tenemos todo, instalamos la actualización 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
(Botón Inicio-> Configuración-> Panel de control-> Fuentes de datos ODBC 32 bits).
En este punto, tendrás 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 botón de “Agregar” para añadir una nueva fuente de datos y a
continuación, selecciona el driver de Mysql. Aparecerá la siguiente pantalla:

76
En ella tendrás que rellenar los siguientes campos:
Data Source Name: Nombre de la fuente de datos que estará disponible desde Windows.
Server Nombre o dirección 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.
Password: Contraseña del usuario.
Una vez están estas opciones configuradas, se puede hacer clic en "OK" para cerrar las
ventanas.

77
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 algún momento. A continuación explicamos cómo recuperar
información 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 opción 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 configuración del driver por si deseas marcar para esta
acción en concreto, algunas de las opciones de configuración 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:

78
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 algún proveedor de Hosting, tenemos que tener en cuenta que
estos no siempre incluyen en su paquete básico el acceso remoto al servidor de
base de datos, o requiere de un aviso explicito por parte del cliente para su
configuración.

79
Exportar datos de Access 2000 a MySQL
Para exportar una tabla a Mysql, hay que abrir la base de datos y seleccionar la tabla.
Después, hacer clic sobre Archivo->Exportar. En la pantalla de exportar, en la opción
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 configuración del driver por si deseas marcar para esta acción en
concreto algunas de las opciones de configuración que aparecen en el driver ODBC. Si no
deseas marcar ninguna, haz clic sobre "OK" y los datos comenzarán a exportarse.
80
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 gráfico que satisfaga a la mayor parte de los usuarios. Existen magníficos proyectos
a través de página Web, como PHPmysqlAdmin o Mycc, pero muchas veces te encuentras
con gente que le gustaría 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 día ninguna herramienta parecida al Access para trabajar con
Mysql, el presente artículo expondrá la forma de trabajar con las bases de datos de Mysql
utilizando el entorno gráfico de Access. Al terminarlo, podrás 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 página, podrá trabajar desde
Access, con la comodidad de los formularios, los menús desplegables etc., y los datos serán
enviados automáticamente a Mysql. En la siguiente figura se muestra un reporte que podría
obtenerse con Access.
Formulario de Access que accede a una base de datos MySQL

81
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 vincularán las tablas. Una vez creada, se hace
clic sobre la opción de crear nueva tabla. Aparecerá la siguiente ventana en la que se
seleccionará crear nueva tabla vinculada:
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 pestaña de fuentes de datos del Equipo, la fuente de datos que
creamos para este fin:

82
Una vez se selecciona, se hace clic sobre Aceptar, y aparece la ventana de configuración 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.
Se seleccionan las tablas, y a continuación aparecerá una ventana donde deberemos

especificar los campos que forman parte de la clave.

83
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 físicamente dentro del archivo de Access, sino que todas las
modificaciones que se realizan sobre la misma, se envían a través de ODBC al archivo
MYSQL.
A partir de ahora, se podrán crear formularios, consultas e informes sobre esta tabla tal y
como se hace normalmente desde Access.

84
3-8 Copias de seguridad en MySQL

El gestor de Bases de datos MySQL incluye varias herramientas para la realización 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 estén 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
deberán 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 modificación 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".
Además 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 podría utilizar alguna herramienta comercial que gestione todo el
proceso, esto tiene como ventaja la simplicidad del método, y como inconveniente,
que no suelen ser gratis, sino que hay que pagar licencia por la utilización de los
mismos. Estas herramientas no se cubrirán en este reportaje.
• En segundo lugar, y a partir de la versión 3.23.25 y posteriores, existe la posibilidad
de realizar una copia de seguridad a través de la sentencia sql "backup table".
• Como tercera opción, es posible realizar copias de seguridad a través de las
herramientas que nos proporciona el propio gestor de base de datos, como pueden
ser mysqldump ó mysqlhotcopy.

85
Backup MySQL mediante Sentencias Sql
Veremos cómo realizar una copia de seguridad de la tabla y su recuperación 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 definición 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 ejecución 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, según va haciendo la copia de seguridad. Esto podría 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 habría 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 operación
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 pedidos, a la carpeta Backups:
mysql> BACKUP TABLE mascotas TO 'c:/appserv/mysql/backups';

+-------------------------+---------+------------+------------+
| Table | Op | Msg_type | Msg_text |
+-------------------------+---------+------------+------------+
| alumno1.mascotas | backup | status | OK |
+-------------------------+---------+------------+------------+
Recuperación de datos
Para complementar la sentencia "Backup table", Mysql dispone de la sentencia "Restore

86
table", que permite restaurar una tabla a partir de una copia de seguridad que se ha
realizado con el comando "Backup Table".
Esta opción solo se puede utilizar si la tabla que se pretende restaurar no se encuentra en la
base de datos, ya que en caso afirmativo mostrará un mensaje de error. Al igual que el
comando de Backup, esta opción sólo esta disponible para las tablas de tipo MyIsam, y a
partir de la versión 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 información:
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 operación
Para restaurar una tabla llamada pedidos 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 |
+-----------------------+---------+-------------+------------+

87
Backup MySQL con mysqldump
Este comando permite hacer la copia de seguridad de una o múltiples bases de datos.
Además 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 creación 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 más conveniente para el propósito 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 línea de comandos de mysql, o desde la
pantalla de ejecución de sentencias sql de cualquier entorno gráfico como puede ser el Mysql
Control Center.
Las limitaciones de la restauración dependerán de las opciones que se han especificado a la

hora de hacer la copia de seguridad, por ejemplo, si se incluye la opción --add-drop-table al
hacer la copia de seguridad, se podrán restauran tablas que existen actualmente en el
servidor (borrándolas primero). Por lo que es necesario estudiar primero los procedimientos
que se utilizarán tanto en la copia como en la restauración, para que todo salga correcto!
Algunas de las opciones que tiene son:
--add-locks
Añade LOCK TABLES antes, y UNLOCK TABLE después de la copia de cada tabla.
--add-drop-table
Añade 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 creación específicas de Mysql.
--allow-keywords
Permite la creación 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
tamaño del archivo)

88
-C, --compress
Comprime la información entre el cliente y el servidor, si ambos soportan compresión.
-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 multilínea. (Proporciona sentencias de insert más compactas y
rápidas.)
-#, --debug[=option_string]
Utilización de la traza del programa (para depuración).
--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 opción -T y tienen el mismo significado que la
correspondiente cláusula LOAD DATA INFILE.
-F, --flush-logs
Escribe en disco todos los logs antes de comenzar con la copia
-f, --force,
Continúa 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 múltiples bases de datos, --lock-tables bloqueará la copia de cada base de datos
por separado. De forma que esta opción no garantiza que las tablas serán consistentes
lógicamente entre distintas bases de datos. Las tablas en diferentes bases de datos se
copiarán en estados completamente distintos.
89
-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 más rápido debido a que los índices se crearán después de que todos los datos
hayan sido restaurados.
-n, --no-create-db
No se incluirá en la salida CREATE DATABASE /*!32312 IF NOT EXISTS*/ db_name; Esta
línea se incluye si la opción --databases o --all-databases fue seleccionada.
-t, --no-create-info
No incluirá la información de creación de la tabla (sentencia CREATE TABLE).
-d, --no-data
No incluirá ninguna información sobre los registros de la tabla. Esta opción sirve para crear
una copia de sólo la estructura de la base de datos.
--opt
Lo mismo que --quick --add-drop-table --add-locks --extended-insert --lock-tables. Esta
opción le debería permitir realizar la copia de seguridad de la base de datos de la forma más
rápida y efectiva.
-pyour_pass, --password[=your_pass]
Contraseña utilizada cuando se conecta con el servidor. Si no se especifica, `=your_pass',
mysqldump preguntará la contraseña.
-P, --port=...
Puerto utilizado para las conexiones TCP/IP
--protocol=(TCP | SOCKET | PIPE | MEMORY)

Especifica el protocolo de conexión 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 opción se debería utilizar en MSDOS,
porque previene la conversión de nueva línea `\n' en nueva línea y retorno de carro`\n\r'.

90
--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 transacción 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 más 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 opción --databases (-B).
-T, --tab=path-to-some-directory
Crea un archivo table_name.sql, que contiene la sentencia de creación 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 opción sólo
funciona si el comando mysqldump se ejecuta en la misma máquina que el demonio mysqld,
el usuario deberá tener permisos para crear y escribir el archivo en la ubicación 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 información sobre las acciones que se van realizando (más lento)
-w, --where='cláusula 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

91
El contenido del archivo copia_seguridad.sql tendrá el siguiente contenido que al ejecutarlo

permitirá la recuperación 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;
--
-- 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`
--

92
/*!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','Tomás','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;
--
-- 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','Tomás','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 */;

93
3-9 Subir una aplicación PHP al servidor

Veremos en que consiste la puesta en marcha de una aplicación, 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 publicación de las páginas web. Ese
sería el lugar donde hay que subir los archivos .php.
Dependiendo del proveedor con el que trabajemos, el directorio de publicación 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.
Además los datos para la conexión, que serán el nombre del servidor y el usuario y
contraseña 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 podría ser el de publicación, 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 conexión FTP. Como decía, 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 publicación, o a cualquier subdirectorio de este.

En definitiva, los tendremos que alojar por ahí dentro y para acceder a ellos bastaría con
escribir el nombre del dominio o URL de nuestro alojamiento, seguido del nombre del
archivo. Si tuviésemos un archivo llamado hola.php y nuestro alojamiento se ha contratado
para el dominio www.midominio.com, deberíamos subir ese archivo al directorio de
publicación y accederíamos al archivo escribiendo:
http://www.midominio.com/hola.php
Si creamos subdirectorios dentro del directorio de publicación 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, podríamos acceder a él de la siguiente
manera.
http://www.midominio.com/paginas/pag1.php
Referencia: hay otro concepto interesante que deberíamos conocer llegados a

este punto, que es el "documento por defecto". Éste no es más que el archivo que
se envía al navegador si en la URL accedida no se especificaba ningún archivo.
94
Suele llamarse index.html o index.php (o index.asp si nuestro servidor soporta

programación en ASP), aunque puede variar de un proveedor a otro.
Colocar los archivos PHP fuera del directorio de publicación
Por decir algo más sobre el tema de colocar los archivos, quería señalar que cualquier cosa
que pongamos fuera del directorio de publicación no podrá ser accedida a través del
navegador. Es decir, si creamos un directorio que se llame funciones_php en el mismo nivel
que el directorio de publicación (fuera del directorio de publicación) 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 sería posible salir del directorio de publicación 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 publicación puede ser muy
útil. Por ejemplo, podríamos 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 más interesante sobre colocar archivos fuera del directorio de publicación.
Se trata de que muchas veces utilizamos en nuestros programas trozos de código
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 código (librerías) en un archivo diferente y llamar a este
archivo con las funciones PHP include() o require(). Así, si un día modificamos la cabecera de
nuestro portal, sólo lo tendremos que modificar en un archivo, o, si cambia la base de datos
que utilizamos sólo tendríamos que modificar el archivo que hace la conexión a la base de
datos una vez, en lugar de ir cambiándolo en todas las páginas PHP que abrían las bases de
datos.
Estos archivos no son páginas independientes, sino trozos. Seguramente, si los ejecutamos
por separado no mostrarían ningún resultado válido, incluso podrían dar mensajes de error.
Por esta razón merece la pena colocarlos en un lugar donde nadie pueda tener acceso: fuera
del directorio de publicación. Con PHP si que podremos acceder a ese directorio para incluir
esos archivos. Solamente deberíamos utilizar las funciones PHP include() o require()
indicando la ruta para acceder a los archivos.
En el caso de que tengamos una página llamada hola.php en el directorio de publicación y

95
un archivo, que se llama abre_base_datos.php, en el directorio funciones_php, que está

fuera del directorio de publicación, si quisiéramos acceder (desde hola.php) al archivo que
abre la base de datos lo haríamos así.
include("../funciones_php/abre_base_datos.php")
Desde PHP sí que podemos acceder a los archivos que se encuentran fuera del directorio de
publicación. Para ello especificamos la ruta adecuada, en la que utilizamos el operador ..
para bajar al directorio padre.
Nada más que decir sobre la colocación de los archivos: una vez situados en el directorio de
publicación se podrá acceder a ellos con nuestro navegador y se deberían ejecutar
perfectamente.
Cabe señalar que, tanto PHP como el servidor donde trabajemos, pueden tener
configuraciones distintas y puede que algún detalle de la programación de nuestras páginas
no funcione correctamente.
Por ejemplo, nuestro PHP puede declarar o no automáticamente las variables que llegan a
través de un formulario. Si en local estaba configurado para hacer esto y en remoto no,
deberíamos 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 página, 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 también 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
código PHP.
Para subirla tendremos que utilizar otros mecanismos. Voy a distinguir entre tres casos
distintos en los que nos podríamos encontrar en este momento:

96
1. La base de datos que pretendemos subir está vacía. Tan sólo hemos creado las
tablas, pero no hemos introducido datos en ellas o, a lo sumo, tienen algún 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 información
dentro y, por supuesto, queremos que esa información quede también en la base de
datos remota.
3. La base de datos está completa (como el caso anterior), pero no es una base de
datos MySQL. En este caso estaríamos haciendo una migración 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 servirán de mucha ayuda para la administración de cualquier
base de datos remota.
PhpMyAdmin. Una aplicación creada en PHP que podemos instalar en nuestro espacio de
alojamiento para administrar la base de datos.
Mysql Control Center (MyCC). Una aplicación Windows que permite conectarse a múltiples
bases de datos MySQL, que se encuentren en local o en remoto.
Access. También 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 administración 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 elección de una herramienta o de otra pasa por los recursos que nos permitan utilizar en
nuestro proveedor. Básicamente, lo que nos puede derivar a una opción 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

aplicación PHP que se conecta en local y a la que se accede desde una página 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 más potentes y rápidas 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.

97
Subir base de datos MySQL vacía al servidor
Es muy normal que hayamos diseñado 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 más probable es que la base de datos esté vacía, o bien contenga datos
que hayamos introducido a modo de prueba y que no queramos conservar cuando subamos
la aplicación a Internet.
La opción más interesante entonces podría ser crear otra vez las tablas que tenemos en
local en la base de datos remota. Para ello tenemos dos posibilidades.
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 recomendación sería 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 más 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 línea de comandos de MS-
DOS.

98

99
Herramienta de backup de PhpMyAdmin. Está marcada la opción de extraer la estructura

de las tablas y los datos. Si marcamos además 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.
Sería un montón 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)
);

100
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
también otro campo para seleccionar un archivo de texto con todas las sentencias SQL, para
ejecutarlas una detrás de otra. En MyCC tenemos un botón 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 información 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 sería muy parecido al de subir una base de datos vacía,
relatado anteriormente, con la salvedad de que ahora debemos extraer no solo la estructura
de la base de datos, sino también los registros que contiene.
Para ello podemos utilizar mysqldump, , o bien PhpMyAdmin, seleccionando la opción que
indica que el backup contenga la estructura y los datos.
La estructura y los datos vendrán 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 vacía, con la ayuda de una instalación 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 más
posibilidades que nosotros para trabajar con las bases de datos, sin temor a que las lentas
comunicaciones por Internet arrojen errores en la restauración de los datos.
Si nuestro proveedor no puede ayudarnos, seguramente disponga y nos indique algún

mecanismo para realizar la tarea sin lugar a errores. Puede ocurrir con algún proveedor que
nos diga que se encarga de todo pero nos exija el pago de las horas de trabajo del
informático 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

101
siempre que vamos a utilizar la base de datos MySQL. En local podríamos disponer de una
base de datos Access, SQL Server o de otro sistema de base de datos.
El proceso de la migración puede ser bastante complejo y, como hay tantas bases de datos
distintas, difícil de dar una receta que funcione en todos los casos. Además, aparte de la
dificultad de transferir la información entre los dos sistemas gestores de base de datos,
también 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 numéricos con decimales o los
booleanos pueden dar problemas al pasar de un sistema a otro porque pueden almacenarse
de maneras distintas o, en el caso de los números, con una precisión distinta.
Recomendaciones para migrar de Access a MySQL
Si nuestra base de datos anterior estaba construida en Access lo tenemos bastante fácil
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 información fácilmente.
Hay que indicar que si deseamos hacer una exportación 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 conexión 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 migración desde Access
en local a MySQL en local y luego podríamos 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 también 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 podríamos realizar el trabajo.
Primero exportando de SQL Server a Acess y luego desde Access a MySQL.
Otras bases de datos u otras técnicas
Si la base de datos origen dispone de un driver ODBC no habrá (en teoría) problema para
conectarla con Access, de manera similar a como se conecta con MySQL. Entonces
podríamos utilizar Access para exportar los datos, porque desde allí se podrían acceder a los
dos sistemas gestores de bases de datos.

102
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 cómo 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.

103

Modulo3 Conectar PHP Con Base de Datos

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Modulo3 Conectar PHP Con Base de Datos

Загружено:

Авторское право:

Доступные форматы

PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos

UNIVERSIDAD TECNOLÓGICA NACIONAL

Secretaria de Extensión Universitaria

Área Tecnológica de Educación Virtual

Coordinador General de Educación Virtual: Magíster Leandro D.

Autor: Ing. Oscar R. Espeche

Módulo 3-Conectar PHP con Base de Datos

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 Administración de MySQL en Windows

3-7 Interconectar con otras bases de datos

3-8 Copias de seguridad en MySQL

3-9 Subir una aplicación PHP al servidor

Autor: Ing. Oscar R. Espeche

3-1 Estructura de MySQL

Teniendo en cuenta la importancia de MySQL en el manejo de datos en un sitio Web,

Suponemos que ya tenemos instalado el servidor mysqld y el cliente mysql. A continuación

CAMPO TIPO POR DEFECTO

El término priv hace referencia a los privilegios de acceso.

CAMPO TIPO POR DEFECTO

CAMPO TIPO POR DEFECTO

He aquí una breve descripción de los diferentes permisos:

• Select_priv: Permite utilizar la sentencia SELECT

• Insert_priv: Permite utilizar la sentencia INSERT

Administración básica de MySQL

mysql> CREATE DATABASE alumno1;

mysql> USE alumno1

Luego vemos las tablas de dicha base.

mysql> SHOW TABLES;

Luego creamos las tabla como en el siguiente ejemplo.

mysql> CREATE TABLE mascotas(

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

mysql> SHOW TABLES;

Vemos la estructura de la tabla.

mysql> describe mascotas;

6 rows in set (0.01 sec)

Crear cuenta de usuarios: Mediante el comando “grant” podemos crear cuentas de

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

Autor: Ing. Oscar R. Espeche

mysql> GRANT ALL PRIVILEGES ON alumno1.* TO 'alumno1'@'localhost'

Autor: Ing. Oscar R. Espeche

3-2 Tipos de Datos de Mysql

Bit ó Bool: un número entero que puede ser 0 ó 1

Decimal, Dec, Numeric: Número en coma flotante desempaquetado. El número se

DateTime: Combinación de fecha y hora. El rango de valores va desde el 1 de enero del

TimeStamp: Combinación de fecha y hora. El rango va desde el 1 de enero de 1970 al año

Autor: Ing. Oscar R. Espeche

Blob y Text: un texto con un máximo de 65535 caracteres.

TinyText y TinyBlob: Columna con una longitud máxima de 255 caracteres.

LongBlob y LongText: un texto con un máximo de caracteres 4.294.967.295. Hay que

Tipo de campo Tamaño de Almacenamiento

Autor: Ing. Oscar R. Espeche

3-3 Trabajar con el cliente mysql

shell> mysql –help

A continuación se describe el proceso completo de creación y uso de una base de datos en

Conectándose y desconectándose al servidor MySQL

Para conectarse al servidor, usualmente necesitamos de un nombre de usuario (login) y de

shell> mysql -h NombreDelServidor -u NombreDeUsuario –p

Si la conexión al servidor MySQL se pudo establecer de manera satisfactoria, recibiremos el

shell>mysql -h casita -u root -p

Enter password: ******

Welcome to the MySQL monitor. Commands end with ; or \g.

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