Documentos de Académico
Documentos de Profesional
Documentos de Cultura
PHP MySQL Manual Corto
PHP MySQL Manual Corto
1. Instalando MySQL
Instalar MySQL en su versión para Windows, e ir haciendo pruebas antes de subir nuestras páginas, es bastante sencillo.
En la sección Programas podeis encontrarlo para bajarlo.
Simplemente haced doble click en el programa de instalación, responded a las típicas preguntas de dónde lo quieres
instalar, etc., y ya está.
Ahora hay que ponerlo en marcha. Para ello, siempre debe estar ejecutándose (estará en segundo plano) el programa
mysqld.exe, situado en el subdirectorio bin del directorio en el que se haya instalado el programa. Con este programa en
marcha, ejecutaremos mysql.exe para ver cómo entrar sentencias SQL, o directamente podremos probar scripts PHP que
conecten con el servidor MySQL.
Como PHP lleva soporte interno para MySQL, únicamente hemos de acordarnos de tener en memoria el programa
mysqld.exe, el resto lo hace él solo, como iremos viendo en los siguientes capítulos.
Type 'help;' or '\h' for help. Type '\c' to clear the buffer
mysql> _
Un mensaje de bienvenida, y el prompt del sistema, que ha cambiado por mysql>. Vamos a ver cómo crear una base de
datos. La sintaxis será CREATE DATABASE NombreBD, por ejemplo:
mysql> CREATE DATABASE Prueba;
Query OK, 1 row affected (0.72 sec)
mysql> _
Con esto, acabamos de crear la base de datos Pruebas, que se habrá grabado en el subdirectorio data del programa,
dentro de un directorio llamado como la base de datos, es decir, Pruebas. Podemos ver las bases de datos que existen en
Mysql, sin más que hacer:
mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| Prueba |
| mysql |
| test |
+----------+
3 rows in set (0.55 sec)
mysql> _
Ahora que sabemos qué bases de datos existen (no borreis las otras dos, porque son propias del programa), vamos a
elegir una con la que trabajar, escribiendo esto:
mysql> USE Prueba;
Database changed
mysql> _
Con la base de datos que vamos a usar activa, crearemos una tabla, haciendo esto:
mysql> CREATE TABLE USUARIOS(
-> USUARIO VARCHAR(30) NOT NULL,
-> EMAIL VARCHAR(50) NOT NULL,
-> NOMBRE VARCHAR(20) NOT NULL,
-> APELLIDOS VARCHAR(40) NOT NULL,
-> ICONO INTEGER,
-> PRIMARY KEY(USUARIO));
Query OK, 0 rows affected (0.83 sec)
mysql> _
Por claridad, he escrito cada campo en una línea. Como aún no había escrito el punto y coma terminador de sentencia
SQL, al darle a ENTER él ha puesto la flecha -> y la indentación.
Y ahora que hemos creado la tabla, vamos a borrarla (más que nada porque estamos practicando y hay que ver de todo,
no porque sea la costumbre usual ;-) ). Para ello, haremos:
mysql> DROP TABLE USUARIOS;
Query OK, 0 rows affected (0.11 sec)
mysql> _
Llevad cuidado cuando borreis una tabla, pues no quedará ni rastro de ella, así que luego no podreis recuperar los datos
que hubiera. Hay que estar muy seguro de que se quiere borrar una tabla para hacerlo.
Y, puestos a borrar, vamos a borrar la base de datos (repito, esto no es lo usual cuando uno trabaja con ellas ;-) ), para
lo que haremos:
mysql> DROP DATABASE Prueba;
Query OK, 0 rows affected (0.11 sec)
mysql> _
Hemos borrado la base de datos entre otras cosas porque era un ejemplo y tampoco era demasiado útil O;-)
Vamos a salir del programa, ejecutando exit.
Ya sabemos crear la base de datos, elegirla de entre unas cuantas, crear tablas... insertar registros tampoco será nada
complicado, sin embargo, estaría bien poder pensar cómo será la base de datos, escribir en algún fichero los comandos a
ejecutar, y pasar ese script a MySQL, incluso, con algunas inserciones de registros, si es necesario. Bien, pues de eso es
de lo que vamos a ver ahora un ejemplo.
Con cualquier editor de texto, nos creamos un fichero como este (yo lo he llamado ScriptEjemplo.sql):
CREATE DATABASE REGISTRO;
USE REGISTRO;
mysql> _
Si queremos realizar ahora una consulta, será tan sencillo como escribir lo siguiente:
mysql> SELECT USUARIO FROM USUARIOS;
+---------+
| USUARIO |
+---------+
| MADDY |
+---------+
1 row in set (0.55 sec)
mysql> _
Por último, vamos a ver una acción que nos resultará útil cuando no nos acordemos de cómo estaba definida una tabla,
qué campos tenía, de qué tipo, etc., se trata de SHOW COLUMNS FROM tabla. Lógicamente, para ello debemos tener
seleccionada una base de datos ;-)
mysql> SHOW COLUMNS FROM USUARIOS;
+-----------+-------------+------+-----+---------+-------+---------------------------------+
| Field | Type | Null | Key | Default | Extra | Privileges |
+-----------+-------------+------+-----+---------+-------+---------------------------------+
| USUARIO | varchar(30) | | PRI | | | select,insert,update,references |
| EMAIL | varchar(50) | | | | | select,insert,update,references |
| NOMBRE | varchar(20) | | | | | select,insert,update,references |
| APELLIDOS | varchar(40) | | | | | select,insert,update,references |
| ICONO | int(11) | YES | | NULL | | select,insert,update,references |
+-----------+-------------+------+-----+---------+-------+---------------------------------+
5 rows in set (0.60 sec)
Y aquí tenemos la información que queríamos :-)
Esta función nos devuelve un valor de tipo int que sirve para identificar la conexión con el servidor SQL, así que
podremos asignarlo a una variable con la que referirnos a la conexión abierta.
Por ejemplo, si todos pueden acceder al servidor, abriríamos la conexión haciendo:
$IdConexion = mysql_connect("localhost","","");
Será útil tener los datos en variables (las posteriores modificaciones son así más sencillas), por ejemplo, en las siguientes
líneas guardamos el nombre del servidor, usuario y clave en variables, y abrimos la conexión:
<?php
$Servidor = "localhost";
$Usuario = "Perico";
$Clave = "Palotes";
Por ejemplo, teniendo abierta una conexión cuyo identificador hemos guardado en la variable $IdConexion, para crear
una base de datos cuyo nombre sea "PruebaBD", haremos:
<?php
$NombreBD = "PruebaBD";
mysql_create_db($NombreBD, $IdConexion);
?>
Hay que recordar que borrar una base de datos eliminará toda la información que ésta tuviera, incluida la estructura de
las tablas, no dejando rastro alguno de la base de datos en el servidor.
La función para eliminar una base de datos es:
mysql_drop_db(string NombreBD, int IdConexion);
Por ejemplo, si queremos eliminar la base de datos que acabamos de crear, haríamos:
<?php
mysql_drop_db($NombreBD, $IdConexion);
?>
donde $NombreBD e $IdConexion son las variables que teníamos definidas antes, una con el nombre de la base de datos
y otra con el identificador de la conexión.
Por último, podemos escoger sobre qué base de datos de las existentes queremos trabajar, para ello, usaremos la
función:
mysql_select_db(string NombreBD, int IdConexion);
Por ejemplo, si queremos abrir una base de datos cuyo nombre sea "Usuarios", haremos lo siguiente:
<?php
$NombreBD = "Usuarios";
mysql_select_db($NombreBD, $IdConexion);
?>
siendo $IdConexion el identificador de la conexión abierta.
Dos funciones más que nos van a ser útiles serán las funciones mysql_errno(); y mysql_error();.
mysql_errno(int IdConexion);
Esta función devuelve un número de error que se haya dado al hacer alguna operación sobre una base de datos
MySQL.
mysql_error(int IdConexion);
Esta función devuelve un mensaje de error que se haya dado al hacer alguna operación sobre una base de datos
MySQL.
Veamos un ejemplo de uso:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<HTML>
<HEAD>
<TITLE> Prueba PHP y MySQL </TITLE>
</HEAD>
<BODY BGCOLOR=white>
<?php
$NombreBD = "Registro";
$Servidor = "localhost";
$Usuario = "root";
mysql_select_db($NombreBD, $IdConexion);
</BODY>
</HTML>
El resultado será como el de la imagen:
Dejamos el capítulo en este punto, y en el siguiente ya comenzamos a ver funciones para acceder a los datos de la base
de datos. Entre otras cosas, se explicará la función mysql_query();, que ha aparecido por aquí "por arte de magia" ;-)
4. Consultas
Comenzaremos este capítulo con un script de ejemplo, llamado PruebaBD.phtml:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<HTML>
<HEAD>
<TITLE> Prueba PHP y MySQL </TITLE>
</HEAD>
<BODY BGCOLOR=white>
<?php
$NombreBD = "Registro";
$Servidor = "localhost";
$Usuario = "root";
mysql_select_db($NombreBD, $IdConexion);
$ResultQuery = mysql_fetch_array($IdConsulta);
print("Usuario: ".$ResultQuery["USUARIO"]."<B>");
print("E-mail: ".$ResultQuery[1]."<P>");
?>
</BODY>
</HTML>
En este ejemplo, cuya ejecución podemos observar en la siguiente imagen, se ven varios elementos ya estudiados en el
capítulo anterior, y uno nuevo, que es el que trataremos extensamente en este capítulo.
Podemos ver estas dos líneas de código:
$IdConexion = mysql_connect($Servidor, $Usuario);
[...]
mysql_select_db($NombreBD, $IdConexion);
que, como sabemos, la primera establece la conexión, devolviendo en la variable $IdConexion el identificador de la
conexión para referirnos a ella después, y la segunda elige una base de datos de entre todas las que hay, utilizando el
identificador de conexión devuelto por la primera.
Comenzamos analizando las siguientes dos sentencias:
$Query = 'SELECT USUARIO,EMAIL FROM USUARIOS';
$IdConsulta = mysql_query($Query, $IdConexion);
En primer lugar, introducimos en una variable a la cual llamamos $Query (como podíamos haberla llamado $Consulta o
de otra manera) la consulta que queremos hacer y, en segundo lugar, llamamos a la función mysql_query, a la que le
pasamos la consulta y nos devuelve un identificador de consulta. Veamos más detalladamente su estructura:
mysql_query(string Consulta, int IdConexion);
Como se aprecia en la definición, hemos de pasarle como parámetro obligatorio una cadena en la que debe estar
almacenada la consulta a realizar y, como parámetro opcional, el identificador de la conexión abierta (si no se especifica,
se toma el que esté activo en ese momento). Además, devuelve un identificador de consulta, que podemos almacenar en
una variable para referirnos luego a dicha consulta. Lo que hacemos con esta función es enviar la sentencia SQL al
servidor MySQL para que ésta sea ejecutada.
Una vez hecha la consulta, hay que saber cómo recuperar los datos; esto es lo que hacemos en las siguientes líneas:
$ResultQuery = mysql_fetch_array($IdConsulta);
print("Usuario: ".$ResultQuery["USUARIO"]."<B>");
print("E-mail: ".$ResultQuery[1]."<P>");
Tenemos varias funciones para recuperar los datos de una consulta. Una de ellas es, como vemos en el ejemplo,
mysql_fetch_array();. Esta función devuelve en un array el contenido de la sentencia SELECT, identificando cada
elemento con un campo de la base de datos y avanzando a la siguiente fila. Para ello, debemos pasarle el identificador de
consulta devuelto por mysql_query();. Observamos, además, que como índice podemos especificar tanto su posición
numérica (los arrays van del 0 al N-1, donde N es el número de elementos) como, entre comillas, el nombre del campo.
Si queremos recorrer todas las filas devueltas por el SELECT, tendremos que ir haciendo la asignación fila a fila hasta
que ya no queden filas.
Para saber cuántas filas devuelve un SELECT, tenemos la función mysql_num_rows();. Esta función, cuya definición
vemos:
mysql_num_rows(int IdConsulta);
devuelve un entero, que será el número de filas del SELECT, de la consulta correspondiente al identificador IdConsulta.
Por ejemplo:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<HTML>
<HEAD>
<TITLE> Prueba PHP y MySQL </TITLE>
</HEAD>
<BODY BGCOLOR=white>
<?php
$NombreBD = "Registro";
$Servidor = "localhost";
$Usuario = "root";
$IdConexion = mysql_connect($Servidor, $Usuario);
mysql_select_db($NombreBD, $IdConexion);
$ResultQuery = mysql_fetch_array($IdConsulta);
print("Usuario: ".$ResultQuery["USUARIO"]."<B>");
print("E-mail: ".$ResultQuery[1]."<P>");
$NFilas = mysql_num_rows($IdConsulta);
print("Hay ".$NFilas." filas devueltas en la consulta<P>");
?>
</BODY>
</HTML>
Cuyo resultado es:
Al igual que tenemos mysql_fetch_array();, hay una función que se llama mysql_fetch_row();. Hace lo mismo, pero
con una salvedad, y es que no se puede usar el nombre del campo en el array que devuelve como si fuera una manera de
indexar. Es decir, sólo admite referencias numéricas a los campos de la consulta. Hay que tener en cuenta que el primero
es el 0.
Otras funciones que pueden sernos útiles son:
mysql_field_name(int IdConsulta, int IndiceCampo);
Nos devuelve el tipo de dato correspondiente a un campo de la base de datos, perteneciente a la consulta
IdConsulta y cuya posición en el SELECT viene dada por IndiceCampo, siendo 0 la primera posición. Probad a
poner, como muestra, este código en el ejemplo:
$TipoDato = mysql_field_type($IdConsulta, 1);
print("Tipo de dato del campo: ".$TipoDato."<P>");
mysql_field_name(int IdConsulta, int IdCampo);
Esta función nos devuelve el nombre del campo que ocupa la posición IdCampo referente a la consulta
IdConsulta. Una vez más, hay que decir que los campos se numeran de 0 a N-1, siendo N el número de campos
de la consulta. Podemos incluir este fragmento de código en el ejemplo anterior:
$NombreDato = mysql_field_name($IdConsulta,0);
print("Nombre del campo: ".$NombreDato."<P>");
Nos queda por ver una función, mysql_result();. Esta función tiene la siguiente definición:
mysql_result(int IdConsulta, int Fila, int Campo);
Esta función nos devuelve el dato referido a la consulta IdConsulta que ocupa la posición (Fila, Campo). Por ejemplo,
si añadimos este código al que teníamos:
$Dato1 = mysql_result($IdConsulta, 0, 0);
print("El valor obtenido en la posición (0,0) ".
"es: <B>".$Dato1."</B><P>");
Insertar, borrar y actualizar registros es igualmente sencillo. Simplemente, tenemos que almacenar nuestra consulta en
una variable, y pasársela como argumento a la función mysql_query();. Terminamos el capítulo viendo un ejemplo en el
que insertamos un nuevo registro y luego mostramos cuántos hay:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<HTML>
<HEAD>
<TITLE> Prueba PHP y MySQL </TITLE>
</HEAD>
<BODY BGCOLOR=white>
<?php
$NombreBD = "Registro";
$Servidor = "localhost";
$Usuario = "root";
mysql_select_db($NombreBD, $IdConexion);
for($i=0;$i<$NFilas;$i++) {
print("Fila ".$i."<BR>");
$ResultQuery = mysql_fetch_array($IdConsulta);
print("Usuario: ".$ResultQuery["USUARIO"]."<BR>");
print("E-mail: ".$ResultQuery[1]."<P>");
}
?>
</BODY>
</HTML>
Podemos ver el resultado en la imagen:
5. Un ejemplo final
Para hacernos una idea de cómo trabajar, vamos a desarrollar en este capítulo un ejemplo cuya finalidad será, dada una
base de datos con una única tabla, insertar en ella comentarios. Es un ejemplo sencillo que, convenientemente
modificado, puede dar lugar a aplicaciones como un libro de visitas, o ampliar sus posibilidades para hacer un sistema de
comentarios en la web, etc.
Partimos del siguiente código, que nos creará un formulario en la página (obviaremos las directivas de la cabecera y nos
centramos directamente en <BODY>):
<FORM ACTION="Comentarios.phtml" METHOD="POST" NAME="Comentario">
<CENTER>
<H2>Comentarios</H2>
<TABLE BORDER=0 CELLSPACING=2 CELLPADDING=2>
<TR> <TD>Nombre: </TD>
<TD><INPUT TYPE=TEXT SIZE=20 NAME="Nombre"></TD></TR>
<TR> <TD>Email: </TD>
<TD><INPUT TYPE=TEXT SIZE=20 NAME="Email"></TD></TR>
<TR> <TD COLSPAN=2>Escribe tu comentario: <BR>
<TEXTAREA ROWS=5 COLS=30 NAME="TComentario"></TEXTAREA></TD></TR>
</TABLE>
<INPUT TYPE=SUBMIT VALUE="Enviar">
<INPUT TYPE=RESET VALUE="Borrar">
</CENTER>
</FORM>
Podemos afinar más, y en lugar de un elemento SUBMIT poner simplemente uno de tipo BUTTON que en su evento
onClick tenga asociado un código de validación de datos, para no permitir campos vacíos, o una dirección de correo sin
arrobas, etc., para lo que habría que hacer el correspondiente script JavaScript. Pero eso es una ampliación y queda
como ejercicio al lector.
La idea va a ser, con los datos del formulario, rellenar los campos de una tabla en una base de datos que ha sido creada
invocando a MySQL pasándole este script:
CREATE DATABASE COMENTARIOS;
USE COMENTARIOS;
<BODY BGCOLOR=white>
<?php
$NombreBD = "Comentarios";
$Servidor = "localhost";
$Usuario = "root";
mysql_select_db($NombreBD, $IdConexion);
<?php
$Query = 'SELECT NOMBRE,EMAIL,MENSAJE FROM COMENTARIOS;';
$IdConsulta = mysql_query($Query, $IdConexion);
$NFilas = mysql_num_rows($IdConsulta);
?>
<CENTER>
<TABLE BORDER=0 BGCOLOR=#7BA9E8 CELLPADDING=4 CELLSPACING=3>
<?
for($i=0;$i<$NFilas;$i++) {
$ResultQuery = mysql_fetch_array($IdConsulta);
print("<TR>");
print("<TD>Nombre: ".$ResultQuery["NOMBRE"]."</TD>");
print("<TD>E-mail: ".$ResultQuery["EMAIL"]."</TD></TR>");
print("<TR><TD BGCOLOR=#ACC1FB COLSPAN=2>");
print("Mensaje: ".$ResultQuery["MENSAJE"]."</TD>");
print("</TR>");
}
?>
</TABLE>
</CENTER>
</BODY>
</HTML>
Con todo lo visto, no queda mucho más por comentar aquí, ya que no se ha hecho nada nuevo con respecto a capítulos
anteriores. Un ejemplo, tras varias inserciones de prueba, de este script, podemos verlo en la imagen:
A partir de ahora, todo depende de la imaginación del lector :-)