Llevando datos de la base MySQL a las páginas PHP

Cómo leer datos desde una base con PHP

Uno de los principales objetivos de la creación de una tabla en una base de datos es que todos (o parte de) los datos contenidos en ella se puedan leer y mostrar dentro de una página de nuestro sitio web.

Aprenderemos los pasos necesarios para leer los datos almacenados en una tabla de una base de datos y, a continuación, los mostraremos dentro del código HTML de una página.

Los pasos que se seguirán son los siguientes:

1. Que el programa intérprete de PHP se identifique ante el programa gestor de MySQL (que obtenga la autorización para solicitar datos).
2. Una vez autorizado, prepararemos la orden del lenguaje SQL que queremos ejecutar para traer los datos que nos interesan.
3. Ejecutaremos la orden SQL, y obtendremos un paquete de datos como respuesta.
4. Recorreremos el paquete de datos mediante un bucle que vaya extrayendo de a un registro por vez, registro que descompondremos en campos que iremos mostrando hasta que no haya más datos para mostrar.

Vamos a aprender estos pasos con un ejemplo concreto: construiremos una página que muestre el contenido de la tabla "mensajes" creada en el artículo por nombre: "Creando la primera base de datos".

Probar la conexión

El programa intérprete de PHP -que procesa nuestro código PHP- le debe demostrar al programa gestor de MySQL que tiene autorización para solicitarle datos.

Para intentar establecer una conexión entre estos dos programas, utilizaremos la función mysql_connect, que requiere que completemos tres parámetros: host, usuario y clave de MySQL, en ese orden, en consecuencia la estructura básica de esta función será:

<?php
mysql_connect ("host", "usuario", "clave");
?>

NOTA:
A partir de la versión 5.5.0 de PHP la función mysql_connect ha quedado como obsoleta, por lo tanto, se recomienda utilizar mysqli_connect o PDO::__construct().
De igual forma se recomienda dar un vistazo a cada una de las extensiones para las funciones de MySQLi

¿Qué significa cada uno de estos parámetros?

1. Host es la computadora en la que se encuentra instalado el programa gestor de MySQL, típicamente, será la misma computadora en la que se está ejecutando nuestro interprete de PHP, ya sea que la estemos haciendo localmente en nuestra casa, o un hosting. Siendo asi, el primer parámetro de la función mysql_connect deberá decir localhost (el host local, el mismo en el que se está ejecutando nuestro código PHP). En el raro caso de que MySQL se encuentre en otra computadora distinta a la que está ejecutando PHP, deberemos colocar la dirección IP de esa máquina como primer parámetro.
2. Usuario es el nombre de un usuario de software MySQL que tiene autorización para ejecutar consultas. Para la mayoría de emuladores que se instalan de manera local (XAMP EASYPHP, APPSERV), el usuario para utilizar la base de datos se llama "root", pero en un hosting el nombre de usuario será diferente, ya sea porque lo ha creado el administrador del hosting, o porque lo creamos nosotros mismos desde un panel de administración del sitio Web (esto varía mucho en cada hosting, por lo que lo dejamos para que lo consulten al soporte técnico de su empresa proveedora). Suele ser el usuario con el que nos identificamos para entrar en el phpMyAdmin.
3. Clave: es la contraseña del usuario con el que nos estemos identificando ante el programa MySQL. Para la mayoría de emuladores que se instalan de manera local la clave es un campo vacío, pero en un hosting tendremos que pedirla o crearla, como en el ejemplo del usuario que se explicó en el paso anterior.

Por esta razón, localmente nuestra función mysql_connect quedaría así:

<?php
mysql_connect ("localhost", "root", "clave");
?>

En el raro caso de una intranet con distintas máquinas para el intérprete de PHP y el programa gestor de MySQL, quedará algo como lo que expresa a continuación (obviamente los datos no son reales):

<?php
mysql_connect (123.456.10.1,"usuario", "password");
?>

Al ser mysql_connect una función que sólo puede devolver "verdadero" o "falso" (booleana), es posible envolverla dentro de un condicional que evaluará si MySQL nos autoriza que le enviemos consultas, o no:

<?php
if (mysql_connect ("localhost", "root", "clave") ){
echo "<p>MySQL le ha dado permiso a PHP para ejecutar consultas con ese usuario y clave</p>";
}else{
echo "<p>MySQL no conoce ese usuario y password, y rechaza el intento de conexión</p>";
}
?>

Con esto ya tenemos listo el primer paso. Nuestro programa interprete de PHP ya tiene autorización para realizar consultas al programa gestor de MySQL. Ahora, es momento de crear la consulta que ejecutaremos.

La orden "SELECT": entendiendo el lenguaje SQL

Para que el programa gestor de MySQL nos entregue un conjunto de datos, deberemos aprender a decírselo de forma que nos comprenda y, para ello, utilizaremos órdenes del lenguaje SQL (Structured Query Language o lenguaje de consultas estructurado).

En este caso que necesitaremos leer datos de una tabla, la orden será SELECT (seleccionar). Mediante esta orden, le pediremos al gestor de MySQL que nos entregue exactamente aquellos que queremos mostrar en nuestras páginas.

La sintaxis básica de la orden SELECT es la siguiente:

SELECT campo1, campo2, campo3, FROM tabla

Esto se traducirá como "Seleccionar los campos indicados, de la tabla indicada".

Con un ejemplo será más que simple entender su uso:

SELECT nombre, email FROM mensajes

Esta orden seleccionará los campos (columnas) nombre y email a través de todos los registros de nuestra tabla denominada mensajes.

Es decir, devolverá todos los registros (filas) de la tabla, pero "cortados" verticalmente, extrayendo sólo las dos columnas solicitadas (nombre y email), en consecuencia, nos llegaría lo siguiente (podemos insertar varios registros antes de hacer esto):

Pepe	pepe@pepe.com
Carlos	carlos@garcia.com
Alberto	alberto@perez.com

Si en cambio quisiéramos traer "todos los campos" de la tabla (tarea muy frecuente y, que en caso de tener muchos campos la tabla, podría resultar bastante tedioso completar sus nombres uno por uno) podemos utilizar un carácter que cumple las funciones de comodín para simbolizar "todos los campos de la tabla".

Este caracter es el asterisco, con el cual la orden quedaría :

SELECT * FROM mensajes

Esta orden traería todas la columnas (campos) de la tabla mensajes (y, desde ya, todos los registros también):

1	Pepe	pepe@pepe.com	Bla, bla, bla...
2	Carlos	carlos@garcia.com	Bla, bla, bla...
3	Alberto	alberto@perez.com	Bla, bla, bla...

Resumiendo, para finalizar este segundo paso, podemos almacenar la orden SQL en una variable (hasta el momento en que la necesitemos):

<?php
$consulta= "SELECT * FROM mensajes";
?>

Ahora que tenemos preparada nuestra orden SQL, es momento de pasar al tercer paso y hacer que el intérprete PHP se la envíe al gestor de MySQL, obteniendo alguna respuesta.

Ejecutar la orden y obtener una respuesta

Para que PHP envíe una consulta SQL hacia el gestor de MySQL utilizaremos dos funciones que posee el lenguaje de PHP.

La primera es llamada mysql_select_db (seleccionar una base de datos) y, la segunda mysql_query (hacer una consulta -query- a una base de datos MySQL).

La primera, mysql_select_db, se usa una sola vez por página, para indicar a cuál base de datos le realizaremos consultas de allí en más.

Solo hace falta especificar entre paréntesis a cuál base de datos solicitaremos ejecutar esta consulta (recomendemos que, hasta ahora, en ningún momento mencionamos nuestra base de datos llamada "cursos" visto en el artículo por nombre "Creando la primera base de datos").

Por ejemplo:

<?php
mysql_select_db ("cursos");
?>

Luego de seleccionar la base datos, ejecutamos la consulta propiamente dicho con mysql_query.

Esta función requiere que completemos un solo parámetro: la consulta SQL que ejecutaremos.

Por lo tanto, la orden, en este caso, quedaría provisoriamente así:

<?php
mysql_query ($consulta);
?>

Notemos que especificamos la variable donde recientemente hemos almacenado la orden del lenguaje SQL que vamos a ejecutar ($consulta)

Pero si ejecutáramos este código tal cual como está aquí, nos perderíamos el objetivo principal de esta consulta, que era obtener datos de la tabla.

Estamos ejecutando esta consulta, que a cambio nos debería devolver un "paquete" de datos, pero... estamos ignorando esto que nos entrega y dejamos que se pierda en el aire.

Es necesario que recibamos los datos que nos devuelve, en el mismo instante en el que ejecutamos la consulta, es decir: debemos asignarle a alguna variable el resultado de ejecutar la función mysql_query, para que sea esta variable la que contenga la respuesta recibida.

Por ejemplo:

<?php
$datos = mysql_query ($consulta);
?>

De esta manera, culminamos el tercer paso y estamos listos para el cuarto y último paso.

Integrar los datos al código HTML

Solo resta recorrer con un bucle el paquete de datos e ir generando el código HTML que incluya los datos que iremos mostrando en la pantalla.

Comencemos diciendo que $datos no es una variable común, ni una matriz, sino que es un resultado de una consulta o, más sencillamente, un "paquete cerrado" de datos que no podremos utilizar directamente, sino que tendremos que descomprimirlo para que se pueda mostrar.

El paquete de datos contiene varias filas (los mensajes de Pepe, García, Pérez, etc.), pero, a su vez, cada fila contiene varios campos (id, nombre, email y mensaje).

Será preciso ir tomando con pinzas de a una fila horizontal por vez del paquete que es $datos, y una vez que tengamos seleccionada una fila, deberemos traspasarla dentro de una matriz (podremos llamarla $fila) que contenga en cada celda, un campo de esa fila: $fila["id"], $fila["nombre"], $fila ["email"] y $fila["mensaje"].

Exactamente esto es lo que hace una función llamada mysql_fetch_array: toma como parámetro un paquete $datos que tenemos y le extrae una fila completa, que debemos asignar a una matriz que llamaremos $fila.

El código sería así:

<?php
$fila= mysql_fetch_array ($datos);
?>

Este momento ,$fila es una matriz (o array, por eso lo de...fletch_array) que contiene la primera fila completa de la tabla, con los valores de sus cuatro campos ubicados en cuadro celdas de la matriz $fila.

Los índices alfanúmericos de esta matriz $fila, que contiene un registro de la tabla, son los nombres que tenían los campos en la tabla.

En este momento,

• $fila["id"] contiene un "1",
• $fila["nombre"] contiene Pepe,
• $fila["email"] contiene "pepe@pepe.com" y
• $fila["mensaje"] "Bla, bla, bla...".

Pero, ¿qué pasará con el resto de filas que no hemos leídos? La función mysql_fetch_array sólo lee una fila cada vez que se ejecuta.

Para poder leer no solo la primera, sino también el resto de las filas, deberíamos realizar un bucle, que ejecute esta lectura y asignación de una fila por vez, repetitivamente, mientras todavía quede dentro de $datos alguna fila que asignar (será un bucle de tipo while, ya que no sabemos de antemano cuántas filas nos devolverá la consulta).

En cuanto se almacena una fila en la matriz, la deberemos mostrar inmediatamente (escribir en pantalla con un print o echo), ya que una vuelta después del bucle, el contenido de $fila será borrado para permitir almacenar los valores de la siguiente fila de la tabla.

La condición del bucle será "mientras podamos descomprimir con mysql_fetch_array una nueva fila del paquete de datos, almacenarla en una matriz"... Pensemos esto detenidamente y veamos cómo sería esa parte:

<?php
while ($fila=mysql_fetch_array($datos)){
echo "<p>";
echo "-"; //un separador
echo $fila ("nombre");
echo "-"; // un separador
echo $fila ("email");
echo "-"; // un separador
echo $fila ("mensaje");
echo "<p>";
?>

Para terminar, veamos un ejemplo completo, pasado en limpio de los cuatro pasos juntos:

<?php
// 1) Conexión
if ($conexión = mysql_connect("localhost", "root", "clave")){
echo "<p>MySQL le ha dado permiso a PHP para ejecutar consultas con ese usuario</p>";

// 2) Preparar la orden SQL
$consulta= "SELECT*FROM mensajes";

// 3) Ejecutar la orden y obtener datos
mysql_select_db("cursos");
$datos= mysql_query ($consulta);

// 4) Ir Imprimiendo las filas resultantes
while ($fila =mysql_fetch_array($datos)){
echo "<p">;
echo $fila ["id"];
echo "-"; // un separador
echo $fila["nombre"];
echo "-"; // un separador
echo $fila ["email"];
echo "-"; // un separador
echo $fila["mensaje"];
echo "</p>";
}

}else{
echo "<p> MySQL no conoce ese usuario y password</p>";
}
?>

Ahora sí que estamos preparados par mostrar los datos almacenados en nuestras tablas.

Vamos a volver a hacer esto miles de veces, cambiando "productos" por "mensaje", "empleados", "comentarios", o lo que sea que haya que mostrar en una página de nuestro sitio.

Desde ya que la forma de mostrar estos datos dentro del código HTML irá variando; en algunos casos, precisaremos mostrar un texto (párrafos como los del ejemplo anterior); en otros, necesitaremos generar etiquetas option dentro de un elemento select; otras veces, filas de una tabla; o botones de tipo radio, o casillas de verificación.

Lo ideal es que nos vallamos creando una serie de funciones, que reciban como parámetros el nombre de la tabla y los campos que se seleccionarán, más algún dato específico (label, name, elemento a mostrar seleccionado, etc.) y que devuelva el bloque HTML completo cargado con los datos de la tabla.

Complementos de la orden SELECT del lenguaje SQL

Ya hemos visto la sintaxis mínima de la orden SELECT del lenguaje SQL, que nos permite seleccionar determinados campos de una tabla.

Pero ahora vamos a ir un poco más allá y conoceremos un modificador condicional denominado WHERE, que resulta muy útil para aumentar su potencia a la hora de extraer datos con precisión de la base de datos (todas nuestras consultas SQL poseerán un WHERE).

Para poner en practica este concepto, crearemos una nueva tabla en nuestra base de datos.

La llamaremos "empleados", y poseerá los siguientes campos:

CREATE TABLE empleados (
id TINYINT (3) NOT NULL AUTO_INCREMENT PRIMARY KEY,
nombres VARCHAR(40) NOT NULL,
apellido VARCHAR (40) NOT NULL,
edad TINYINT (2) NOT NULL,
pais VARCHAR (30) NOT NULL,
especialidad VARCHAR (30) NOT NULL
) ENGINE = MYISAM

Podemos escribir esta orden dentro de la ventana de ejecución de código de SQL del phpMyAdmin, y la tabla será creada idéntica a la original:

Una vez creada la tabla, vamos a cargar varios registros con diferentes valores en los distintos campos, para poder utilizarlos en las órdenes de selección condicional.

Recomendamos cargar los siguientes datos, ya que fueron elegidos especialmente para mostrar resultados significativos en las consultas que realizaremos a continuación:

id	nombre	apellido	edad	país	especialidad
1	Pedro	Fernandez	34	España	Matemáticas
2	José	García	28	México	Sistemas
3	Guillermo	Pérez	32	España	Contabilidad
4	Alberto	Maza	45	México	Matemáticas
5	Luis	Puente	43	Argentina	Sistemas
6	Claudio	Lopéz	41	España	Medicina
7	Mario	Juárez	41	México	Sistemas
8	Alan	Flores	25	Perú	Sistemas

El condicional WHERE

A nuestras órdenes SELECT será muy común que les agreguemos condiciones, para que nos devuelva un conjunto menor de resultados: solo aquellos registros que cumplan con la condición. La condición tomará en cuenta el valor de alguno de los campos.

Por ejemplo, imaginemos que necesitamos una lista de los empleados de la tabla anterior, pero no todos, sino solo aquellos cuya especialidad sea "Matemáticas".

La sintaxis de la expresión condicional WHERE es similar a la de un if: se trata de una afirmación en la forma de una comparación, cuyos elementos serán un campo de la tabla, un operador de comparación y un valor contra el que se compara:

... WHERE campo operador 'valor'

Lo que traducido a un ejemplo más concreto, podría ser:

... WHERE especialidad='Matemáticas'

Y completando la orden SELECT con esta condición, tendríamos una orden completa:

SELECT nombre, apellido FROM empleados
WHERE especialidad='Matemáticas'

Si escribimos esta orden en la ventana de ejecución de código SQL del phpMyAdmin, y pulsamos en Continuar, obtendremos como resultado justo los datos que necesitábamos:

Obtuvimos sólo el nombre y el apellido de los empleados cuyo campo "especialidad" tenía un valor exactamente igual a "Matemáticas".

Operadores para utilizar WHERE

Los operadores de los que disponemos dentro de un WHERE son muy similares a los que usamos en los condicionales de PHP, salvo el ultimo, denominado LIKE.

Operador	Significa
=	Igual
>	Mayor que
<	Menor que
>=	Mayor o igual
<=	Menor o igual
<>	Distinto de
LIKE	Que incluya... (ahora lo analizaremos)

El operador LIKE permite establecer condiciones de "similaridad" mucho menos estrictas que la simple igualdad del contenido completo de un campo permitida por el ya conocido signo igual.

Por ejemplo, si en vez de necesitar un listado de empleados cuya especialidad sea exactamente "Matemáticas", necesitáremos un listado de empleados cuya especialidad "comience con M", podríamos usar este operador. Sirve para encontrar un carácter (o más) al principio, en medio o al final de un campo.

Se vale de un "comodín" que es el signo de % (porcentaje), que simboliza la presencia potencial de caracteres en esa dirección.

Se usa de la siguiente forma:

1. ... WHERE especialidad LIKE 'M%'
   Nos devolverá aquellos registros en los cuales el campo especialidad contenga una letra "M" al principio del campo, sin importar si a continuacion sigue cualquier otra cosa (o incluso si no le sigue nada). En nuestra tabla de ejemplo, incluirá a quien tenga "Medicina" y Matemáticas" como especialidad.
2. ... WHERE especialidad LIKE '%M%'
   Devolverá los registros que en el campo especialidad contengan una letra "M" (mayúsculas o minúsculas, es indistinto) al principio, en el medio o al final del campo. En nuestra tabla, nos devolverá a quienes tengan especialidades de "Medicina", "Matemáticas" y "Sistemas".
3. ... WHERE especialidad LIKE '%M'
   Seleccionará los que en el campo especialidad contengan una letra "M" justo al final, como última letra del campo (o como única letra del campo), pero sin que la siga otra letra.
   Es fundamental que el valor buscado, junto con el carácter de "%", estén envueltos entre comillas simples.

Este operador LIKE es el que típicamente se utiliza en cualquier campo de búsqueda que indague dentro de un campo de textos o títulos de noticias, comentarios, mensajes de foros, nombres de productos, etc.

Lo importante es que nos permite encontrar la palabra buscada en parte del título o nombre del producto.

Por ejemplo, si buscamos ...WHERE nombre LIKE '%TV%', encontraremos registros que en el nombre de un producto contengan "TV LG 42 pulgadas", o "Mini TV de pulsera", o "Monitor LED con sintonizador de TV", que será imposible de seleccionar con el operador "=" normal (que exige que el contenido completo del campo sea igual a lo buscado).

Veamos ahora un operador útil para rangos: se trata del operador BETWEEN, que nos permite especificar un límite mínimo y un límite máximo. Probemoslo con la edad de nuestros empleados.

Si precisamos un listado de empleados de entre 40 y 50 años, lo obtendríamos con esta orden:

SELECT * FROM empleados WHERE edad BETWEEN 40 and 50

Podemos indicar la exclusión de un rango mediante NOT BETWEEN:

SELECT * FROM empleados WHERE edad NOT BETWEEN 18 and 40

También podemos unir varias condiciones mediante los operadores lógicos AND y OR.

Veamos un ejemplo de OR (nos devolverá tanto los empleados que en su campo "país" figura el valor "España" como los que sean de "Argentina"):

SELECT * FROM empleados WHERE país= 'España' OR país= 'Argentina'

En cambio al combinar condiciones con AND, los resultados serán más específicos sólo aquellos registros que cumplan con todas las condiciones unidas mediante AND:

SELECT * FROM empleados WHERE país= 'Argentina' AND especialidad= 'Sistemas'

También, podemos buscar coincidencias con varios valores posibles para un campo, y no con uno sólo, usando IN:

SELECT * FROM empleados
WHERE país In ('México', 'Argentina', Perú')

De esta manera, proporcionamos, en un solo paso, una lista de valores para el campo "país" que, en este ejemplo, nos devolverá los registros de empleados cuyo país sea México, Argentina o Perú.

Ordenando los resultados

Al momento de obtener los resultados de una consulta SQL, podemos desear que éstos se nos entreguen de forma ordenada, por el valor de alguno de los campos.

Para ello, se utiliza la expresión ORDER BY, a la que debe seguir el nombre del campo por el cual queremos ordenar los resultados.

Probemos obtener una lista de empleados ordenados alfábeticamente por el apellido:

SELECT * FROM empleados ORDER BY apellido

Contamos con dos modificadores adicionales que especifican si el ordenamiento será realizado de menor o mayor (ascendente: ASC, no es necesario especificarlo ya que es la forma en que se ordenaran por defecto), o de forma descendente (de mayor a menor, en cuyo caso el modificador es DESC). Por ejemplo:

SELECT * FROM empleados ORDER BY edad DESC

Limitando la cantidad de resultados

Cuando la cantidad de resultados pueda ser muy grande, será conveniente mostrar solamente cierta cantidad de resultados (tal como hace Google en su listado de resultados).

Esto es muy usado al mostrar resultados "paginados" (con la opción de ver otros conjuntos siguientes o anteriores de resultados, mediante < y > o similares).

Para limitar la cantidad que devuelve una consulta, usaremos LIMIT.

Este modificador requiere que especifiquemos dos valores: a partir de qué número de resultado devolver, y cuántos resultados devolverá.

con un ejemplo será más fácil de entender:

SELECT * FROM empleados ORDER BY apellido LIMIT 0,3

Eso nos devolverá tres registros, a partir del primero, pero no del primero físicamente en la tabla, sino el primero de los resultados que hubiera devuelto la consulta ordenada por apellido, es decir, el de apellido más cercano a la A.

Si en un paginador tuviéramos que realizar otra consulta para traer los tres siguientes, lo único que cambiará es el valor de inicio de LIMIT:

SELECT * FROM empleados ORDER BY apellido LIMIT 3,3

Eso devolverá tres registros, posteriores al tercero (tomando en cuenta el apellido).

Seleccionando valores no repetidos

Podemos obtener fácilmente los valores únicos de un campo, sin tener en cuenta sus repeticiones.

Por ejemplo si queremos obtener el listado de especialidades, sin repetir ninguna, que al menos uno de los empleados tiene asignada, podemos solicitarlo agregando la palabra DISTINCT delante del campo que se seleccionará.

SELECT DISTINCT especialidad FROM empleados

Eso nos devolverá la lista de especialidades una por registro

Funciones estadísticas

Muchas veces, no necesitaremos que una consulta nos devuelva "los datos" que están almacenados en la tabla, si no alguna información estadística "acerca de" esos datos.

Por ejemplo, cuántos registros logró seleccionar una consulta, cuál es el valor mínimo o máximo de un campo, cuál es la sumatoria de los valores de ese campo a lo largo de todos los registros, o cuál es el valor promedio:

Función	Qué devuelve
COUNT	La cantidad de registro seleccionados por una consulta
MIN	El valor mínimo almacenado en ese campo
MAX	El valor máximo almacenado en ese campo
SUM	La sumatoria de ese campo
AVG	El promedio de ese campo

En caso de que necesitemos consultar "si existe" algún dato en una tabla (lo sabremos si su cantidad es menos 1), o si queremos saber cuántos registros existen que cumplan con determinada condición, podemos utilizar la función COUNT:

SELECT COUNT (*) FROM empleados WHERE país= 'México'

Esta función devuelve, no un conjunto de registros, sino un único número: la cantidad de registros existentes que cumplan con la condición especificada (y si no especificamos ninguna, nos devolverá el número total de registros de la tabla):

Las otras cuatro funciones, al igual que COUNT, devuelven un único número como resultado.

Se utilizan del mismo modo, junto a la palabra SELECT, y al tratarse de funciones, todas envuelven entre paréntesis el nombre del campo que van a analizar.

SELECT MIN (edad) FROM empleados;
SELECT MAX(edad) FROM empleados;
SELECT SUM (edad) FROM empleados;
SELECT AVG (edad) FROM empleados;

Existen muchísimos otros operadores, funciones y modificadores en el lenguaje SQL, por lo que recomendamos seguir investigando por nuestra cuenta en algún buen manual especifico del lenguaje SQL.

Funciones propias para mostrar datos

Es sumamente útil crear una "biblioteca" de funciones, especializadas en leer datos de una base de datos y mostrarlos luego dentro de diferentes tipos de etiquetas HTML. Tarde o temprano, tendremos que realizar una tarea similar en nuestros sitios.

Nos conviene dividir todo el trabajo en varias funciones complementarias:

1. Una función que intente establecer una conexión con la base y que trate de seleccionarla (si llega a fallar cualquiera de estos dos pasos, no se podrá hacer nada mas).
2. Una función que ejecute una consulta y obtenga como respuesta un "paquete" de datos. Necesitará como parámetro de entrada la orden SQL que ejecutará, y que devolverá un "paquete" de datos (o false en caso de que el paquete de datos esté vacío).
3. Varias funciones, cada una especializada en mostrar los datos recibidos, envueltos en etiquetas HTML específicas.

Vamos paso por paso:

1) Para crear una función que se encargue de la conexión a la base de datos, una práctica previa –muy recomendable- es definir, en un único archivo externo, todas las variables relativas a la conexión con MySQL como, por ejemplo, el host, usuario, contraseña y nombre de la base de datos, ya que su valor suele cambiar de un hosting a otro.

Si lo hacemos de esta manera, cuando probemos nuestro sistema en un hosting diferente, no tendremos que ir cambiando a mano esos datos en cada página de nuestro sitio.

Supongamos que creamos un archivo llamado datos.php con ese objetivo. Su contenido será el siguiente:

<?php
$host="localhost";
$usuario="root";
$clave="clave";
$base="cursos";
?>

Luego haremos un include de ese archivo dentro de cada página donde vayamos a conectarnos con la base de datos, y usaremos esas variables en las funciones. Por ejemplo:

<?php
// Incluimos esos datos:
include ("datos.php");
//usamos esas variables:
if ($conexion= msql_connect($host,$usuario,$clave)) {
// etc.
?>

De esta forma, si cambiamos de servidor (entre un servidor local de pruebas y un hosting o de un hosting de un cliente al hosting de otro cliente), donde no tendremos los mismos nombres de bases, usuarios y claves, sólo tendremos que modificar un único archivo (datos.php) una sola vez, y no tendremos que modificar absolutamente nada dentro del código de nuestras páginas.

Lo ideal es tener un archivo datos.php en el servidor local con los datos de conexión locales, y otro datos.php en el hosting, con los datos de conexión del hosting.

Habiendo preparado en un archivo aparte los datos de conexión, ahora ya podemos crear una función propia que se encargue de la conexión a la base de datos.

Si bien en PHP contamos con una función para establecer una conexión con MySQL (mysql_connect), y otra para seleccionar una base de datos en particular (mysql_select_db), ambas son independientes, y esto nos obliga a hacer dos condiciones distintas para validar si lograron su tarea, complicando nuestro código.

Nuestra propuesta es unificar ambos pasos, ya que un fallo a este nivel impedirá el uso del sistema, y al usuario poco le importara si no puede usar el sistema porque "fallo la conexión" o porque "no pudo seleccionarse la base de datos", ambas cosas le son desconocidas, y es importante plantearse si necesita un mensaje específico o no es necesario.

Si coincidimos en que no es necesario informar con tanto detalle, entonces podemos unir ambos pasos: conectarnos y seleccionar una base.

Crearemos entonces una función booleana (que devuelva true o false, así podemos evaluarla dentro de un condicional al momento de ejecutarse).

<?php
function conecatarBase ($host,$usuario,$clave,$base){
if (!$enlace= mysql_connect($host,$usuario,$clave)){
return false;
} elseif (!mysql_select_db(base)){
return false;
} else {
return true;

A esta función, tal como vimos en la figura anterior, la crearemos dentro de un archivo externo llamado funciones.php, al que también lo incluiremos dentro de las paginas mediante una orden include:

include ("datos.php");
include ("funciones.php");

Sin embargo en esta función todavía existe un problema, que podemos comprobar fácilmente si modificaremos intencionalmente alguno de los datos de conexión (probemos cambiando el host, usuario o clave, por uno que no sea el correcto), y es que, si llega a fallar el intento de conexión, aparecerá en la pantalla un mensaje de error en inglés.

Podemos ocultar fácilmente ese mensaje de error si anteponemos a la función de PHP que produce el error (mysql_connect, en este caso) el operador de control de errores de PHP, que es una simple arroba:

<?php
function conectaBase ($host,$usuario,$clave,$base){
if (!$enlace= @mysql_connect($host,$usuario,$clave)){
//notemos la arroba antepuesta a la función que devolvía error
return false;
} elseif (!mysql_select_db(base)){
return false;
} else {
return true;
}
}
?>

Este operador de control de errores (la arroba) lo ponemos anteponer a cualquier expresión que devuelva datos (como, por ejemplo, una llamada a una función, una orden include, una variable o una constante), y de esta forma evitamos que se muestre el mensaje de error de PHP en caso de fallo.

Volviendo a la función que acabamos de crear, la utilizaríamos desde nuestras páginas dentro de un condicional:

<?php
//incluimos los datos de conexión y las funciones:
include ("datos.php");
include ("funciones.php");
// usamos esas variables:
if conecatarBase ($host,$usuario,$clave,$base){
// Aquí haríamos el resto de operaciones...
} else {
echo "<p>Servicio interrumpido</p>"
}
?>

2) Ahora, es momento de crear una función que nos permita realizar una consulta a la base de datos, obteniendo un paquete de datos como respuesta (o false en caso de fallo).

Esta función podría ser así:

<?php
function consultar ($consulta){
if (!datos= mysql_query ($consulta) or mysql_num_
rows ($datos) <1{
return false;// si fue rechazada la consulta por errores de sintaxis, o ningún registro coincide con lo buscado, devolvemos false
} else {
return $datos;// si se obtuvieron datos, los devolvemos al punto que fue llamada la función
}
}
?>

Notemos el uso de la función mysql_num_rows, que devuelve la cantidad de registro que obtuvo una consulta.

En nuestro condicional, estamos planeando una doble condición si la consulta en sí falló (y devolvió false) -eso es lo que evalúa antes del ol-, o si la cantidad de registros obtenidos fue... ninguno.

Hemos decicido aunar en una sola condición ambas situacion, desde ya que podríamos descomponerlo en diferentes condicionales pero en este momento creemos que sería complicar la lectura del ejemplo.

De la misma que en nuestra función anterior, utilizaremos nuestra función consultar dentro de un condicional, cuando estemos seguros de que la conexión a la base funcionó.

Veamos cómo va quedando el código de la página que va llamando a estas funciones sucesivamene:

<?php
// Incluimos los datos de conexión y las funciones:
include ("datos.php");
include ("funciones.php");
// Usamos esas variables:
if (conectarBase ($host, $usuario, $clave, $base)){
$consulta= "SELECT * FROM empleados";
if ($paquete= consultar ($consulta)){
// Aquí llamaremos a una función que muestre esos datos
} else {
echo "<p>No se encontraron datos</p>";
}
} else {
echo "<p> Servicio interrumpidos</p>";
}
?>

Por último, sólo nos falta crear distintas funciones que se ocupen de mostrar el "paquete" de datos recibido, con la diferencia de que cada una se especializará en mostrar los datos dentro de distintas etiquetas HTML: veremos cómo mostrar datos dentro de un menú de selección, una tabla, botones de radio y casillas de verificación.

Menú de selección dinámico

Comencemos por uno de los elementos HTML más usados para mostrar datos de una base: los menúes de selección (elementos select HTML).

Es muy común que estos elementos muestren listados de países, provincias, estados civiles, categorías y cualquier otra variedad de opciones excluyentes entre sí, de las que el usuario deba elegir una obligatoriamente.

Las opciones que se mostrarán, como podemos imaginar, son el contenido de una tabla de la base de datos.

Una función que produzca el código de un select podría poseer definidos, al menos, los parámetros name y label, adémas de un "paquete de datos" obteniendo luego de realizar una consulta a la base de datos.

Nos anticipamos a un par de detalles que observaremos en este código:

• Hemos colocado saltos de línea\n donde finaliza cada renglón de código HTML, para que podamos leerlo con mayor claridad al mirar el código fuente recibido en nuestro navegador.
• Y hemos convertido al juego de caracteres UTF-8 los datos alfanuméricos recibidos de la base de datos; para mostrar los acentos y eñes sin problemas. Para ellos, le hemos aplicado la función de PHP llama utf8_encode a los datos alfanuméricos.

Hechas estas aclaraciones, veamos cómo podría ser una función que muestre datos dentro de un menú de selección:

<?php
function genera_MenuSelección ($datos, $name, $label){
$codigo= '<label>'.$label.'</label>'."\n";
$codigo= $codigo.'<select name="'.name.'">."\n";
while ($fila= mysql_fetch_array ($datos)){
$codigo= $codigo.'<option
value= "'.$fila["id"].'">.utf8_encode($fila["pais"]).'/
option>'."/n";
}
$codigo= $codigo."</select>\n";
return $codigo;
}
?>

En la página donde vayamos a llamar a esa función, recibiremos en una varible el código que fue acumulado la función internamente en su variable local $codigo, y allí quedará (en la variable $codigoMenu, en este ejemplo) hasta que decidamos usarlo. En este caso, inmediatamente lo mostramos con un echo.

Recordemos que ya contámos con un $paquete de datos, que es lo que pasaremos como parámetro a la función:

$codigoMenu= generaMenuSeleccion($paquete, $name, $label);
echo $codigoMenu;

Estas dos líneas irían colocadas en la parte del código anterior donde dejamos el comentario que decía "// Aquí llamaremos a una función que muestre esos datos".

Lo cual producirá, en el caso de nuestra tabla de empleados, el siguiente código HTML:

<label>Empleados</label>
<select name= "empleados">
<option value= "1"> Pedro</option>
<option value= "2"> José</option>
<option value= "3"> Guillermo</option>
<option value= "4"> Alberto</option>
<option value= "5"> Luis</option>
<option value= "6"> Claudio</option>
<option value= "7"> Mario</option>
<option value= "8"> Alan</option>
</select>

Vemos los valores de label y del name (proporcionados como parámetros al momento de llamar a la función), y luego los valores envueltos entre la apertura y cierre de cada etiqueta option (obtenidos gracias a la consulta a la base de datos).

Esta misma lógica, podemos aplicarla para envolver los datos obtenidos en cualquier otra etiqueta HTML, Veremos, a continuación, algunos ejemplos más.

Generando tablas, filas y datos de datos

Un uso muy común de los datos obtenidos de una consulta a una base de datos es mostrarlos en una tabla.

Como sabemos, una tabla consite en una etiqueta table que envuelve todo el contenido de la tabla, una etiqueta tr (table row, o fila de tabla) que envuelve a cada fila horizontal y una etiqueta td (table data, o dato de tabla) que envuelve a cada celda que contenga datos. Tendremos que generar estas tres partes con nuestro código PHP.

Veamos cómo podría ser una función que mostrará datos en una tabla:

<?php
function tabular ($datos){
//Abrimos la etiqueta table una sola vez:
$codigo = '<table border="1" cellpadding="3">';

//Vamos acumulando de a una fila "tr" por vuelta:
while ($fila = @mysql_fetch_array($datos) ) {

$codigo .= '<tr>';

//vamos acumulando tantos "td" como sea necesario:
$codigo .= '<td>'.utf8_encode($fila["id"]).'</td>';

$codigo .= '<td>'.utf8_encode($fila["nombre"]).'</
td>';
$codigo .= '<td>'.utf8_encode($fila["apellido"]).'</
td>';
$codigo .= '<td>'.utf8_encode($fila["edad"]) .'</
td>';
$codigo .= '<td>'.utf8_encode($fila["pais"]) .'</
td>';
$codigo .= '<td>'.utf8_encode($fila
["especialidad"]).'</td>';

//cerramos un "tr":
$codigo .= '</tr>';
}
//finalizandoell bucle, cerramos por unica vez la tabla:
$codigo .='</table>';

return $codigo;
}

Podemos usarla igual que la función anterior, a partir de un paquete de datos ya obtenido y asignado el código que fabrica a una variable, que luego mostramos en echo.

Los botones de radio y las casillas de verificación

Los últimos casos que veremos son los del los botones de radio y las casillas de verificación.

Comenzaremos por los botones de radio: recordemos que para ser parte de una misma serie excluyente de opciones, deben compartir el mismo valor en el atributo name, aunque cada botón tenga su propio id único.

Y que además de un fieldset y legend descriptivo del conjunto completo, cada botón debe tener su propio label:

<?php
function crearRadios($datos,$leyendas,$name){
//Abrimos el fieldset con su leyenda:
$codigo = '<fieldset><legend>'.$leyenda.'</
legend'."/n";
//Vamos mostrando un label y un input por vuelta:
while($fila=@mysql_fetch_array($datos)){

//Un label:
$codigo .='<label>'.utf8_encode($fila["nombre"]);

//Un input:
$codigo = $codigo.'<input type="radio"
name="'.$name.'" id="dato'.$fila["id"].'"/>'."\n";

//cerramos el label:
$codigo .='</label><br />'."\n";
}
$codigo .='</fieldset>'."\n";
return $codigo;

}
?>

Podemos llamarla dentro del mismo archivo que realizaba la conexión y ejecutaba una consulta obteniendo un paquete de datos, de la siguiente manera:

$radios =crearRadios($paquete,'Votemos al empliado del mes','empleado');
echo $radios;

Por último las casillas de verificación: como sabemos, en ellas cada name debe ser diferente, por lo que lo formaremos uniendo a una parte escrita de manera fija el identificador de cada registro, como hicimos con los id en el ejemplo anterior, de los botones de radio:

<?php
function crearCasillas ($datos,$leyenda) {
//abrimos el fieldsetcon su leyenda:
$codigo = '<fieldset><legend>' .$leyenda.'>/
legend>' ."\n";
//Vamos mostrando un label y un input por vuelta:
while ($fila=@mysql_fetch_array($datos) ) {
//Un label:
$codigo .='<label>'.utf8_encode($fila["nombre"]);
//Un input:
$codigo = $codigo.'<input type="checkbox"
name="dato'.$fila["id"].'"dato'.$fila["id"].'"
/>'."\n";

//Cerramos el label:
$codigo .='</label><br />'."\n";
}
$codigo .= '</fieldset>'."\n";

return $codigo;
}
?>

Y la llamaríamos de la siguiente manera:

$casillas = crearCasillas($paquete,'Tu voto puede sumarse a
mas de un empleado'.'empleado');

echo $casillas;

Será muy útil seguir creando tantas funciones como consideramos necesario, para mostrar datos de distintas formas dentro de etiquetas HTML, ya que las necesitaremos continuamente en nuestro trabajo con base de datos.

El objetivo de la creación de todas las funciones es organizar nuestro código par que no quede suelto (que lo vuelve muy fácil de reutilizar).

Podemos notar como la cantidad de código suelto dentro de nuestras páginas es cada vez menor, consistiendo en apenas un par de includes (del archivo de “datos” y del de “funciones”), algunos condicionales que validad datos y deciden cual ejecutar, y nada más.

Esta forma de programar modularizada o estructurada en funciones, facilita muchísimo el mantenimiento, y hace que futuros cambios (siempre imprevisibles) no nos obliguen a modificar las “paginas” una por una, sino solo el archivo donde este la declaración de nuestras funciones.

Con esto, ya dominaremos suficientes técnicas para enviar datos desde la base hacia nuestras páginas.

Llega el momento de agregar interactividad y hacer el recorrido inverso, llevando datos desde la pantalla del usuario hacia nuestra base de datos