Académique Documents
Professionnel Documents
Culture Documents
Curso:
PHP, MySQL y E-Commerce
Módulo:
“Conectar PHP con base de datos”
Tutor: Ing. Oscar R. Espeche
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
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
Tabla host
Tabla db
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.
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.
Para poder realizar tareas con dicha base es necesario realizar el siguiente comando para
definir a dicha base como la base por defecto.
Autor: Ing. Oscar R. Espeche
5
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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.
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.
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
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
Autor: Ing. Oscar R. Espeche
8
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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
Tamaño Formato
AñoMesDiaHoraMinutoSegundo
14
aaaammddhhmmss
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
Autor: Ing. Oscar R. Espeche
10
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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.
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:
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.
Cuando ejecutamos este comando, se nos pedirá que proporcionemos también la contraseña
para el nombre de usuario que estamos usando.
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
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
La mayoría de los ejemplos siguientes asume que estamos conectados al servidor, lo cual se
indica con el prompt de mysql.
C:\>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.
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.
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
+-----------+--------------+
| VERSION() | CURRENT_DATE |
+-----------+--------------+
| 3.23.41 | 2002-10-01 |
+-----------+--------------+
Autor: Ing. Oscar R. Espeche
13
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
mysql>
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.
Aquí está otra consulta que demuestra como se pueden escribir algunas expresiones
matemáticas y trigonométricas:
+-------------+---------+
| 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:
Autor: Ing. Oscar R. Espeche
14
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
+-----------+
| 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:
Autor: Ing. Oscar R. Espeche
15
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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:
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:
+----------------+
| USER() |
+----------------+
| root@localhost |
+----------------+
mysql>
Los prompts '> y "> ocurren durante la escritura de cadenas. En mysql podemos escribir
cadenas utilizando comillas sencillas o comillas dobles (por ejemplo, 'hola' y "hola"), y mysql
nos permite escribir cadenas que ocupen 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.
Autor: Ing. Oscar R. Espeche
17
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
Ahora que conocemos como escribir y ejecutar sentencias, es tiempo de accesar a una base
de datos.
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:
+----------+
| 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.
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:
El mensaje anterior indica que la base de datos no ha sido creada, por lo tanto necesitamos
crearla.
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
Autor: Ing. Oscar R. Espeche
19
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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:
Type 'help;' or '\h' for help. Type '\c' to clear the buffer
mysql>
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:
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
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.
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>
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.
Ahora que hemos creado la tabla, la sentencia SHOW TABLES debe producir algo como:
+---------------------+
| Tables_in_zoologico |
+---------------------+
| mascotas |
+---------------------+
mysql>
Para verificar que la tabla fué creada como nosotros esperabamos, usaremos la sentencia
DESCRIBE:
+--------------+-------------+------+-----+---------+-------+
| 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>
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.
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:
Podemos usar la sentencia INSERT para agregar su registro en nuestra base de datos.
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.
La sentencia SELECT es usada para obtener la información guardada en una tabla. La forma
general de esta sentencia es:
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.
La manera más simple de la sentencia SELECT es cuando se recuperan todos los datos de
una tabla:
+--------+-------------+-----------+------+------------+---------------+
| 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 |
+--------+-------------+-----------+------+------------+---------------+
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.
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:
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:
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.
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:
+--------+-------------+---------+------+------------+--------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimento |
+--------+-------------+---------+------+------------+--------------+
| Kaiser | Diana | Perro | m | 1989-08-31 | 1997-07-29 |
+--------+-------------+---------+------+------------+--------------+
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":
+--------+-------------+-----------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+-----------+------+------------+---------------+
| FanFan | Benito | Perro | m | 2000-08-27 | 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 |
+--------+-------------+-----------+------+------------+---------------+
Podemos también combinar condiciones, por ejemplo, para localizar a los perros hembras:
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
La consulta anterior usa el operador lógico AND. Hay también un operador lógico OR:
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Fluffy | Arnoldo | Gato | f | 1999-02-04 | NULL |
| Mau | Juan | Gato | m | 1998-03-17 | NULL |
| Chispa | Omar | Ave | f | 1998-09-11 | NULL |
| Wicho | Tomás | Ave | NULL | 2000-02-09 | NULL |
+--------+-------------+---------+------+------------+---------------+
4 rows in set (0.00 sec)
mysql> SELECT * FROM mascotas WHERE (especie = "Gato" AND sexo = "m")
->OR (especie = "Perro" AND sexo = "f");
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Mau | Juan | Gato | m | 1998-03-17 | NULL |
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
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":
+--------+------------+
| 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 |
+--------+------------+
+-------------+
| propietario |
+-------------+
| Arnoldo |
| Juan |
| 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:
+-------------+
| 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:
+--------+---------+------------+
| nombre | especie | nacimiento |
+--------+---------+------------+
| Fluffy | Gato | 1999-02-04 |
| Mau | Gato | 1998-03-17 |
| Buffy | Perro | 1999-05-13 |
| FanFan | Perro | 2000-08-27 |
| Kaiser | Perro | 1989-08-31 |
+--------+---------+------------+
Ordenando registros
Se debe notar en los ejemplos anteriores que las filas regresadas son mostradas sin 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.
+--------+------------+
| nombre | 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 |
+--------+------------+
Para ordenar en orden inverso, debemos agregar la palabra clave DESC al nombre de la
columna que estamos usando en el ordenamiento:
+--------+------------+
| nombre | nacimiento |
+--------+------------+
| Skim | 2001-04-29 |
| FanFan | 2000-08-27 |
| Pelusa | 2000-03-30 |
| Wicho | 2000-02-09 |
| Buffy | 1999-05-13 |
| Fluffy | 1999-02-04 |
| Chispa | 1998-09-11 |
| Mau | 1998-03-17 |
| Kaiser | 1989-08-31 |
+--------+------------+
Podemos ordenar 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:
+--------+-----------+------------+
| 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.
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.
+--------+------------+--------------+------+
| 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 |
Autor: Ing. Oscar R. Espeche
30
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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.
+--------+------------+--------------+------+
| nombre | nacimiento | CURRENT_DATE | edad |
+--------+------------+--------------+------+
| 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:
+--------+------------+--------------+------+
| nombre | nacimiento | CURRENT_DATE | 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 |
Autor: Ing. Oscar R. Espeche
31
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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.
+--------+------------+---------------+------+
| 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( ).
+--------+------------+-------------------+
| 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 |
+--------+------------+-------------------+
Autor: Ing. Oscar R. Espeche
32
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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).
+--------+------------+
| nombre | nacimiento |
+--------+------------+
| 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.
+----------+-----------+----------+----------+
Autor: Ing. Oscar R. Espeche
33
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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:
+-----------+---------------+
| 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
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.
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Fluffy | Arnoldo | Gato | f | 1999-02-04 | NULL |
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
+--------+-------------+-----------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+-----------+------+------------+---------------+
| Kaiser | Diana | Perro | m | 1989-08-31 | 1997-07-29 |
| Chispa | Omar | Ave | f | 1998-09-11 | NULL |
| Skim | Benito | Serpiente | m | 2001-04-29 | NULL |
| Pelusa | Diana | Hamster | f | 2000-03-30 | NULL |
+--------+-------------+-----------+------+------------+---------------+
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:
• 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.
• 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.
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.
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
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.
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
Para encontrar los nombres que finalizan con la palabra fy, haremos uso del caracter $.
+--------+-------------+---------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+---------+------+------------+---------------+
| Fluffy | Arnoldo | Gato | f | 1999-02-04 | NULL |
| Buffy | Arnoldo | Perro | f | 1999-05-13 | NULL |
+--------+-------------+---------+------+------------+---------------+
Para encontrar los nombres que contienen una letra s, la consulta sería:
+--------+-------------+-----------+------+------------+---------------+
| nombre | propietario | especie | sexo | nacimiento | fallecimiento |
+--------+-------------+-----------+------+------------+---------------+
| Kaiser | Diana | Perro | m | 1989-08-31 | 1997-07-29 |
| Chispa | Omar | Ave | f | 1998-09-11 | NULL |
| Skim | Benito | Serpiente | m | 2001-04-29 | NULL |
| Pelusa | Diana | Hamster | f | 2000-03-30 | NULL |
+--------+-------------+-----------+------+------------+---------------+
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.
+----------+
| COUNT(*) |
+----------+
| 9 |
+----------+
Si deseamos conocer cuántas mascotas tiene cada uno de los propietarios, la consulta es la
siguiente:
+-------------+----------+
| 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:
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.
+-----------+----------+
| especie | COUNT(*) |
+-----------+----------+
| Ave | 2 |
| Gato | 2 |
| Hamster | 1 |
| Perro | 3 |
| Serpiente | 1 |
Autor: Ing. Oscar R. Espeche
38
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
+-----------+----------+
+------+----------+
| sexo | COUNT(*) |
+------+----------+
| NULL | 1 |
| f | 4 |
| m | 4 |
+------+----------+
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:
+---------+------+----------+
| especie | sexo | COUNT(*) |
+---------+------+----------+
| Gato | f | 1 |
| Gato | m | 1 |
Autor: Ing. Oscar R. Espeche
39
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
| Perro | f | 1 |
| Perro | m | 2 |
+---------+------+----------+
+-----------+------+----------+
| especie | sexo | COUNT(*) |
+-----------+------+----------+
| Ave | f | 1 |
| Gato | f | 1 |
| Gato | m | 1 |
| Hamster | f | 1 |
| Perro | f | 1 |
| Perro | m | 2 |
| Serpiente | m | 1 |
+-----------+------+----------+
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:
Dadas estas condiciones, la sentencia para crear la tabla eventos queda de la siguiente
manera:
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
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.
+--------+------+---------------------------------+
| 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 |
+--------+------+---------------------------------+
• 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:
+--------+------+--------+------+---------+
| nombre | sexo | nombre | sexo | especie |
+--------+------+--------+------+---------+
| Fluffy | f | Mau | m | Gato |
| Buffy | f | FanFan | m | Perro |
| Buffy | f | Kaiser | m | Perro |
+--------+------+--------+------+---------+
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:
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
Así mismo, es posible especificar los parámetros de conexión desde la línea de comandos.
Por ejemplo:
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.
Se pueden distribuir los scripts a otras personas para que puedan ejecutar también nuestros
comandos y sentencias.
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.
+-----------+
| especie |
+-----------+
| Gato |
| Perro |
| Ave |
| Serpiente |
+-----------+
especie
Gato
Perro
Ave
Serpiente
+-----------+
| especie |
+-----------+
| Gato |
| Perro |
| Ave |
| Serpiente |
+-----------+
Si queremos evitar que nos pida el password tenemos que indicarlo en el comando de la
siguiente manera:
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
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
mysql_connect
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
Autor: Ing. Oscar R. Espeche
45
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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
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
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
mysql_db_query
mysql_drop_db
mysql_errno
int mysql_errno();
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");
echo mysql_errno().": ".mysql_error()."<BR>";
$conn = mysql_query("SELECT * FROM algunatabla");
echo mysql_errno().": ".mysql_error()."<BR>";
?>
mysql_fetch_array
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.
mysql_fetch_field
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.
mysql_fetch_lengths
Autor: Ing. Oscar R. Espeche
48
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
mysql_fetch_object
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
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.
mysql_field_name
mysql_field_seek
Mueve el puntero del campo actual hacia delante, las posiciones indicadas por 'offset'.
Ver también: mysql_fetch_field.
mysql_field_table
mysql_field_type
mysql_field_flags
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( )
mysql_field_len
mysql_free_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);
Autor: Ing. Oscar R. Espeche
50
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
mysql_list_fields
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
mysql_num_fields
mysql_num_rows
mysql_pconnect
Autor: Ing. Oscar R. Espeche
51
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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
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.
mysql_result
mysql_select_db
mysql_tablename
<?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++;
}
?>
Como ya vimos, el comando para crear una base de datos MySQL es el siguiente:
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.
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.
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>";
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.
Una vez que nos hemos conectado con el servidor de bases de datos, ya podemos realizar
consultas a las tablas de la base de datos.
Para facilitar la 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.
<?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>
<title>Ejemplo de PHP</title>
</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
while($row = mysql_fetch_array($result)) {
printf("<tr><td> %s</td><td> %s </td></tr>",
$row["Nombre"],$row["Apellidos"]);
}
mysql_free_result($result);
Autor: Ing. Oscar R. Espeche
56
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
mysql_close($link);
?>
</table>
</body>
</html>
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.
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>
<title>Ejemplo de PHP</title>
</head>
<body>
<FORM ACTION="procesar.php">
<TABLE>
<TR>
<TD>Nombre:</TD>
<TD><INPUT TYPE="text" NAME="nombre" SIZE="20" MAXLENGTH="30"></TD>
Autor: Ing. Oscar R. Espeche
57
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
</TR>
<TR>
<TD>Apellidos:</TD>
<TD><INPUT TYPE="text" NAME="apellidos" SIZE="20" AXLENGTH="30"></TD>
</TR>
</TABLE>
<hr>
<?php
include("conex.php");
$link=Conectarse();
$result=mysql_query("select * from prueba",$link);
?>
<TABLE BORDER=1 CELLSPACING=1 CELLPADDING=1>
<TR>
<TD> <B>Nombre</B></TD>
<TD> <B>Apellidos</B> </TD>
</TR>
<?php
while($row = mysql_fetch_array($result)) {
printf("<tr><td> %s</td> <td> %s </td></tr>",
row["Nombre"], $row["Apellidos"]);
}
mysql_free_result($result);
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.
<?
include("conex.php");
$link=Conectarse();
mysql_query("insert into prueba (Nombre,Apellidos) values
('$nombre','$apellidos')",$link);
Autor: Ing. Oscar R. Espeche
58
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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.
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>
<title>Ejemplo de PHP</title>
</head>
<body>
<H1>Borrar registros</H1>
<?php
include("conex.php");
$link=Conectarse();
$result=mysql_query("select * from prueba",$link);
?>
<TABLE BORDER=1 CELLSPACING=1 CELLPADDING=1>
<TR><TD> <B>Nombre</B></TD>
<TD> <B>Apellidos</B> </TD>
<TD> <B>Borrar</B> </TD></TR>
<?php
while($row = mysql_fetch_array($result)) {
Autor: Ing. Oscar R. Espeche
59
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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_free_result($result);
mysql_close($link);
?>
</table>
</body>
</html>
<?php
include("conex.php");
$link=Conectarse();
mysql_query("delete from prueba where ID_Prueba = $id",$link);
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.
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.
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.
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.
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.
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.
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/.
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.
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.
Lo primero que podemos leer es el archivo de la documentación, que encontramos junto con
Autor: Ing. Oscar R. Espeche
70
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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.
Autor: Ing. Oscar R. Espeche
71
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
$cfgServers[$i]['user'] string
$cfgServers[$i]['password'] string
El par usuario/contraseña que debe utilizar phpMyAdmin para conectarse con el servidor
MySQL.
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.
-- --------------------------------------------------------
--
-- Estructura de tabla para la tabla `eventos`
--
--
-- Volcar la base de datos para la tabla `eventos`
--
INSERT INTO `eventos` VALUES ('Fluffy', '2001-05-15', 'camada', '4 gatitos 3 hembras 1
macho');
INSERT INTO `eventos` VALUES ('Buffy', '2001-06-23', 'camada', '5 perritos 2 hembras 3
machos');
INSERT INTO `eventos` VALUES ('Buffy', '2002-06-19', 'camada', '2 perritos 1 hembra 1
macho');
INSERT INTO `eventos` VALUES ('Chispa', '2000-03-21', 'veterinario', 'Una pata lastimada');
INSERT INTO `eventos` VALUES ('FanFan', '2001-08-27', 'cumpleanos', 'Primera vez que se
enfermo de la panza');
INSERT INTO `eventos` VALUES ('FanFan', '2002-08-03', 'veterinario', 'Dolor de panza');
INSERT INTO `eventos` VALUES ('Whicho', '2001-02-09', 'cumpleanos', 'Remodelacion de
casa');
-- --------------------------------------------------------
--
-- Estructura de tabla para la tabla `mascotas`
--
--
-- Volcar la base de datos para la tabla `mascotas`
Autor: Ing. Oscar R. Espeche
74
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
--
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`
--
--
-- Volcar la base de datos para la tabla `prueba`
--
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/
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:
Data Source Name: Nombre de la fuente de datos que estará disponible desde Windows.
Database: Nombre de la base de datos con la que se trabajará desde la fuente de datos
Una vez están estas opciones configuradas, se puede hacer clic en "OK" para cerrar las
ventanas.
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().
Aparecerá una ventana donde pregunta qué tabla de Mysql se desea exportar a Access:
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.
Autor: Ing. Oscar R. Espeche
80
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
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.
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:
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:
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.
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.
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.
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.
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:
Recuperación de datos
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:
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.
--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)
-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.
Autor: Ing. Oscar R. Espeche
89
PHP,MySQL y E-COMMERCE Conectar PHP con Base de datos
-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
-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'.
--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)
-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
--
-- Table structure for table `eventos`
--
--
-- Dumping data for table `eventos`
--
--
-- Table structure for table `mascota`
--
--
-- Dumping data for table `mascota`
--
--
-- Table structure for table `mascotas`
--
--
-- Dumping data for table `mascotas`
--
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.
http://www.midominio.com/hola.php
http://www.midominio.com/paginas/pag1.php
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.
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.
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:
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.
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.
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.
Las podemos crear en remoto con alguna herramienta como PhpMyAdmin o MyCC.
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.
Sería un montón de sentencias con esta forma como ya vimos en ejemplos anteriores:
# --------------------------------------------------------
#
# Table structure for table 'comentario'
#
Para restaurar estas sentencias tenemos opciones tanto dentro de PhpMyAdmin como de
MyCC. En ambos casos lo que tenemos que hacer es ejecutar estas sentencias en el servidor
MySQL remoto. En PhpMyAdmin tenemos un campo para introducir sentencias SQL y
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.
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.
El último caso en el que nos podemos encontrar a la hora de subir una base de datos a
nuestro proveedor de alojamiento es que la base de datos la tengamos creada en local, pero
en un sistema gestor distinto del que vamos a utilizar en remoto. En remoto suponemos
siempre que vamos a utilizar la base de datos MySQL. En local 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.
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.
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.
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.
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.