PHP y MySQL Tecnologías para El Desarrollo de Apli... - (PG 230 - 431)

PHP Y MYSQL.
TECNOLOGÍAS PARA EL DESARROLLO DE APLICACIONES WEB
$num_entradas = 5;
$tarifa = "precio_normal";
$importe = $tarifa($num_entradas);
print "El importe total de las $num_entradas entradas
es $importe euros.";
En este caso concreto, se está llamando a la función precio_normal(), y, por

tanto, la salida del programa sería:
El importe total de las 5 entradas es 22.5 euros.
Por supuesto, el valor de la variable que hace referencia a la función podría ser
asignado a partir de determinadas condiciones en el programa, por ejemplo, si el día
actual es un miércoles se podría aplicar la tarifa reducida y en cualquier otro día la
tarifa normal:
if(date("w") == 3)
$tarifa = "precio_reducido";
else
$tarifa = "precio_normal";
$importe = $tarifa($num_entradas);
Para obtener el día de la semana correspondiente al día actual se utiliza la función

date() con el parámetro "w", en esta situación esta función devuelve un valor de
0 a 6, correspondiendo el 0 al domingo y el 6 al sábado.
Si se utilizan funciones variables, se debe tener especial cuidado en evitar la

asignación a la variable de un nombre de una función inexistente, ya que en caso
contrario se produciría un error grave en tiempo de ejecución y se finalizaría
Copyright © 2005. Ediciones Díaz de Santos. All rights reserved.
bruscamente la ejecución del programa. Para asegurarse de que una función

realmente existe, PHP dispone de la función function_exists(), que
devuelve un valor booleano indicando si la función cuyo nombre se pasa como
argumento existe o no.
function_exists() busca la correspondiente función tanto entre la funciones

internas del lenguaje como entre las definidas por el propio programador. De
hecho, es posible obtener un array con los nombres de todas las funciones
disponibles en el programa, para ello basta hacer una llamada a una nueva función
de PHP:
get_defined_functions()
212
Cobo, Á., Gómez, P., & Pérez, D. (2005). Php y mysql : Tecnologías para el desarrollo de aplicaciones web. Retrieved from http://ebookcentral.proquest.com
Created from unadsp on 2019-09-13 11:30:05.
DEFINICIÓN DE FUNCIONES
Por ejemplo, una simple ejecución de las sentencias
$f = get_defined_functions();
print_r($f);
mostraría en la página una lista con las más de 700 funciones predefinidas en PHP.
213
ARRAYS
8.1. CONCEPTOS FUNDAMENTALES

Los arrays son estructuras de datos que están presentes en prácticamente la
totalidad de lenguajes de programación. Permiten el almacenamiento y
procesamiento de grandes volúmenes de datos sin necesidad de tener que recurrir al
uso de un elevado número de variables. Una vez almacenada la información en un
array, puede accederse a ella y modificarse siempre que sea necesario, gracias a la
multitud de funciones que permiten la gestión y manipulación de arrays, aspecto
este último en el que destaca especialmente el lenguaje PHP.
Este capítulo se centra en explicar los procesos de construcción de arrays y sus

características principales; para terminar abordando con detalle las funciones más
interesantes de manipulación de arrays.
Un array o matriz es un conjunto de datos que se almacenan bajo un nombre

común y a los que se puede acceder utilizando uno o más índices. En PHP los datos
que componen el array pueden ser de diferente tipo, de manera que en un único
array pueden almacenarse indistintamente cadenas de caracteres, valores
numéricos, otros arrays,... Una de las particularidades que distinguen a PHP de
otros lenguajes de programación surge a la hora de crear el array: no es necesario
determinar la dimensión antes de inicializarlo. Esto dota de una gran flexibilidad a
215
PHP Y MYSQL. TECNOLOGÍAS PARA EL DESARROLLO DE APLICACIONES WEB
los programas, pues permite la modificación posterior del array, suprimiendo o

añadiendo nuevos elementos cuando sea necesario.
8.1.1. CONSTRUCCIÓN DE ARRAYS

Los elementos que componen un array, como cualquier otro elemento, son
almacenados en una variable, para indicar que dicha variable contiene un array se
utilizan los caracteres [], situando entre ellos un índice numérico que permitirá
identificar a cada uno de los elementos individuales.
Ejemplo 8.1:
Una primera forma de definir un array consiste en asignar directamente sus valores,
por ejemplo, a continuación se define un array de nombre $x, con cuatro elementos
indexados numéricamente comenzando en la posición 0:
$x[0] = 1;
$x[1] = "¡¡hola!!";
$x[2] = 3;
$x[] = "Último";
A la hora de añadir un último elemento no es necesario indicar el índice

correspondiente. En este ejemplo, automáticamente se asigna a la posición 3.
Además, puede observarse cómo el array puede contener datos de tipos diferentes,
en este caso dos valores numéricos y dos cadenas de caracteres.
Como alternativa se podría haber creado e inicializado el anterior array con ayuda
de la función array(), de la siguiente forma:
$x = array(1, "¡¡hola!!",3, "Último");
En este caso no se han especificado índices y se consideran por defecto los valores
0, 1, 2…
Para acceder a cada uno de los elementos del array, de nuevo se utiliza el índice,
pudiéndose utilizar esos valores en una expresión como cualquier otra variable. Por
ejemplo:
$z = $x[0] + 5*$x[2];
216
ARRAYS
En este primer ejemplo se ha mostrado la forma de construir un array indexado

numéricamente; pero en PHP es posible indexar los elementos de cualquier array
con cadenas de caracteres, lo que permite al programador una identificación más
efectiva de sus elementos. Este tipo de arrays se conocen como arrays asociativos.
Ejemplo 8.2:
Supóngase que se desea almacenar los años de un conjunto de películas. Se puede
construir un array de elementos numéricos (los años) indexados mediante una
cadena de caracteres (el título de la película correspondiente).
$peliculasAño["La costilla de Adán"] = 1949;

$peliculasAño["La gran ilusión"] = 1937;
$peliculasAño["Roma, ciudad abierta"] = 1944;
$peliculasAño["Sabrina"] = 1954;
$peliculasAño["Vive como quieras"] = 1938;
Opcionalmente, con ayuda de la función array() se podría generar el array de la

siguiente manera:
$peliculasAño=array("La costilla de Adán" => 1949,

"La gran ilusión" => 1937,
"Roma, ciudad abierta" => 1944,
"Sabrina" => 1954,
"Vive como quieras" => 1938);
En este caso, al construir el array debe indicarse tanto la palabra clave que actúa de
índice como el valor asociado a ese elemento del array. Aunque el array se haya
construido con la función array(), en cualquier momento se podría añadir un
nuevo elemento:
$peliculasAño["West Side Story"] = 1961;
Para acceder a los elementos del array se utiliza de nuevo la palabra clave:
echo "El año de producción de la película <i>Sabrina</i>

es $peliculasAño[Sabrina]";
En el caso de que la palabra clave no contenga espacios en blanco, basta con

colocar dicha palabra entre los corchetes para acceder al elemento, pero cuando sí
contiene espacios en blanco o caracteres especiales, se debería dar, a su vez,
entrecomillada.
$a = $peliculasAño["Roma, ciudad abierta"];
217
Cualquier intento de acceso a un elemento del array mediante un índice

o palabra clave no definida produce una notificación de error por parte
del intérprete de PHP. Sin embargo, este tipo de errores no son
NOTA
considerados graves y las restantes sentencias del programa pueden
seguir siendo ejecutadas.
8.1.2. ARRAYS MULTIDIMENSIONALES
El lenguaje PHP permite la creación de arrays multidimensionales, es decir, arrays

cuyos elementos son nuevos arrays. La sintaxis es similar al caso de una
dimensión, siendo necesario indicar los dos índices por separado.
Ejemplo 8.3:
A continuación se crea un array de nombre $M y de dos dimensiones:
$M[0][0] = 5;
$M[0][1] = 3;
$M[1][0] = -2;
$M[1][1] = 7;
La definición equivalente usando la función array() sería:
$M=array(array(5,3),array(-2,7));
Para acceder a los elementos individuales del array se deberían utilizar los dos
índices:
$d = $M[0][0]*$M[1][1] - $M[0][1]*$M[1][0];
Por supuesto, es posible definir arrays asociativos multidimensionales, e incluso

combinar índices numéricos y alfabéticos
Ejemplo 8.4:
$pelicula["George Cukor"][1949] = "La costilla de Adán";
$pelicula["Jean Renoir"][1937] = "La gran ilusión";
$pelicula["Roberto Rossellini"][1944] = "Roma, ciudad
abierta";
$pelicula["Billy Wilder"][1954] = "Sabrina";
$pelicula["Frank Capra"][1938] = "Vive como quieras";
218
ARRAYS
Conviene advertir de la necesidad de tener especial cuidado al utilizar arrays

multidimensionales dentro de cadenas de caracteres ya que para que se expandan
correctamente deben ser encerrados entre llaves.
echo "Hoy se proyectará una producción de 1937 dirigida

por
Jean Renoir: {$pelicula["Jean Renoir"][1937]}";
Ejemplo 8.5:
También es posible indexar los elementos de un array multidimensional:
$peliculas = array(
"La costilla de Adán" =>
array("Director"=>"G. Cukor","Año"=>1949),
"La gran ilusión" =>
array("Director"=>"J. Renoir","Año"=>1937),
"Roma, ciudad abierta" =>
array("Director"=>"R. Rossellini","Año"=>1944),
"Sabrina" =>
array("Director"=>"B. Wilder, "Año"=>1954),
"Vive como quieras" =>
array("Director"=>"F. Capra","Año"=>1938)
);
echo "El director de la película

<i>Roma, ciudad abierta</i>
es
{$peliculas["Roma, ciudad abierta"]["Director"]}";
8.2. RECORRIDO DE TODOS LOS ELEMENTOS

DE UN ARRAY
Una vez creado e inicializado un array unidimensional o multidimensional, puede
que se esté interesado en mostrar o manipular todos sus elementos. Para mostrar
todos los elementos de un array, una primera opción es el uso de la función
print_r(), que aplicada sobre un array muestra en la página la estructura del
mismo de acuerdo al siguiente esquema:
([indice1]=>elemento1
[indice2]=>elemento2
....................
[indiceN]=>elementoN)
219
Para la manipulación de los elementos de arrays se dispone de estructuras iterativas

que simplifican la tarea, en particular, es de destacar una sentencia específica para
recorrer todos los elementos de un array:
foreach(array as valor)
Ejemplo 8.6:
La siguiente sentencia recorre todos los elementos de un array y los muestra en la
página:
$actors = array("Marlon Brando","Gary Cooper",

"Cary Grant","James Stewart");
foreach($actores as $nombre){
echo "$nombre <br>";
}
Cada elemento del array se asigna en cada iteración a una misma variable, (en el
ejemplo, la variable $nombre), que es la que se manipula. El ejemplo se limita a
imprimir uno a uno todos los nombres que componen el array. Se ha añadido un
comando <HTML> de cambio de línea de forma que cada nueva iteración comience
a escribir en un nuevo renglón. El resultado sería:
Marlon Brando
Gary Cooper
Cary Grant
James Stewart
Si además de recuperar los elementos del array, se desea también conocer el índice,
tanto en el caso de índices numéricos como en arrays asociativos, se puede utilizar

una sintaxis alternativa del bucle foreach:
foreach(array as índice => valor)
Ejemplo 8.7:
Dado el array y el bucle siguientes:
$películasAño = array("La costilla de Adán" => 1949,

"La gran ilusión" => 1937,
"Roma, ciudad abierta" => 1944,
"Sabrina" => 1954,
"Vive como quieras" => 1938);
foreach($películasAño as $indice => $valor){
220
ARRAYS
echo "<i>$indice,</i> ($valor) <br>\n";

}
el resultado generado sería:
La costilla de Adán, (1949)

La gran ilusión, (1937)
Roma, ciudad abierta, (1944)
Sabrina, (1954)
Vive como quieras, (1938)
También es posible construir bucles que recorran todos los elementos del array
usando las restantes estructuras iterativas. El problema que surge habitualmente es
que puede no saberse cuántos elementos existen en el array y cuáles son los índices
asociados a esos elementos, ya que una particularidad de los arrays de PHP es que
no es necesario que sus elementos tengan asociados índices numéricos
consecutivos. Estos problemas pueden salvarse mediante la función
each(array)
En cada llamada a dicha función se recupera un elemento del array; cuando se

alcance el final del array la función devuelve un valor booleano falso. Realmente,
en cada llamada a la función each() se recupera un array con dos elementos, el
primero el índice y el segundo el valor del correspondiente elemento del array. Se
puede utilizar la función list() para asignar esos dos elementos a sendas
variables y operar posteriormente con ellas. Esta función permite generar una lista
cuyos elementos son los argumentos que se pasen, cuando se asigna a esa lista un
array, PHP realiza una asignación elemento a elemento con las variables de la lista
y los elementos del array.
Ejemplo 8.8:
La siguiente estructura iterativa recorre e imprime todos los elementos del array
$actores:
while(list($ind,$nombre) = each($actores))
echo "$nombre <br>";
Mientras no se alcance el final del array, en cada iteración del ciclo, el índice del
elemento del array se almacena en la variable $ind y el elemento correspondiente
en la variable $nombre. Tras alcanzar el último elemento, la función
each()toma el valor falso y el ciclo while finaliza.
221
Por supuesto, también es posible utilizar estas estructuras iterativas anidadas para
recorrer arrays multidimensionales.
Ejemplo 8.9:
$peliculas=array(
"La costilla de Adán" =>
"La gran ilusión" =>
"Roma, ciudad abierta" =>
"Sabrina" =>
array("Director"=>"B. Wilder","Año"=>1954),
"Vive como quieras" =>
array("Director"=>"F. Capra","Año"=>1938)
);
foreach($peliculas as $indice => $titulo){
echo "Datos de $indice:<BR>\n";
foreach($titulo as $indice => $valor){
echo "&nbsp&nbsp $indice: $valor <BR>\n";
}
}
El resultado generado por estas estructuras iterativas es:
Datos de La costilla de Adán:

Director: G. Cukor
Año: 1949
Datos de La gran ilusión:
Director: J. Renoir
Año: 1937
Datos de Roma, ciudad abierta:
Director: R. Rossellini
Año: 1944
Datos de Sabrina:
Director: B. Wilder
Año: 1954
Datos de Vive como quieras:
Director: F. Capra
Año: 1938
222
ARRAYS
Cuando se desea conocer el número de elementos de un array, puede usarse la

función count(). Debe advertirse que esta función devuelve el número de
elementos del array y que esa cantidad no necesariamente coincide con el índice de
su último elemento, ya que en PHP no es necesario utilizar índices consecutivos
para los elementos del array.
Ejemplo 8.10:
A continuación se define una función de creación de tablas. Toma como argumento
un array bidimensional, que se asume indexado numéricamente con valores
0,1,2,..., y muestra todos sus elementos en una tabla HTML. La función también
recibe como argumentos un array con los rótulos de las columnas y otro con los
encabezamientos de las filas.
function crearTabla($a,$col,$f) {
echo "<TABLE BORDER CELLPADDING=5>";
//Cabecera
echo "<TR>";
echo "<TD>&nbsp</TD>";
for($i=0;$i<count($col);$i++){
echo "<TH>$col[$i]</TH>";
}
echo "</TR>";
// Cuerpo de la tabla
for($i=0;$i<count($a);$i++){
echo "<TR>";
// encabezado de la fila i-ésima
echo "<TH>$f[$i]</TH>";
// resto de la fila
for($j=0;$j<count($a[$i]);$j++){
echo "<TD>{$a[$i][$j]}</TD>";
}
echo "</TR>";
}
echo "</TABLE>";
}
Considérese, por ejemplo, la necesidad de mostrar una tabla de distancias

kilométricas entre una serie de ciudades, tal como se ve en la Figura 8.1. El
siguiente programa construye dicha tabla utilizando la función anterior y calcula la
distancia en kilómetros de una ruta determinada. Se asume que la función anterior
se encuentra definida en otro documento, de nombre funciones.php, y se utiliza la
función include() para incluirla.
223
Figura 8.1 Tabla de distancias kilométricas
<?php
include("funciones.php");
echo "<H2>Cálculo de distancias de rutas</H2><BR>";
$datos = array(array(0,100,124,198,235),
array(100,0,224,98,34),
array(124,224,0,115,56),
array(198,98,115,0,122),
array(235,34,56,122,0));
// Generación de los arrays de cabeceras
$cabecera = array();
for($i=0;$i<count($datos[0]);$i++){
$aux = $i+1;
$cabecera[$i] = "Ciudad $aux";
}
// Construcción de la tabla
crearTabla($datos,$cabecera,$cabecera);
// Determinación de la ruta
$ruta = array(1,3,5,1);
$suma = 0;
// Generación de una lista con los datos de cada etapa
echo "<UL>";
for($i=0;$i<count($ruta)-1;$i++){
$aux1 = $ruta[$i];
$aux2 = $ruta[$i+1];
$distancia = $datos[$aux1-1][$aux2-1];
224
ARRAYS
$suma += $distancia;
echo "<LI>De la ciudad $aux1 a la
ciudad $aux2: $distancia kilómetros";
}
echo "<B>Distancia total: $suma kilómetros</B>";
echo "</UL>";
?>
8.3. FUNCIONES DE MANIPULACIÓN DE

ARRAYS
En esta sección se describen las funciones más representativas a la hora de
manipular un array. Estas funciones permiten, entre otras cosas, la modificación de
los índices o de los elementos de un array, la subdivisión o prolongación, la
comparación de elementos entre arrays, la búsqueda de un índice o de un elemento
concretos, etc. Atendiendo a la tarea descrita se agruparán los diversos métodos en
categorías diferentes. Es de destacar la gran diversidad de funciones predefinidas
para la manipulación de arrays que existen en PHP.
8.3.1. TRANSFORMACIÓN DE LOS ÍNDICES

— array_change_key_case(array,caso): en el caso de arrays
asociativos, esta función devuelve un nuevo array pero transformando las
palabras clave a mayúsculas o minúsculas, según el argumento opcional
caso. Los valores posibles de este segundo argumento son las constantes
CASE_UPPER (conversión a mayúsculas) y CASE_LOWER (conversión a

minúsculas), siendo este último el valor por defecto.
Ejemplo 8.11:
El siguiente fragmento de código:
$actores["Primer actor"] = "Gary Cooper";

$actores["Segundo actor"] = "Cary Grant";
$actores["Tercer actor"] = "Spencer Tracy";
$actoresMay=array_change_key_case($actores,CASE_UPPER);
foreach($actoresMay as $indice => $valor)
echo "$indice: $valor <BR>\n";
225
produce la siguiente salida:
PRIMER ACTOR: Gary Cooper

SEGUNDO ACTOR: Cary Grant
TERCER ACTOR: Spencer Tracy
8.3.2. SUBDIVISIÓN
— array_chunk(array,dimensión,valor_booleano): el array dado

como argumento se subdivide en arrays más pequeños de dimensión la
indicada con el argumento dimensión. Se genera así un array
multidimensional de índices numéricos que comienzan con el valor 0. El
último parámetro es un valor booleano que indica si se desea conservar los
índices del array original en los diferentes subarrays. Este parámetro es
opcional, siendo su valor por defecto FALSE.
Ejemplo 8.12:
El siguiente código:
$oeste = array(
"Solo ante el peligro","Fred Zinnemann","Gary Cooper",
"Raíces profundas","George Stevens","Alan Ladd",
"Horizontes de grandeza","William Wyler");
$oesteOrdenado = array_chunk($oeste,3);
foreach($oesteOrdenado as $indice => $valor){
echo "$indice-> <BR>";
foreach($valor as $indice => $valor){

echo "&nbsp&nbsp&nbsp $indice-> $valor <BR>";
}
}
da lugar a la salida:
0->
0-> Solo ante el peligro
1-> Fred Zinnemann
2-> Gary Cooper
1->
0-> Raíces profundas
1-> George Stevens
2-> Alan Ladd
2->
226
ARRAYS
0-> Horizontes de grandeza

1-> William Wyler
Se ha considerado el valor por defecto del último argumento, lo que provoca que
cada nuevo subarray se numere desde 0. Si se quieren conservar los índices del
array original, se debe dar como tercer argumento el valor TRUE:
$oesteOrdenado = array_chunk($oeste,3,TRUE);
De esta manera, el resultado obtenido sería:
0->
0-> Solo ante el peligro
1-> Fred Zinnemann
2-> Gary Cooper
1->
3-> Raíces profundas
4-> George Stevens
5-> Alan Ladd
2->
6-> Horizontes de grandeza
7-> William Wyler
8.3.3. CONTABILIZACIÓN DE ELEMENTOS
— array_count_values(array): devuelve un array formado por valores

numéricos que representan el número de veces que cada elemento del array
inicial aparece repetido. Los índices de esta nueva matriz son cada uno de los
elementos iniciales.
— count(array): devuelve el número de elementos de un array. Es útil en

especial cuando se emplea un bucle for para acceder a cada elemento del
array.
Ejemplo 8.13:
$a = array("a", "b", "c", "a", "d", "e", "b", "d", "a");

$n = count($a);
echo "El array tiene $n letras, repartidas
de la siguiente manera: <BR>";
227
$c = array_count_values($a1);
foreach($c as $indice=>$valor)
El resultado generado sería:
El array tiene 9 letras, repartidas de la siguiente manera:

a: 3
b: 2
c: 1
d: 2
e: 1
8.3.4. BÚSQUEDA DE DATOS
Para la realización de procesos de filtrado y búsquedas sobre los elementos de un

array PHP dispone de funciones muy útiles. A continuación se presentan
brevemente alguna de ellas, acompañadas de sencillos ejemplos ilustrativos.
— array_filter(array,función): aplica una función de filtro booleana

a cada uno de los elementos de un array dado. Aquellos para los que se obtiene
el valor de retorno TRUE forman parte de un nuevo array de salida,
conservando sus índices originarios.
Ejemplo 8.14:
A continuación se muestra un ejemplo de selección de determinadas películas de

una lista en función de su año de producción. En concreto, se trata de conseguir de
las películas almacenadas, las realizadas desde el año 1960 en adelante:
function año($a){
return($a >= 1960);
}
$peliculas = array("El apartamento"=>1960,"Charada"=>1963,

"Doctor Zhivago"=>1965,"Gigí"=>1958,
"El gran dictador"=>1940,"El hombre tranquilo"=>1952,
"Lawrence de Arabia"=>1962,"West Side Story"=>1961
);
$selección = array_filter($peliculas,"año");
228
ARRAYS
foreach($seleccion as $indice=>$valor)
Como puede apreciarse, lo primero que se necesita es una función booleana que,
dado un elemento del array, indique si debe ser seleccionado o no. El nombre de
esa función es pasado a array_filter() como segundo argumento. El
resultado final del programa anterior sería:
El apartamento: 1960
Charada: 1963
Doctor Zhivago: 1965
Lawrence de Arabia: 1962
West Side Story: 1961
— array_keys(array,elemento): devuelve un array con los índices del array

dado como primer argumento. Opcionalmente, se pueden pedir únicamente aquellos
correspondientes a un elemento dado.
Ejemplo 8.15:
El siguiente programa lista los nombres de los actores que aparecen como claves en
un array asociativo:
$actores=array(
"Gary Cooper" => array("Solo ante el peligro",
"La gran prueba", "El secreto de vivir"),
"Cary Grant" => array("La fiera de mi niña",
"Arsénico por compasión","Historias de
Filadelfia"),
"Marlon Brando" => array("La ley del silencio",
"Sayonara","¡Viva Zapata!")
);
$busqueda=array_keys($actores);
foreach($busqueda as $indice=>$valor)
echo "$valor <br>\n";
Como resultado se obtiene la lista:
Gary Cooper
Cary Grant
Marlon Brando
229
Ejemplo 8.16:
En este segundo caso, se localizan los índices asociados a un determinado valor. En
concreto, se listan las películas almacenadas correspondientes al año 1940:
$peliculas=array(
"El apartamento"=>1960,"Charada"=>1963,
"Doctor Zhivago"=>1965,"Gigí"=>1958,
"El gran dictador"=>1940,"Historias de
Filadelfia"=>1940,
"El hombre tranquilo"=>1952,"Lawrence de Arabia"=>1962,
"Rebeca"=>1940
);
$busqueda=array_keys($peliculas,1940);
foreach($busqueda as $indice=>$valor)
echo "$valor <br>\n";
Se obtiene así el siguiente listado:
El gran dictador
Historias de Filadelfia
Rebeca
— array_key_exists(índice,array): función booleana que devuelve el valor

TRUE si el índice dado está en el array.
Ejemplo 8.17:
Dado el array $actores definido en el Ejemplo 8.15, se comprueba si el nombre
de un actor está entre las palabras claves del array, y en caso afirmativo se muestra
el listado de todas sus películas:
$actor="Gary Cooper";
if(array_key_exists($actor,$actores)) {
echo "<B>Películas de $actor:</B><BR>";
foreach($actores[$actor] as $indice=>$valor)
echo "$valor <BR>\n";
}
— array_rand(array,num_elementos): devuelve un array formado al

seleccionar aleatoriamente los índices correspondientes a un número de
elementos del array dado. El segundo parámetro es opcional, si no se indica se
asume el valor 1.
230
ARRAYS
Ejemplo 8.18:
En el siguiente ejemplo, se diseña una página de manera que cada vez que un
usuario accede a ella obtiene entradas gratis para dos películas de un ciclo de cine:
$peliculas=array("El halcón maltés","Laura","Cayo Largo",

"El sueño eterno","Forajidos");
// se obtienen al azar los índices de dos películas
$sorteo = array_rand($peliculas,2);
echo "<H2>¡Enhorabuena! Ha conseguido entradas gratis para
los pases de las siguientes películas del ciclo de
cine negro:</H2>";
// se muestran las películas seleccionadas
for ($i = 0; $i<count($sorteo); $i++ ){
$j = $sorteo[$i];
echo "<H3><I>$peliculas[$j]</I></H3>";
}
El resultado de la ejecución de este programa es una página como la que aparece en

la Figura 8.2; por supuesto, cada vez que se acceda a esa página el resultado varía,
ya que el sorteo se repite.
Figura 8.2 Resultado del sorteo
— array_search(elemento_buscado,array,valor_logico):
devuelve el índice de elemento_buscado si este pertenece al array dado.
En caso contrario, devuelve FALSE. Si dicho elemento aparece más de una vez
dentro del array, solo se obtiene el índice correspondiente a la primera
aparición. El tercer argumento es opcional y corresponde a un valor lógico que
231
indica si el elemento a buscar debe coincidir con el del array tanto en el valor
como en el tipo.
— array_values(array): devuelve una lista con todos los elementos del

array dado, donde ahora los índices son los numéricos por defecto,
independiente de los que tuviera previamente.
— in_array(elemento,array): busca un elemento dado dentro de un

array. Devuelve TRUE si dicho elemento pertenece al array, FALSE en caso
contrario.
8.3.5. GENERACIÓN DE ARRAYS

A continuación se recogen algunas funciones que permiten generar arrays a partir
de valores individuales o a partir de otros arrays.
— array_combine(índices,elementos): función que devuelve un

array formado por los elementos dados como segundo argumento. Se indexan
en correspondencia con el primer argumento de la función. Ambos argumentos
deben ser arrays. La función devuelve el valor FALSE si ambos argumentos no
tienen el mismo número de elementos.
— compact(ListaVariables): dada una lista de variables, se genera

un array asociativo con los valores de esas variables, utilizando como
palabras clave para los elementos del array el nombre de la
correspondiente variable. Las variables se pueden pasar o bien con
cadenas de caracteres conteniendo el nombre de las mismas, o bien

introduciendo dichos nombres en un array.
Ejemplo 8.19:
A partir de tres variables que almacenan los datos de una determinada película,
(título, director y año),
$película = "La diligencia";

$director = "J. Ford";
$año = 1939;
se desea generar un array formado por esos tres elementos e indexados con el
nombre de sus respectivas variables. Esto se podría hacer de dos maneras:
232
ARRAYS
$listaAux=array("pelicula","director","año");
$lista=compact($listaAux);
o bien:
$lista=compact("pelicula","director","año");
— extract(array,extracción): este método procede de forma inversa al

anterior. En este caso, a partir de un array con elementos indexados se genera
una serie de variables de nombre igual a cada uno de los índices y de valor el
elemento correspondiente. De forma opcional se puede indicar la forma de
extracción, es decir qué hacer si existe una variable inicializada previamente y
de nombre igual a alguno de los índices. En concreto, algunos de los valores
que puede tomar el segundo argumento son las constantes:
EXTR_OVERWRITE: la variable ya existente toma el nuevo valor. Este es

el valor que se toma por defecto.
EXTR_SKIP: la variable ya existente no modifica su valor.
EXTR_PREFIX_SAME: se añade un prefijo (tercer argumento en forma de
cadena de caracteres) a la nueva variable.
EXTR_PREFIX_ALL: se añade un prefijo a todas las variables.
Ejemplo 8.20:
A continuación se crean tres variables a partir de los índices de un array dado y se
inicializan automáticamente con los valores correspondientes. Obsérvese que
previamente a la construcción del array y a la llamada a la función extract(),
ya se ha inicializado una variable de nombre idéntico a uno de los índices del array.
$titulo = "Misión de audaces";

$película = array("titulo"=>"La diligencia",
"director"=>"J. Ford",
"protagonista"=>"J. Wayne");
extract($pelicula);
echo "$titulo, de "$director, con "$protagonista";
Al no indicarse forma de extracción, la variable $titulo toma el nuevo valor,

con lo que el mensaje que se genera es:
La diligencia, de J. Ford, con J. Wayne
233
Si en lugar de la llamada a la función extract() con un solo parámetro, se hace la

llamada siguiente:
extract($pelicula,EXTR_SKIP);
el resultado sería:
Misión de audaces, de J. Ford, con J. Wayne
— range(inicio,final,aumento): se genera un array numérico o de

caracteres, comenzando en el valor inicial hasta llegar al valor final dado.
Como argumento opcional, se incluye el criterio de paso de un elemento a otro,
cuyo valor por defecto es 1. Este tercer argumento fue incorporado en la
versión 4.4 del lenguaje. La Tabla 8.1 muestra algunos ejemplos de uso de la
función range().
Sentencia Array generado

range(3,15) (3,4,5,6,7,8,9,10,11,12,13,14,15)
range(15,3) (15,14,13,12,11,10,9,8,7,6,5,4,3)
range(3,10,2) (3,5,7,9)
range('b','k') ('b','c','d','e','f','g','h','i','j','k')
range('k','b') ('k','j','i','h','g','f','e','d','c','b')
range('casa','gato') ('c','d','e','f','g')
Tabla 8.1 Ejemplos de usos de la función range()
— array_slice(array,fragmento,dimensión): se obtiene un array a

partir de determinados elementos de uno dado. Estos elementos se determinan

con ayuda de los argumentos fragmento y dimensión, de acuerdo a los
siguientes criterios:
Si fragmento es positivo, indica la posición a partir de la cual se
extraen los elementos de la matriz dada.
Si fragmento es negativo, extrae elementos comenzando por el final
del array. El número de elementos a extraer coincide en este caso con
el valor sin signo de fragmento.
Si se indica el argumento dimensión, este representa el número de
elementos a extraer, en el caso de ser positivo, o el número de
elementos a dejar en el array, en el caso de que sea negativo.
234
ARRAYS
La Tabla 8.2 muestra algunos sencillos ejemplos del uso de esta función.
Sentencia Array generado

$a = array(1,2,3,4,5,6)
array_slice($a,3) (4,5,6)
array_slice($a,-2) (5,6)
array_slice($a,3,2) (4,5)
array_slice($a,-2,1) (5)
array_slice($a,1,-2) (2,3,4)
array_slice($a,-4,-2) (3,4)
Tabla 8.2 Ejemplos de uso de la función array_slice()
— array_splice(array,frag,dim,nuevo): si no se especifica como
cuarto argumento una lista de elementos nuevos, este método funciona
exactamente igual que el anterior. En caso contrario, estos nuevos elementos
sustituyen a los eliminados.
Ejemplo 8.21:
Las siguientes sentencias permiten apreciar el funcionamiento de esta función:
$a = array(1,2,3,4,5,6);
print_r($a);
print "<br>";
/* inserción de tres nuevos elementos, en sustitución del
cuarto y el quinto: a1=(1,2,3,0,1,2,6) */
array_splice($a,3,2,array(0,1,2));
print_r($a);
print "<br>";
El resultado de la ejecución de estas sentencias es:
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 )
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 0 [4] => 1 [5] => 2 [6] => 6 )
Ejemplo 8.22:
El siguiente ejemplo muestra una página de actualización del listado de directores
de los que se tienen películas disponibles.
$directores = array("Frank Capra","John Ford",

"Elia Kazan","Jean Renoir",
"Roberto Rossellini","William Wyler");
235
//Lista de directores dados de baja

$directoresAus = array("Jean Renoir","William Wyler");
// bucle que recorre todos los directores dados de baja

for($i=0;$i<count($directoresAus);$i++){
// se comprueba si pertenece a la lista general
if(in_array($directoresAus[$i],$directores)){
// en caso afirmativo se accede a su índice
$posicion = array_search($directoresAus[$i],
$directores);
//y se procede a la sustitución
array_splice($directores,$posicion,1,
"$directoresAus[$i]=><b>No
disponible</b>");
}
}
echo "<H2>Bienvenido. Esta es nuestra lista
actualizada de directores</H2>";
foreach($directores as $indice=>$valor)
echo "<i>$valor</i> <br>";
La página generada por este programa puede ver en la Figura 8.3.

Figura 8.3 Lista de directores
236
ARRAYS
8.3.6. PROLONGACIÓN O TRUNCAMIENTO DE UN

ARRAY
— array_fill(índice,cantidad,elemento): función que devuelve

un array en el que se ha introducido un elemento dado tantas veces como se
desee a partir de un índice también dado.
— array_pad(array,tamaño_final,elemento_nuevo): prolonga el
array dado con un nuevo elemento, hasta completar el tamaño especificado. La
prolongación se realiza por la derecha o por la izquierda, dependiendo de si el
valor del argumento tamaño_final es positivo o negativo,
respectivamente. El correcto funcionamiento de la operación exige que el
tamaño especificado en el argumento sea mayor que la dimensión del array.
— array_pop(array): extrae el último elemento de una matriz dada,

quedando esta modificada con un elemento menos.
— array_push(array,elemento1,elemento2,...): añade al array

dado los elementos que se indican como argumentos. La función devuelve la
nueva dimensión del array.
— array_shift(array): extrae el primer elemento del array dado,

quedando este modificado con un elemento menos.
— array_unique(array): elimina los elementos repetidos del array dado,

conservándose únicamente la primera posición encontrada de dichos
elementos. La función devuelve un nuevo array, manteniendo los índices

anteriores de sus elementos.
Ejemplo 8.23:
La función array_unique() considera elementos iguales aquellos cuya
representación en forma de cadena es idéntica. Este ejemplo ilustra su
funcionamiento:
$a = array(1,2,"1",3,4,5,"4",6,7,"6",8,6);
$b = array_unique($a);
foreach($b as $indice=>$valor)
237
El resultado obtenido es:
0: 1
1: 2
3: 3
4: 4
5: 5
7: 6
8: 7
10: 8
— array_unshift(array,elementos): función que añade al inicio del

array dado los elementos indicados como argumentos y devuelve el número de
elementos del nuevo array.
8.3.7. COMBINACIÓN DE ARRAYS
— array_merge(array1,array2,array3,...): devuelve un nuevo

array formado uniendo todos los elementos de los arrays pasados como
argumentos. Si dos o más elementos tienen el mismo índice alfabético en
varios de los arrays iniciales, se incluye en la unión el último de ellos.
Ejemplo 8.24:
A continuación se muestra la unión de dos arrays asociativos en los que una de las
claves se repite en ambos.
$peliculas1 = array(
"B. Wilder"=>"Primera plana",
"J. Ford"=>"Río Grande",
"G. Cukor"=>"Cena a las ocho");
$peliculas2 = array(
"F. Capra"=>"Sucedió una noche",
"B. Wilder"=>"Sabrina",
"W. Wyler"=>"Horizontes de grandeza");
$p = array_merge($peliculas1,$peliculas2);
Como resultado de la unión se generaría un array $p con los siguientes elementos:
("B. Wilder"=>"Sabrina", "J. Ford"=>"Río Grande",

"G. Cukor"=>"Cena a las ocho", "F. Capra"=>"Sucedió una noche",
"W. Wyler"=>"Horizontes de grandeza").
238
ARRAYS
— array_diff_assoc(array1,array2,array3,...): función que

devuelve un array formado por los elementos del array dado como primer argumento
y que no se encuentren en ninguno de los restantes arrays. Los índices de los
elementos se tienen en cuenta en la comparación, es decir, un mismo valor pero
asociado a índices diferentes en los dos arrays no se considera igual.
— array_diff(array1,array2,array3,...): a diferencia de la función

anterior, aquí no se tienen en cuenta los índices, se comparan exclusivamente los
valores de los elementos; por lo demás el funcionamiento de la función es el mismo.
— array_intersect_assoc(array1,array2,array3,...): devuelve un
array con los elementos comunes a todos los argumentos de la función. En la
comparación se tienen en cuenta los índices.
— array_intersect(array1,array2,array3,...): a diferencia de la
función anterior, en este caso, se realiza la intersección pero los índices de los
elementos no se tienen en cuenta en la comparación.
Ejemplo 8.25:
Dados los siguientes arrays:
$oeste = array("a"=>"J. Ford", "b"=>"W. Wyler",

"c"=>"H. Hawks", "d"=>"G. Stevens");
$comedia = array("a"=>"J. Ford", "b"=>"F. Capra",
"c"=>"G. Cukor", "d"=>"H. Hawks");
$drama = array("a"=>"W. Wyler", "b"=>"D. Sirk",
"c"=>"R. Walsh", "d"=>"G. Cukor");
Si se realiza la operación:
$c = array_diff_assoc($oeste,$comedia,$drama);
se obtendría un array con los siguientes elementos:
("b"=>"W. Wyler", "c"=>"H. Hawks", "d"=>"G. Stevens")
pues, si bien los tres primeros elementos del array $oeste se repiten en posteriores
arrays, únicamente el primero de ellos aparece repetido con el mismo índice.
Si en lugar de utilizar la función array_dic_assoc() se ejecuta la siguiente
sentencia:
$c = array_diff ($oeste,$comedia,$drama);
239
el array $c sería:
("d"=>"G. Stevens")
ya que ahora los tres primeros elementos del array $oeste deberían ser
eliminados al estar repetidos en los otros, aunque los índices o palabras clave
puedan ser iguales.
8.3.8. APLICACIÓN DE FUNCIONES
— array_map(función,array1,array2,...): función que devuelve

un nuevo array donde cada uno de sus elementos es el resultado de aplicar la
función dada como primer argumento, a los elementos respectivos elementos
de array1, array2,…. El número de argumentos de función deberá
coincidir con el de arrays dados. En cuanto a la longitud de estos, si es
diferente, el de menor número de elementos se prolonga con elementos vacíos.
Ejemplo 8.26:
El siguiente programa toma una lista con los nombres y apellidos de una serie de
directores de cine. El objetivo es crear una lista nueva donde el nombre de cada
director aparece solo con su inicial. En el programa se utilizan algunas funciones
de manipulación de cadenas de caracteres que serán estudiadas con más detalle en
el próximo capítulo.
/* función que toma la primera palabra de una cadena y la

transforma en su inicial seguida de un punto. */

function abreviar($cadena){
// primera palabra de la cadena
$separacion = strtok($cadena," ");
// concatenación de la inicial con un punto
$abrev = substr($separacion,0,1).".";
// generación de la cadena resultado
return(str_replace($separacion,$abrev,$cadena));
}
// Definición del array

$directores=array("D1"=>"Charles Chaplin",
"D2"=>"Stanley Donen","D3"=>"John Ford",
"D4"=>"David Lean","D5"=>"Vincent Minnelli");
// Aplicación de la función sobre cada director
240
ARRAYS
$directoresAbrev = array_map("abreviar",$directores);
// Impresión del resultado
foreach($directoresAbrev as $indice=>$valor){
echo "$indice -> $valor<BR>";
}
La salida generada por el programa es:
D1 -> C. Chaplin
D2 -> S. Donen
D3 -> J. Ford
D4 -> D. Lean
D5 -> V. Minnelli
Ejemplo 8.27:
En el caso de considerar más de un array, la función a aplicar debe tener más de un
argumento. El siguiente programa muestra un ejemplo de esta situación:
function union($a1,$a2){
return("El Óscar del año $a1 es $a2.");
}
$años = array(1940,1945,1951,1955,1960);
$peliculas = array("Rebeca","Días sin huella",
"Un americano en París","Marty",
"El apartamento");
$oscar = array_map("union",$años,$peliculas);
Tras aplicar la función array_map(), el array $oscar tendría el siguiente

contenido:
(0=>" El Óscar del año 1940 es Rebeca.",

1=>" El Óscar del año 1945 es Días sin huella.",
2=>" El Óscar del año 1951 es Un americano en París.",
3=>" El Óscar del año 1955 es Marty.",
4=>" El Óscar del año 1960 es El apartamento.")
Ejemplo 8.28:
Con la ayuda de la función array_map() es posible construir un array
multidimensional a partir de una serie de arrays unidimensionales. En el siguiente
ejemplo se muestra el proceso:
241
$películas = array("El apartamento","Charada",

"Doctor Zhivago","Gigí",
"El gran dictador","El hombre
tranquilo");
$directores = array("B. Wilder","S. Donen","D. Lean",
"V. Minnelli","C. Chaplin","J. Ford");
$a = array(1960,1963,1965,1958,1940,1952);
//Se incluye como primer argumento null

$listado=array_map(null,$peliculas,$directores,$a);
Si se indica como primer argumento de la función array_map() la palabra

null, no se considerará ninguna función a aplicar y lo que se generará es un array
bidimensional en el que cada elemento es un array con el título de la película, su
director y su año de realización.
— array_walk(array,nombreFunción,argumentos): aplica una

función determinada a cada elemento de la matriz dada y a su correspondiente
clave. Los argumentos de la función aplicada deben ser, por este orden:
elemento, índice, otros argumentos.
Ejemplo 8.29:
Dado un array de años, correspondientes a películas dadas como índices, a continuación
se utiliza la función array_walk() para escribir en la página un listado con el título
de cada película junto con su año entre paréntesis. Para ello se define previamente una
función que realiza genera el mensaje correspondiente a cada película, y se pasa como
segundo argumento a array_walk() el nombre de esa función:
function unir($a,$b){
echo "$b, ($a).<BR>";
}
$peliculas = array(
"El apartamento"=>1960,
"Charada"=>1963,
"Doctor Zhivago"=>1965,
"Gigí"=>1958,
"El gran dictador"=>1940,
"Historias de Filadelfia"=>1940,
"El hombre tranquilo"=>1952,
"Lawrence de Arabia"=>1962,
"Rebeca"=>1940
);
242
ARRAYS
array_walk($peliculas,'unir');
El resultado final de la llamada a esta función es:
El apartamento, (1960).
Charada, (1963).
Doctor Zhivago, (1965).
Gigí, (1958).
El gran dictador, (1940).
Historias de Filadelfia, (1940).
El hombre tranquilo, (1952).
Lawrence de Arabia, (1962).
Rebeca, (1940).
En la llamada a array_walk() se pueden pasar argumentos adicionales que serán

enviados a la función a evaluar junto con el índice y valor de cada elementos del
array. Por ejemplo, definiendo la siguiente función:
function unir2($a,$b,$cadena){
echo "$b, $cadena $a.<BR>";
}
la sentencia
array_walk($peliculas,'unir2',"película realizada en ");
generaría una salida como esta:

El apartamento, película realizada en 1960.

Charada, película realizada en 1963.
Doctor Zhivago, película realizada en 1965.
Gigí, película realizada en 1958.
El gran dictador, película realizada en 1940.
Historias de Filadelfia, película realizada en 1940.
El hombre tranquilo, película realizada en 1952.
Lawrence de Arabia, película realizada en 1962.
Rebeca, película realizada en 1940.
243
8.3.9. ORDENACIÓN DE LOS ELEMENTOS DE UN

ARRAY
En el aspecto de funciones de ordenación de arrays, PHP destaca especialmente por

la disponibilidad de un buen número de funciones diferentes.
— asort(array) y arsort(array): estas funciones permiten ordenar los

elementos de una lista dada, bien en orden ascendente (asort) o descendente
(arsort). Su particularidad es que cada elemento conserva su índice original.
Ejemplo 8.30:
Dado el array del Ejemplo 8.29, si se desea que la lista mostrada incluya las
películas en orden cronológico, desde la más actual a la más antigua, podría
realizarse una simple llamada a la función arsort() antes de la llamada a
array_walk(). La ordenación se produce sobre el valor de los elementos del
array, permaneciendo la clave de cada uno inalterada.
arsort($peliculas);
array_walk($peliculas,'unir',"película realizada en ");
La salida obtenida sería:


— ksort(array) y krsort(array): ordenan los elementos del array según

el índice o clave correspondiente, bien en orden ascendente (ksort) o inverso
(krsort). Se mantiene la relación entre índice y valor del elemento.
Ejemplo 8.31:
Si en el ejemplo anterior se opta por el orden inverso de los índices:
244
ARRAYS
krsort($peliculas);
el resultado sería:

— natsort(array) y natcasesort(array): estas dos funciones

ordenan cadenas alfanuméricas de un array dado atendiendo al orden alfabético
natural. La diferencia entre ambos es que natcasesort() no distingue
entre mayúsculas y minúsculas. Se conserva la relación entre índice y
elemento.
— array_reverse(array): devuelve un nuevo array con los elementos del

array original, pero dispuestos en orden inverso.
— sort(array) y rsort(array): estos métodos reordenan los

elementos de una matriz en orden ascendente o inverso, respectivamente. Los
índices se reasignan según la nueva disposición.
Ejemplo 8.32:
Como ejemplo final, se crea a continuación una tabla a partir de un array de

películas. Las películas serán clasificadas atendiendo a su director y a su año de
producción. La página generada por el programa es la que se muestra en la Figura
8.4.
Los datos a partir de los que se generará la tabla se encuentran almacenados en el

siguiente array bidimensional:
$películas = array(
"Ariane"=>
"La costilla de Adán"=>
"La gran ilusión"=>
245
"El héroe solitario"=>

"Historias de Filadelfia"=>
"Roma, ciudad abierta"=>
"Vive como quieras"=>
array( "Director"=>"F. Capra","Año"=>1938)
);
El programa que genera la tabla es:
echo "<H2>Películas disponibles</H2><BR>";

// array de encabezados de filas: años de producción
$filas = array();
$i = 0;
foreach($peliculas as $titulo){
$filas[$i] = $titulo["Año"];
$i++;
}
// eliminación de años repetidos
$filas = array_unique($filas);
// ordenación en orden ascendente
sort($filas);
// array con nombres de directores
$columnas = array();
$i = 0;
foreach($peliculas as $titulo){
$columnas[$i] = $titulo["Director"];
$i++;
}
// eliminación de repetidos
$columnas = array_unique($columnas);
// ordenación alfabética por apellidos
function extraer($cadena){
return(strchr($cadena," "));
}
$columnasAbrev = array_map("extraer",$columnas);
natcasesort($columnasAbrev);
$indices = array_keys($columnasAbrev);
// encabezados ordenados de las columnas
$columnasOrdenado = array();
for($i=0;$i<count($indices);$i++){
$columnasOrdenado[$i] = $columnas[$indices[$i]];
}
// construcción de la tabla
echo "<TABLE BORDER CELLPADDING=5>\n";
246
ARRAYS
echo "<TR>";
echo "<TD>&nbsp</TD>";
for($i=0;$i<count($columnasOrdenado);$i++){
echo "<TH>$columnasOrdenado[$i]</TH>";
}
echo "</TR>";
// lista con los títulos que hay que colocar en la tabla
$datos = array_keys($peliculas);
// en cada año se recorren los nombres ordenados de los

// directores y se disponen en la fila los títulos de ese
// año que correspondan a uno o a varios de los directores
for($i=0;$i<count($filas);$i++){
echo "<TR>";
echo "<TH>$filas[$i]</TH>";
for($j=0;$j<count($columnasOrdenado);$j++){
// se obtiene la lista de películas
correspondientes
// a la pareja director - año
$ps=array_keys($peliculas,
array("Director"=>$columnasOrdenado[$j],
"Año"=>$filas[$i]));
// si hay alguna película se crea la celda con
// los títulos obtenidos
if(count($ps)!=0){
echo "<TD ALIGN=CENTER>";
for($k=0;$k<count($ps);$k++){
echo $ps[$k]."<br>";
}
echo "</TD>";
}
// en caso contrario la celda es vacía
else
echo "<TD ALIGN=CENTER>"."----------"."</TD>";
}
echo "</TR>";
}
echo "</TABLE>";
247
Figura 8.4 Página con la tabla de películas disponibles

248
FUNCIONES
PREDEFINIDAS
9.1. INTRODUCCIÓN
PHP cuenta con un gran número de funciones predefinidas, más de 700, que
pueden ser usadas en cualquier programa sin necesidad de invocar a ninguna

librería. En el capítulo previo ya han sido presentadas muchas de ellas, en
concreto, las relacionadas con el tratamiento y manipulación de arrays. En este
capítulo se presentarán algunas funciones predefinidas adicionales,
clasificándolas en diversos grupos atendiendo al cometido al que están
destinadas. Se empezará por presentar funciones de manipulación de cadenas de
caracteres, para finalizar con el repaso a las funciones de fechas y horas, y una
lista de funciones matemáticas. En capítulos posteriores del libro se presentarán
nuevas funciones, como son las relacionadas con ficheros y directorios,
funciones de conectividad a base de datos,...
249
9.2. FUNCIONES DE MANIPULACIÓN DE

CADENAS DE CARACTERES
9.2.1. RECONOCIMIENTO DE CARACTERES

Las funciones de tipo booleano que a continuación se detallan permiten detectar los
diversos tipos de caracteres que constituyen una cadena determinada. En concreto,
pueden resultar muy útiles para realizar operaciones de validación de los datos que
los usuarios introducen en los formularios. A esta categoría pertenecen las
funciones siguientes:
— ctype_alnum(cadena): devuelve TRUE si cada carácter de la cadena es

alfanumérico (letra o un número), FALSE en caso contrario.
— ctype_alpha(cadena): devuelve TRUE si cada carácter de la cadena es
una letra, FALSE en caso contrario.
— ctype_digit(cadena): devuelve TRUE si cada carácter de la cadena es
un dígito decimal, FALSE en caso contrario.
— ctype_lower(cadena): devuelve TRUE si cada carácter de la cadena es
una letra minúscula, FALSE en caso contrario.
— ctype_upper(cadena): devuelve TRUE si cada carácter de la cadena es
una letra mayúscula, FALSE en caso contrario.
— ctype_print(cadena): devuelve TRUE si cada carácter de la cadena es
un carácter imprimible (letras, dígitos, signos, espacios en blanco,…)

— ctype_punct(cadena): devuelve TRUE si cada carácter de la cadena es
imprimible pero no es ni una letra, ni un dígito ni un espacio en blanco.
— ctype_space(cadena): devuelve TRUE si cada carácter de la cadena es
un espacio en blanco, considerando como espacios en blanco también las
tabulaciones, retornos de carro,...
9.2.2. CONVERSIONES ENTRE CADENAS Y ARRAYS

En muchas ocasiones se necesita obtener cadenas de caracteres a partir de los
elementos de un array, o al revés, "trocear" una cadena de caracteres para formar
un array con los elementos resultantes. Para este tipo de labores PHP dispone de las
siguientes funciones:
250
FUNCIONES PREDEFINIDAS
— explode(separador,cadena,límite): función que devuelve un array

resultado de fragmentar una cadena dada en segmentos delimitados por una cadena
de separación, (un espacio en blanco, por ejemplo). Si no se indica límite, cada
elemento del array es uno de esos segmentos. En caso contrario, este valor indica el
número exacto de elementos que debe tener el array de salida. El último de ellos
corresponderá al final de la cadena que no haya podido fragmentarse.
— implode(separador,array) y join(separador,array):
funciones que disponen los elementos de un array dado en una cadena
de caracteres, pero separados por la cadena dada como primer
argumento. Ambas funciones actúan de igual forma.
Ejemplo 9.1:
La sentencia
explode(" ","Hola, ¿qué tal?");
genera un array de 3 cadenas de caracteres:
([0] => Hola, [1] => ¿qué [2] => tal?)
Si al hacer la llamada a la función explode() se añade un valor límite
explode(" ","Hola, ¿qué tal?", 2);
el array que se obtendría es:
([0] => Hola, [1] => ¿qué tal? )

Ejemplo 9.2:
En el siguiente programa, dado un array de arrays, se aplica la función implode() a
cada uno de sus elementos para obtener una serie de cadenas de caracteres.
$peliculasMusicales=array(
array("Un americano en París","V. Minnelli",1951),
array("Hello,Dolly!","G. Kelly",1968),
array("¡Qué noche la de aquel día!","R. Lester",1964));
foreach($peliculasMusicales as $pelicula){
$p = implode("--->",$pelicula);
print "$p<BR>";
}
251
El resultado generado es:
Un americano en París--->V. Minnelli--->1951

Hello, Dolly!--->G. Kelly--->1968
¡Qué noche la de aquel día!--->R. Lester--->1964
— str_word_count(cadena,formato): contabiliza el número de

palabras que forman una cadena dada. Si no se especifica ningún formato,
se obtiene un número entero. Si el argumento formato toma el valor 1,
entonces la función devuelve un array con todas las palabras de la cadena;
si ese argumento es 2, devuelve el array con las palabras, pero asociando a
cada una como índice del array la posición que ocupa dentro de la cadena.
Ejemplo 9.3:
Dada la siguiente cadena:
$cadena = "Bienvenido a nuestro cine.";
la sentencia
str_word_count($cadena);
devuelve el número de palabras que forman la frase indicada, es decir, 4.
Si la llamada se realiza de la siguiente forma:
str_word_count($cadena,1);
la función devolvería es siguiente array:
([0] => Bienvenido, [1] => a, [2] => nuestro, [3] => cine)
En cambio, con la llamada
str_word_count($cadena,2);
el array generado sería:
([0] => Bienvenido, [11] => a, [13] => nuestro, [21] => cine)
252
9.2.3. PROLONGACIÓN DE UNA CADENA

— str_pad(cadena,longitud,cadena_añadida,clase_adición)
: devuelve una nueva cadena formada al prolongar la cadena dada al inicio, al
final o en ambos lados hasta completar la longitud indicada. Si no se indica una
nueva cadena, la prolongación se realiza con espacios en blanco. El tipo de
prolongación viene determinado por el cuarto argumento de la función, cuyo
valor pueder ser:
STR_PAD_RIGHT: prolongación al final de la cadena. Valor por defecto.

STR_PAD_LEFT: prolongación al inicio.
STR_PAD_BOTH: prolongación en ambas direcciones.
Si la longitud indicada es negativa o menor que la de la cadena inicial, no se

efectúa la prolongación.
Ejemplo 9.4:
Considérese una cadena de 27 caracteres de longitud, si se quiere prolongarla a
ambos lados con 16 caracteres, repartidos a partes iguales a ambos lados, el código
necesario sería el siguiente:
echo str_pad("¡Bienvenido a nuestro cine!",

41,"********",STR_PAD_BOTH);
generándose de este modo la cadena
********¡Bienvenido a nuestro cine!********

Si como longitud se indica 30, 3 más que la inicial, aunque la nueva cadena aporte
8 caracteres, se truncará en 3, repartidos a izquierda y derecha. Así, el código:
echo str_pad("Bienvenido a nuestro cine",

30,"********",STR_PAD_BOTH);
genera la cadena:
*Bienvenido a nuestro cine**
— str_repeat(cadena,número): devuelve una cadena formado al repetir

la cadena dada tantas veces como se indica en el segundo argumento.
253
Ejemplo 9.5:
La sentencia:
echo str_repeat("oOoxXx",5);
genera el siguiente mensaje:
oOoxXxoOoxXxoOoxXxoOoxXxoOoxXx
9.2.4. MODIFICACIÓN DE UNA CADENA

— str_replace(buscar,reemplazar,cadena): función que devuelve
una nueva cadena como resultado de reemplazar en la cadena dada todas las
apariciones del argumento buscar por el argumento reemplazar.
Ejemplo 9.6:
Dadas las variables
$cadena = "Bienvenido a nuestro cine.";

$nombreCliente = "Pablo González";
la sentencia
echo str_replace(".", ", $nombreCliente.", $cadena);
escribiría el siguiente mensaje:

Bienvenido a nuestro cine, Pablo González.
— strrev(cadena): devuelve una nueva cadena como resultado de invertir la

cadena original.
— strtolower(cadena) y strtoupper(cadena): funciones que, dada una

cadena, generan otra transformando todos los caracteres a minúsculas o a
mayúsculas, respectivamente.
— substr_replace(cadena,reemplazar,posición,longitud): dada
una cadena inicial se obtiene una nueva cadena como resultado de reemplazar
la porción delimitada por los argumentos posición y longitud, por el
254
argumento reemplazar. Se deben tener en cuenta las siguientes

consideraciones:
• Si el valor de posición es positivo, la sustitución comienza

en la posición correspondiente de la cadena; mientras que si es
negativo, la sustitución comienza en la posición correspondiente
de la cadena pero contando desde el final de la misma.
• Si no se especifica el argumento longitud, se entiende que la
sustitución se realiza hasta el final de la cadena. Por el
contrario, si su valor es positivo indica la porción de cadena a
sustituir, y si es negativo indica el número de caracteres,
contados desde el final de la cadena, que deben quedar intactos.
En todo caso se considera que la posición del primer carácter es
0.
Ejemplo 9.7:
Dadas las cadenas
$cadena = "Bienvenido a nuestro cine. Ha efectuado usted

la
decisión correcta.";
$nombreCliente = ", Pablo González. ";
las llamadas siguientes
substr_replace($cadena,$nombreCliente,25,1);
substr_replace($cadena,$nombreCliente,25,-41);
substr_replace($cadena,$nombreCliente,-42,1);
substr_replace($cadena,$nombreCliente,-42,-41);
generan todas el mismo resultado, la cadena
Bienvenido a nuestro cine, Pablo González. Ha efectuado usted la decisión

correcta.
— ucfirst(cadena): convierte a mayúsculas el primer carácter de la cadena

dada.
— ucwords(cadena): convierte a mayúsculas el primer carácter de cada

palabra de la cadena dada.
255
9.2.5. COMPARACIÓN DE CADENAS

— strcasecmp(cadena1,cadena2) y strcmp(cadena1,cadena2):
comparan dos cadenas dadas según el orden establecido por los códigos ASCII
de sus respectivos caracteres (orden computacional). Ambas funciones
devuelven un valor menor que 0 si cadena1 es menor que cadena2; un
valor mayor que 0 si cadena1 es mayor que cadena2 y 0 si ambas son
iguales. La única diferencia entre las dos funciones es que la segunda distingue
mayúsculas y minúsculas.
— strnatcasecmp(cad1,cad2) y strnatcmp(cad1,cad2):
comparan cadenas alfanuméricas teniendo en cuenta el orden alfabético
natural. Se obtiene un valor menor que 0 si la primera cadena es menor
que la segunda; un valor mayor que 0 si es mayor y 0 si ambas son
iguales. La única diferencia entre ambas funciones es que la primera no
distingue entre mayúsculas y minúsculas.
Ejemplo 9.8:
La comparación de cadenas alfabéticas como las siguientes da el mismo resultado
independientemente de la función de comparación empleada:
strcasecmp("Pedro Colsa", "pedro colsa"); // devuelve 0

strcmp("Pedro Colsa", "pedro colsa"); // devuelve -1
strnatcasecmp("Pedro Colsa","pedro colsa"); // devuelve 0
strnatcmp("Pedro Colsa","pedro colsa"); // devuelve -1
En el caso de cadenas alfanuméricas, el resultado varía:

//orden computacional: a11 < a2

strcasecmp("a11","a2"); // devuelve -1
strcmp("a11","a2"); // devuelve -1
//orden lógico: a11 > a2
strnatcasecmp("a11","a2"); // devuelve 1
strnatcmp("a11","a2"); // devuelve 1
9.2.6. BÚSQUEDA DE DATOS

— strchr(cadena,carácter) y strrchr(cadena,carácter):
encuentran la primera y última aparición, respectivamente, de un carácter en
256
una cadena dada. Devuelven la cadena inicial desde la posición localizada

hasta el final.
— stristr(cadena,fragmento) y strstr(cadena,fragmento):
devuelven la cadena dada desde la primera aparición de un carácter o
fragmento determinado. Si el fragmento no se encuentra, se obtiene el valor
booleano FALSE. La diferencia entre ambos métodos es que el primero no
distingue entre mayúsculas y minúsculas.
— strpos(cadena,fragmento,inicio_búsqueda): se obtiene la
posición correspondiente a la primera aparición de un fragmento determinado
dentro de una cadena dada. Como tercer argumento opcionalmente se puede
indicar la posición a partir de la cual iniciar la búsqueda.
— strrpos(cadena,carácter): devuelve la posición correspondiente a la

última aparición de un carácter dentro de una cadena dada.
— substr(cadena,posición_inicial,longitud): se extrae de una

cadena dada, una subcadena delimitada por los dos últimos argumentos. Si el
valor de posición_inicial es positivo, el fragmento comienza en la
posición correspondiente de la cadena; mientras que si es negativo, el
fragmento comienza en la posición correspondiente de la cadena pero contando
desde el final de la misma. Si no se indica el argumento longitud, se extrae
el fragmento hasta el final de la cadena. Por el contrario, si su valor es positivo,
indica la dimensión del fragmento extraído, y si es negativo, la extracción
finaliza a tantos caracteres desde el final de la cadena como indica dicho valor.
— substr_count(cadena,fragmento): devuelve el número de

apariciones de un fragmento dado dentro de una cadena.
Ejemplo 9.9:
Dada la cadena:
$cadena = "¡Bienvenido a nuestros cines!"
la Tabla 9.1 muestra algunos ejemplos de usos de las funciones anteriores.
De la misma manera, la Tabla 9.2 muestra nuevos ejemplos de usa de la función

substr(), pero tomando como cadena de partida:
257
$cadena = "Bienvenido a nuestro cine. Ha efectuado usted

la
decisión correcta.";
Llamada a la función Valor devuelto

strchr($cadena,'e'); envenido a nuestros cines!
strrchr($cadena,'e'); es!
stristr($cadena,"nuestros"); nuestros cines!
stristr($cadena,'e'); envenido a nuestros cines!
strpos($cadena,"e"); 3
strpos($cadena,"e",14); 16
strpos($cadena,"nuestros"); 14
Tabla 9.1 Ejemplos de usos de funciones de búsqueda en cadenas
Llamada a la función Valor devuelto

substr($cadena,27); Ha efectuado usted la decisión correcta.
substr($cadena,-27); usted la decisión correcta.
substr($cadena,27,5); Ha ef
substr($cadena,27,-5); Ha efectuado usted la decisión corr
substr($cadena,-45,10); ine. Ha ef
substr($cadena,-45,-5); ine. Ha efectuado usted la decisión corr
Tabla 9.2 Ejemplos de uso de la función substr()
9.2.7. SUBDIVISIÓN DE CADENAS

— wordwrap(cadena,ancho,separación): particiona el texto de la
cadena dada en líneas del ancho indicado. Por defecto, si no se indica otra cosa,
el texto se fragmenta al llegar a una anchura de 75 con un carácter de cambio
de línea: '\n'.
— strtok(cadena,delimitador): se fragmenta la cadena dada según la

delimitación indicada. La primera llamada a este método devuelve el primer
fragmento. Las siguientes llamadas requieren como único argumento el
delimitador.
Ejemplo 9.10:
El siguiente código fragmenta una cadena dada considerando como delimitador la coma:
$p = "Solo ante el peligro, Fred Zinnemann, Gary Cooper";

// escritura del título (hasta la primera coma)
258
echo strtok($p,',');
echo "<BR>";
// $i cuenta el número de comas leídas
$i = 1;
// número total de comas dentro de la cadena inicial
$frecuencia=substr_count($p,',');
// bucle que fragmenta el resto de la cadena
while($i<=$frecuencia){
echo strtok(',');
echo "<BR>";
$i++;
}
La salida generada por este programa sería:
Solo ante el peligro

Fred Zinnemann
Gary Cooper
9.2.8. LONGITUD DE UNA CADENA

strlen(cadena): devuelve la longitud de una cadena, es decir, el número de
caracteres que contiene.
9.3. FUNCIONES DE FECHA Y HORA

Otro grupo importante de funciones predefinidas en PHP está constituido por todas
las que permiten realizar manipulaciones con fechas y horas.
En PHP cualquier instante de tiempo viene determinado por un número entero que
representa el número de segundos transcurridos desde las 00:00 del día 1 de enero
de 1970; así por ejemplo, la función que calcula el instante de tiempo actual,
función time(), devuelve en realidad un número entero. Por supuesto, es posible
trabajar con fechas y horas en formatos más sencillos para el usuario, para ello
PHP dispone de la función mktime() que permite generar instantes de tiempo y
la función date() para convertir el instante de tiempo en una cadena de
caracteres siguiendo un formato preestablecido.
A continuación se recogen las funciones más importantes para trabajar con

instantes de tiempo y se ilustra su funcionamiento con algunos ejemplos.
259
— time(): devuelve la hora actual expresada como el número de segundos

transcurridos desde las 00 horas del 1 de enero de 1970.
— mktime(hora,minuto,segundo,mes,día,año): devuelve un instante

de tiempo identificado por el número de segundos transcurridos desde las 00:00
del 1 de enero de 1970 hasta el momento determinado por los argumentos pasados.
Obsérvese el orden en el que deben ser pasados estos argumentos. Los argumentos
son opcionales, de manera que cualquier argumento omitido tomará
automáticamente el valor correspondiente al instante actual.
— checkdate(mes,día,año): devuelve el valor entero 1 si la fecha dada

como argumento es válida, entendiendo por fecha valida aquella que sigue los
siguientes criterios:
o El año debe estar comprendido entre 0 y 32767.
o El mes entre 1 y 12.
o El día debe estar en el rango admisible del mes considerado. Se
tienen en cuenta los años bisiestos.
— date(formato,instante): devuelve una cadena de caracteres con la

fecha y/o hora de acuerdo al formato indicado en el primer argumento. El
segundo argmento será un número entero que identificará el instante asociado a
dicha fecha y hora. Este segundo argumento es opcional, en caso de omitirse se
asumirá automáticamente la fecha y hora actual en el servidor.
La cadena de formato que recibe la función date() como primer argumento

incluye determinados caracteres con un significado especial. La siguiente lista
incluye alguno de estos caracteres, explicando el significado de su presencia en la
cadena de formato:
Formato para el año:

— “Y” con cuatro dígitos.
— “y” con dos dígitos.
Día del año:
— “z” de 0 a 365.
Formato para el mes:
— “F” el nombre completo en inglés.
— “M” nombre abreviado en inglés.
— “m” del 01 al 12.
— “n” del 1 al 12.
— “t” número de días del mes.
260
Formato para el día del mes:

— “d” del 01 al 31.
— “j” del 1 al 31.
Formato para el día de la semana:
— “l” nombre completo en inglés.
— “D” nombre abreviado en inglés.
— “w” día de la semana del 0 (domingo) al 6 (sábado).
Formato para la hora:
— “g” la hora de 1 hasta 12.
— “G” la hora de 0 a 23.
— “h” la hora de 01 a 12.
— “H” la hora de 00 a 23.
— “i” los minutos de 00 a 59.
— “s” los segundos de 00 a 59.
— “a” am o pm.
— “A” AM o PM.
Años bisiestos:
— “L” 1 si el año es bisiesto, 0 en otro caso.
Ejemplo 9.11:
El siguiente programa genera una página de bienvenida en la que se muestra la
fecha local del servidor con el formato escogido en el correspondiente argumento
de la función date():
print("Bienvenido, la hora local en nuestro servidor es: ");

print(date("h:i A"));
print(" y estamos en el día ");

print(date("z"));
print(" del año ");
print(date("Y."));
En la página aparecerá un mensaje como el siguiente:
Bienvenido, la hora local en nuestro servidor es: 06:03 PM y estamos en el

día 296 del año 2004.
Ejemplo 9.12:
Si se quiere mostrar el mes en curso, basta la siguiente línea de código:
print(date("M"));
261
Sin embargo, si se quiere mostrar un mes del año, distinto al actual, se debe añadir
como segundo argumento de la función date() una llamada a la función
mktime() con los argumentos adecuados: en este caso, basta indicar el número
de mes y un día del mes, (el 1, por ejemplo):
print(date("M",mktime(0,0,0,1,1,0)));
Ejemplo 9.13:
Si se desea averiguar el día de la semana correspondiente al 2 de marzo de 1972 se
podría escribir la siguiente línea de código:
print(date("w",mktime(0,0,0,3,2,1972)));
Se obtiene el valor 4, correspondiente al jueves.
Ejemplo 9.14:
Mediante el siguiente programa se generará el calendario del mes en curso en el
momento de acceder a una página dada, incluyendo además dos enlaces: uno al
calendario del mes anterior y otro al del mes siguiente. El aspecto de este
calendario puede verse en la Figura 9.1.
Figura 9.1 Calendario del mes actual
262
El programa se estructura en cuatro ficheros:
— Datos.php: fichero de datos generales, que almacena dos arrays con los
nombres de los meses y de los días y variables relacionadas con la fecha en
curso. También implementa la función crearCalendario(), que permite
construir el calendario de un mes y año dados. Toda esta información será
añadida en los restantes ficheros con la sentencia include.
— Calendario.php: construye el calendario del mes en curso en el momento de
acceder a la página y se crean dos enlaces que remiten al calendario del mes
anterior y del mes siguiente, respectivamente.
— MesAnterior.php y MesSiguiente.php: generan el calendario correspondiente al
mes anterior y al mes siguiente al mes en curso.
A continuación se incluye el código completo de cada fichero y se comentan sus

sentencias más significativas:
Fichero Datos.php
<?php
$meses = array("Enero", "Febrero", "Marzo",
"Abril", "Mayo","Junio",
"Julio", "Agosto", "Septiembre",
"Octubre", "Noviembre", "Diciembre");
$semana = array("Lu", "Ma", "Mi", "Ju", "Vi", "Sa", "Do");
$añoActual = date("Y");
$mesActual = date("n");
$mesActualTr = $meses[$mesActual-1];
$diaActual = date("j");
function crearCalendario($mes,$año,$fechaActual){
$nummes = array_search($mes,$GLOBALS["meses"])+1
$diasemana=date("w",mktime(0,0,0,$nummes,1,$año));
if($diasemana==0)
$diasemana=7;
$diasMes= date("t",mktime(0,0,0,$nummes,1,$año));
// generación del calendario

echo "<B>$mes $año</B>";
echo "<TABLE BORDER ALING=CENTER>";
echo "<TR>";
// cabeceras de la tabla
for($i=0;$i<=6;$i++){
263
echo "<TH>".$GLOBALS["semana"][$i]."</TH>";
}
echo "</TR>";
// días en blanco hasta el inicio del mes

echo "<TR>";
$aux = 1;
while($aux<$diasemana){
echo "<TD> </TD>";
$aux++;
}
// días del mes

for($i=1;$i<=$diasMes;$i++) {
if(($diasemana==6) or ($diasemana==7)){
if($fechaActual){
if($i==$GLOBALS["diaActual"])
echo "<TH BGCOLOR=#00FFFF >$i</TH>";
else
echo "<TD BGCOLOR=#00FFFF >$i</TD>";
}
else
echo "<TD BGCOLOR=#00FFFF >$i</TD>";
}
else{
if($fechaActual){
if($i==$GLOBALS["diaActual"])
echo "<TH>$i</TH>”;
else
echo "<TD>$i</TD>";
}
else
echo "<TD>$i</TD>";
}
$diasemana++;
if($diasemana==8) {
echo "</TR>";
echo "<TR>";
$diasemana=1;
}
}
echo "</TR></TABLE>";
}
?>
Como puede apreciarse, este fichero comienza con las definición de dos arrays,
que almacenan los nombres de los meses y de los días de la semana, y cuatro
264
variables que almacenarán el año, el mes y el día del mes correspondientes al

momento de visitar la página. Para la obtención de estos últimos valores se utiliza la
función date().
Posteriormente, se define la función crearCalendario() que toma como

argumentos: un mes expresado como cadena de caracteres, un año en cuatro dígitos
y una variable booleana que toma el valor TRUE si el calendario a construir
corresponde al del mes en curso. Dentro de esta función, para acceder a los arrays y
variables globales definidas fuera de la misma se utiliza el array asociativo
$GLOBALS[]; de esta manera, lo primero que se hace es obtener el número de
mes asociado al mes cuyo nombre se ha recibido como argumento. Posteriormente
se calcula el día de la semana correspondiente al primer día de ese mes, y el
número total de días del mes. Para estas dos operaciones se utiliza de nuevo la
función date(), pero en este caso indicando como último argumento el instante
de tiempo correspondiente a las 0:00 del primer día del mes; este instante de
tiempo se genera con la función mktime().
En PHP, como ocurre en la cultura anglosajona, el primer día de la semana es el

domingo, y dicho día queda identificado con el número 0; es por ello que, para
considerar el domingo como último día de la semana, se asigna el valor 7
cuando sea 0.
Una vez establecidos todos los datos necesarios, la función crearCalendario()

procede a la creación del calendario mediante una tabla HTML generada
dinámicamente. Las celdas correspondientes a los fines de semana tendrán un
sombreado diferentes, y además, en el caso de que el calendario que se crea
corresponda al mes en curso, el día actual se mostrará en negrita.
Fichero Calendario.php
<?php
include("Datos.php");
crearCalendario($mesActualTr,$añoActual,true);
$mesAnt = "MesAnterior.php";
$mesSig = "MesSiguiente.php";
echo "<BR><A HREF=$mesAnt>Mes anterior</A> <BR>
<A HREF=$mesSig>Mes próximo</A>";
?>
Este fichero es el principal, diseña la página donde se muestra el calendario del

mes en curso junto con dos enlaces a los calendarios anterior y próximo,
respectivamente. Como puede observarse, lo primero que se realiza es la inclusión
265
del fichero Datos.php mediante la función include(), para posteriormente

efectuar la llamada a la función crearCalendario(), y crear los dos enlaces.
Fichero MesAnterior.php
<?php
if($mesActual==1){
$aux = 11;
$año = $añoActual-1;
}
else{
$aux = $mesActual-2;
$año = $añoActual;
}
crearCalendario($meses[$aux], $año, false);
?>
Fichero MesSiguiente.php
<?php
if($mesActual==12){
$aux = 0;
$año = $añoActual+1;
}
else{
$aux = $mesActual;
$año = $añoActual;
}
crearCalendario($meses[$aux], $año, false);
?>
Estos dos últimos ficheros cargan de nuevo todos los datos y lo único que realizan
es una modificación de las variables que identifican al mes en curso. Una vez
modificadas esas variables se procede a efectuar la llamada a la función de
creación del calendario.
266
9.4. FUNCIONES MATEMÁTICAS

El lenguaje PHP cuenta con una serie de constantes numéricas ya definidas y con
un conjunto de funciones que manipulan valores numéricos, tanto de tipo entero
como en coma flotante. La Tabla 9.4 muestra las constantes de carácter matemático
predefinidas en PHP más comúnmente conocidas.
Respecto a las funciones matemáticas, la Tabla 9.3 muestra algunas de las más utilizadas.
Función Descripción
abs(n) Obtiene el valor absoluto de un entero o en coma flotante.
round(n) Redondea a entero un número dado.
ceil(n) Obtiene el valor entero superior más próximo a n.
floor(n) Obtiene el valor entero inferior más próximo a n.
cos(n) Calcula el coseno de un ángulo.
sin(n) Calcula el seno de un ángulo
tan(n) Calcula la tangente de un ángulo.
exp(a) Calcula el valor ea.
log(n) Calcula el logaritmo neperiano de n.
min(n1,n2,...) Obtiene el menor valor de un número determinado de
min(array) argumentos numéricos o de los elementos de un array.
Si alguno de estos números es decimal, el resultado
también tendrá este formato.
max(n1,n2,…) Obtiene el mayor valor de un número determinado de
max(array) argumentos numéricos o de los elementos de un array.

Si alguno de estos números es decimal, el resultado
también tendrá este formato.
pow(a,b) Se calcula el valor de la potencia ab.
rand(mín,máx) Si no toman argumentos, estas funciones devuelven
mt_rand(mín,máx) un valor aleatorio entre 0 y RAND_MAX. En caso
contrario, se obtiene un número aleatorio entre mín y
máx. El valor RAND_MAX es una cota superior entera
definida por el sistema, que se puede obtener con una
llamada a la función mt_getrandmax().
sqrt(a) Raíz cuadrada de a.
Tabla 9.3 Funciones matemáticas
267
Constantes numéricas Descripción

M_PI número Pi (3.14159…).
M_E número e (2.718281…).
M_PI_2 pi/2.
M_SQRT2 raíz cuadrada de 2.
M_SQRT3 raíz cuadrada de 3.
Tabla 9.4 Constantes predefinidas
268
PROGRAMACIÓN
ORIENTADA A
OBJETOS
10.1. INTRODUCCIÓN
Los dos elementos básicos de todo lenguaje de programación estructurada son las
variables y las funciones. Las primeras se utilizan para almacenar datos, y las
segundas realizan acciones sobre esos datos. En un esquema de programación
estructurada tradicional ambos elementos básicos se encuentran perfectamente
diferenciados, definiendo las variables por un lado y las funciones por otro.
Sin embargo, a la hora de programar se puede pensar en objetos como entidades

que maneja el programa y que funcionan de una determinada manera. Estos objetos
poseen determinadas características (variables) y con ellos se pueden realizar
diversas tareas (funciones). En un esquema de programación orientada a objetos,
las variables y las funciones no son considerados como elementos independientes
sino como componentes de una misma entidad: el objeto; tal como ocurre con los
objetos de la vida real.
269
En la programación orientada a objetos, las funciones asociadas a cada objeto

reciben el nombre de métodos. Los métodos permitirán no solo realizar acciones
sobre los objetos sino también extraer información sobre sus variables, enviar
mensajes a otros objetos,...
Los objetos definidos son elementos dinámicos, en todo momento tienen un estado
(determinado por los valores de sus variables) y un comportamiento (determinado
por sus métodos).
Ejemplo 10.1:
Piénsese en la gestión de un cine; en un cine se maneja información sobre
películas, proyecciones, clientes,... En definitiva, se podría pensar en diferentes
objetos con diferentes características (variables) y diferentes acciones (métodos)
que pueden realizar cada uno:
— Cada objeto película tendrá asociadas cuatro variables que indicarán el título,
el director, la lista de actores y el año de producción. Además tendrá un
método que permitirá generar la ficha artística de la película (véase Figura
10.1).
— Cada objeto proyección tendrá asociadas tres variables que indicarán el día y la
hora de la proyección, y la película a proyectar. Un método del objeto permitirá
asignar una película a la proyección (véase Figura 10.2).
— Cada objeto cliente tendrá asociadas tres variables que indicarán el nombre y la
edad del cliente y la lista de proyecciones para las que ha adquirido una
entrada. Además de sus variables, un cliente también dispondrá de un método
que le permitirá adquirir una entrada para una proyección (véase Figura 10.3).
Además de los objetos anteriores, el cine en sí puede verse también como un

objeto:
— El objeto cine tendrá asociadas cinco variables que indicarán el día de la

semana que se considera día del espectador, la tarifa normal y la tarifa
reducida, y las listas de proyecciones disponibles y de clientes del cine. El
objeto cine también podrá realizar una serie de acciones como buscar los datos
de un cliente, calcular el importe de una localidad para un cliente y proyección
concretos, y añadir nuevas proyecciones y clientes (véase Figura 10.4).
270
PROGRAMACIÓN ORIENTADA A OBJETOS
PELÍCULA
VARIABLES: MÉTODO:
• Título • Generar ficha
• Director
• Actores
• Año
Figura 10.1 Estructura de un objeto Película
PROYECCIÓN
VARIABLES: MÉTODO:
• Día • Asignar película
• Hora
• Película
Figura 10.2 Estructura de un objeto Proyección

CLIENTE
VARIABLES: MÉTODO:
• Nombre • Adquirir entrada
• Edad
• Lista proyecciones
Figura 10.3 Estructura de un objeto Cliente
271
CINE
VARIABLES: MÉTODOS:
• Día del espectador • Buscar cliente
• Tarifa normal • Calcular importe
• Tarifa reducida • Crear proyección
• Proyecciones • Crear cliente
• Clientes
Figura 10.4 Estructura del objeto Cine
Como puede comprobarse en este esquema, un objeto puede convertirse a su vez en

variable de otro objeto, tal es el caso, por ejemplo, del objeto película asociado al
objeto proyección.
Por último, los objetos podrían disponer de métodos específicos para acceder a sus
variables, tanto para consultar como para cambiar sus valores. Además, los objetos
suelen disponer de métodos, denominados constructores, que son llamados cuando
se crea el objeto.
En las próximas secciones de este capítulo, este esquema organizativo de objetos se

traducirá al lenguaje PHP, presentando conceptos básicos de programación
orientada a objetos como son los de clases, objetos y variables de clase y herencia.
10.2. DEFINICIÓN DE UNA CLASE

Al igual que ocurre en la vida real, los objetos se agrupan en familias o clases de
objetos que comparten características comunes. Así por ejemplo, dos clientes
diferentes tendrán las mismas variables, aunque lógicamente con diferentes valores
para cada uno de ellos, y podrán realizar las mismas acciones; por tanto, serían dos
objetos de una misma clase.
La programación orientada a objetos se basa en definir clases, crear objetos de esas

clases y realizar acciones con ellos. La clase establecerá las características
(variables y métodos) que compartirán todos los objetos de la misma; en este
sentido la clase puede entenderse como un prototipo para los objetos.
272
La definición de una clase en PHP comienza con la palabra clave class y un

nombre elegido por el programador; su código completo se delimita entre llaves.
Dentro de ese cuerpo de la clase, las variables se declaran con la palabra var y los
métodos se definen como cualquier otra función en PHP.
class NombreClase {
var
variables de la clase
métodos
}
Ejemplo 10.2:
A continuación se presenta el esquema de las clases de objetos que fueron
presentados en el Ejemplo 10.1. En esta primera aproximación se incluye
únicamente la definición de las variables de cada clase y la declaración de los
métodos; posteriormente se añadirá la implementación completa de estos últimos.
class Pelicula {
var $titulo,
$director,
$actores,
$año;
// implementación de métodos
function generar_ficha() {
}
class Proyeccion {
var $dia_hora;
var $pelicula;
function asignar_pelicula($p) {
}
}
class Cliente {
var $nombre;
var $edad;
var $lista_proyecciones;
273
function adquirir_entrada($proy) {
}
}
class Cine {
var $dia_espectador,
$tarifa_normal,
$tarifa_reducida,
$lista_proyecciones,
$lista_clientes;
function calcular_importe($c,$proy) {
function crear_proyeccion($t,$p) {
function crear_cliente($n,$e) {
function buscar_cliente($c) {
}
}
Obsérvese la manera de indicar la declaración de variables dentro de una clase.

Tras la palabra clave var, se puede optar por listar todas las variables seguidas de
una coma, con un punto y coma al final de la lista; o bien, por anteponer la palabra
clave antes de cada nueva variable, finalizando siempre en punto y coma.
En el caso de la clase Proyeccion, se ha optado por fusionar las

variables dia y hora en una sola variable de nombre dia_hora.
NOTA
Esta variable almacenará un instante de tiempo generado con la función
mktime(). A partir de este instante de tiempo se puede obtener,
mediante la función date(), cualquier información necesaria, como
la hora de la proyección, la fecha, el día de la semana,...
274
10.2.1. CONSTRUCTORES
Las clases definen el prototipo de los objetos, definiendo sus métodos y declarando
sus variables; pero, ¿cómo se inicializan estas variables? Entran aquí en juego dos
nuevos elementos: la variable $this y el constructor de la clase.
Un constructor es un tipo especial de método que se caracteriza por tener el mismo

nombre que la clase y que se utilizará posteriormente para crear los objetos. Este
método se ejecuta automáticamente, por lo que es aquí donde se pueden inicializar
las propiedades del objeto que interesa establecer en el momento de su creación.
La variable $this, en un contexto de programación orientada a objetos, siempre

hace referencia al objeto actual. A través de ella se puede acceder a las variables
particulares del objeto, utilizando la sintaxis:
$this -> nombre_variable
Ejemplo 10.3:
La creación de un objeto de la clase Pelicula exige el aportar la información
necesaria para ese objeto, en este caso concreto, esa información se traduce en los
valores para sus 4 variables. El constructor de la clase puede recibir como
argumentos esos cuatro valores y asignarlos a las respectivas variables del objeto.
function Pelicula($t,$d,$as,$a){
$this->titulo = $t;
$this->director = $d;
$this->actores = $as;
$this->año = $a;
}
Obsérvese cómo la sintaxis, para acceder a las variables del objeto, exige indicar el
nombre de la variable a continuación de -> pero sin el signo $.
Esta misma sintaxis puede ser utilizada dentro de cualquier otro método para
acceder a las variables del objeto. Por ejemplo, a continuación se incluye la
definición completa de la clase Pelicula, incluyendo el método que genera su
ficha artística:
class Pelicula {
var $titulo,
$director,
$actores,
$año;
275
// constructor
function Pelicula($t,$d,$as,$a){
$this->titulo = $t;
$this->director = $d;
$this->actores = $as;
$this->año = $a;
}
function generar_ficha() {
print "<H3> $this->titulo ($this->año)</H3>";
print "Dirigida por $this->director y
protagonizada por:<BR>";
foreach($this->actores as $ac)
print "$ac <BR>";
}
}
De manera similar, se podrían definir constructores para las otras 3 clases

analizadas.
Se incluye a continuación el código completo de la clase Cliente, cuya

estructura se muestra en la Figura 10.3:
class Cliente {
var $nombre;
var $edad;
var $lista_proyecciones;
// constructor
function Cliente($n,$e){
$this->nombre = $n;
$this->edad = $e;
$this->lista_proyecciones = array();
}
array_push($this->lista_proyecciones,$proy);
}
}
Es posible que el constructor no reciba todos los valores iniciales para las variables
del objeto y que se disponga de métodos para realizar esa asignación
posteriormente, tal como ocurre en la clase Proyeccion:
276
class Proyeccion {
var $dia_hora;
var $pelicula;
// constructor
function Proyeccion($t){
$this->dia_hora = $t;
}
function asignar_pelicula($p) {
$this->pelicula = $p;
}
}
Se puede optar por inicializar algunas variables con valores fijos desde el propio
constructor, por ejemplo, asignando valores por defecto para dichas variables. El
constructor de la clase Cine podría ser:
function Cine($d,$t=5,$tr=3.5){
$this->dia_espectador = $d;
$this->tarifa_normal = $t;
$this->tarifa_reducida = $tr;
$this->lista_clientes = array();
}
10.3. CONSTRUCCIÓN DE OBJETOS

Una vez definidas las clases que intervienen en el programa llega el momento de
crear los objetos particulares. En la terminología de la programación orientada a
objetos estos reciben el nombre de ejemplares de la clase.
La creación de un objeto implica la llamada a un constructor de la clase mediante

el operador new. Si en la definición de una clase no ha sido definido ningún
constructor, entonces PHP utilizará un constructor por defecto; dicho constructor
no recibe ningún argumento.
La sintaxis de creación de un nuevo objeto de una clase es:
obj = new nombreClase(argumentos);
277
El valor devuelto por el operador new debe ser asignado a una variable para poder
hacer referencia posteriormente a dicho objeto.
Ejemplo 10.4:
Se podría crear un nuevo objeto de la clase Pelicula con la sentencia:
$p = new Pelicula("El halcón maltés",

"J. Huston",
array("H. Bogart", "M. Astor"),
1941);
Como puede observarse el constructor recibe los cuatro argumentos necesarios para
inicializar las cuatro variables del objeto. La tercera de las variables recibirá como
valor un array con los nombres de los protagonistas de la película.
10.3.1. ACCESO A LAS VARIABLES Y MÉTODOS DEL

OBJETO
Tanto a las variables como a los métodos del objeto, se puede acceder utilizando el
operador -> aplicado sobre la variable que almacena el objeto. La sintaxis para
ello es:
Objeto -> variable

Objeto -> metodo(argumentos)
Ejemplo 10.5:
Dado el objeto $p creado en el Ejemplo 10.4, se podría efectuar una llamada
$p->generar_ficha();
El resultado obtenido sería:
El halcón maltés (1941)
Dirigida por J. Huston y protagonizada por:

H. Bogart
M. Astor
278
Ejemplo 10.6:
Para completar la definición de las clases del Ejemplo 10.1, se incluye a
continuación la definición de la clase Cine, con la implementación de todos sus
métodos.
class Cine {
var $dia_espectador,
$tarifa_normal,
$tarifa_reducida,
$lista_proyecciones,
$lista_clientes;
// constructor
function Cine($d,$t=5,$tr=3.5){
$this->dia_espectador = $d;
$this->tarifa_normal = $t;
$this->tarifa_reducida = $tr;
$this->lista_clientes = array();
}
function calcular_importe($c,$proy) {
// obtención del dia de la semana de la proyección
$dia_proy = date("w",$proy->dia_hora);
if(($dia_proy == $this->dia_espectador)||
($c->edad)<=15 || ($c->edad>=65))
$t=$this->tarifa_reducida;
else
$t=$this->tarifa_normal;
return $t;
}
function crear_proyeccion($t,$p) {
$proy = new Proyeccion($t);
$proy->asignar_pelicula($p);
}
function crear_cliente($n,$e) {
$cl = new Cliente($n,$e);
array_push($this->lista_clientes,$cl);
}
function buscar_cliente($n) {
// búsqueda del nombre en el array de clientes
279
foreach($this->lista_clientes as $cliente) {
if($cliente->nombre == $n)
return $cliente;
}
return FALSE;
}
Ejemplo 10.7:
Una vez definidas todas las clases del Ejemplo 10.1 en un fichero de nombre
clases.php, se encuentran listas para ser utilizadas en cualquier otro programa. A
continuación se incluye un sencillo programa que crea diferentes objetos de las
clases anteriores y realiza con ellos las acciones que permiten sus métodos.
include "clases.php";
// creación de un nuevo objeto Cine

// se asigna el miércoles (3) como día del espectador, y
// 6 y 4.5 como tarifas normal y reducida, respectivamente
$c = new Cine(3,6,4.5);
// creación de nuevos clientes con el método del objeto

$c->crear_cliente("Angel Antón",37);
$c->crear_cliente("Rosa Minguez",36);
$c->crear_cliente("Valeria Conde",7);
// creación de una película y una proyección de la misma

$p = new Pelicula("El halcón maltés",
"J. Huston",
array("H. Bogart", "M. Astor"),
1941);
$c->crear_proyeccion(mktime(16,0,0,12,23,2004),$p);
// Generación de un listado con las proyecciones

disponibles
print "<H2> Proyecciones disponibles </H2>";
foreach($c->lista_proyecciones as $pr) {
$dia = date("d/m/Y",$pr->dia_hora);
$hora = date("H:i",$pr->dia_hora);
$pr->pelicula->generar_ficha();
print "Dia: $dia <BR> Hora: $hora <BR>";
}
// Búsqueda de un cliente y cálculo del importe de su
280
// localidad para la primera proyección disponible

if($cl=$c->buscar_cliente("Valeria Conde")) {
print "El cliente tiene $cl->edad años";
$pr = $c->lista_proyecciones[0];
$precio = $c->calcular_importe($cl,$pr);
print " y el importe de su entrada es $precio";
}
10.4. HERENCIA
La programación orientada a objetos tiene por objetivo la estructuración de los
programas en clases; cada clase describe las características generales que un objeto
debe poseer. A partir de las clases definidas es posible también diseñar objetos
similares con nuevas particularidades; de esta forma surgen los conceptos de
subclases y herencia.
Al igual que ocurre con los objetos del mundo real, una clase de objetos puede ser
vista como una subclase de otra; de manera que hereda todas las propiedades
(variables y métodos) de la superclase. Sin embargo, la verdadera utilidad de las
subclases es el permitir a estas la definición de nuevas variables, la modificación de
los métodos heredados o la implementación de nuevos métodos.
Ejemplo 10.8:
Sobre el esquema de clases presentado en el Ejemplo 10.1 se podrían realizar
algunas modificaciones. En primer lugar se podrían definir varias subclases que
permitan clasificar las películas que el cine gestiona en función de su género
(Figura 10.5). Así por ejemplo, las comedias constituyen una subclase de películas;
lo que significa que toda comedia tiene las características generales de una
película, pero puede tener características propias de este género.
De la misma manera, se podría pensar en un tipo especial de clientes que recibirán

un tratamiento específico. Por ejemplo, se puede considerar el concepto de socio
como un cliente que participa en un programa de fidelidad por el cual obtiene
puntos a canjear por regalos. Surge así la necesidad de definir el socio como una
subclase de cliente pero incorporando nuevas variables y nuevos métodos.
281
PELÍCULA
POLICIACA COMEDIA MUSICAL
Figura 10.5 Subclases de la clase película
CLIENTE
VARIABLES: MÉTODO:
• Nombre • Adquirir entrada
• Edad
• Lista proyecciones
SOCIO
VARIABLES PROPIAS: MÉTODOS PROPIOS:

• Número de socio • Adquirir entrada (*)
• Puntos acumulados • Canjear regalo
Figura 10.6 Estructura de la clase socio, subclase de cliente
Como se aprecia en la Figura 10.6, la subclase Socio dispondrá de dos nuevas

variables no disponibles en un cliente general: una para almacenar un número de
socio y otra para almacenar en todo momento los puntos acumulados por el socio.
En lo que respecta a los métodos, se observa la aparición de uno nuevo (canjear
regalo) y la necesidad de redefinir el método heredado, ya que cuando un socio
adquiera una entrada, se deberá actualizar su saldo de puntos acumulados.
282
10.4.1. DEFINICIÓN DE SUBCLASES

Para la definición de subclases en PHP se utiliza la palabra extends seguida del
nombre de la clase de la que descienden (superclase). Dentro de la definición de la
subclase no es necesario volver a declarar todas las variables y métodos de la
superclase, ya que son automáticamente heredados.
La sintaxis general de la definición de subclases es:
class NombreSubclase extends NombreSuperclase {

var
variables de la subclase
métodos de la subclase
}
Ejemplo 10.9:
La definición de las subclases plateadas en el Ejemplo 10.8 serían:
class Policiaca extends Pelicula{
class Musical extends Pelicula{
}
class Comedia extends Pelicula{
En el caso de la subclase Socio, su definición podría ser la siguiente:
class Socio extends Cliente{
// variables propias de la subclase

var $num_socio,
$puntos;
// constructor
function Socio($n,$e,$num){
$this->nombre = $n;
$this->edad = $e;
283
$this->num_socio = $num;
$this->puntos = 0;
}
$this->puntos += 10;
}
function canjear_regalo(){
$p = $this->puntos;
if($p >= 100) {
print "¡Enhorabuena! ¡Le obsequiamos con
nuestro regalo sorpresa!";
$this->puntos -= 100;
}
else{
$aux = 100-$p;
print "Le faltan $aux puntos para conseguir
un premio";
}
}
}
Como puede observarse, los objetos de esta subclase tienen todas las características
de la clase general Cliente (nombre, edad y lista_proyecciones), pero
además poseen dos nuevos atributos: num_socio y puntos. Cuentan también
con el mismo método adquirir_entrada(), pero definido de nuevo,
adaptándose así a las características de la subclase; en este caso, cada vez que se
adquiera una entrada se incrementará en 10 unidades el valor de la variable
puntos. La subclase incluye también un nuevo método, canjear_regalo(),
que será propio de los objetos de esta nueva clase.
284
COOKIES
11.1. ¿QUÉ SON LAS COOKIES?

Las cookies constituyen un sencillo mecanismo para almacenar información en los
equipos cliente que visitan una página web. La información es enviada por el
servidor web y queda almacenada en el equipo del cliente, bien de forma temporal
en la memoria principal, o permanentemente en la memoria secundaria en forma de
ficheros de texto. La información almacenada en esos ficheros de texto puede ser

recuperada por el servidor web cuando el usuario visite de nuevo la página web u
otras páginas para las cuáles se haya establecido la visibilidad de la cookie.
Las cookies no fueron diseñadas para espiar o invadir la privacidad de los usuarios
de Internet, su principal objetivo es identificar al usuario y poder de esta manera
preparar páginas personalizadas. Son muy prácticas también para almacenar
información como el número de visitas, preferencias, estado de conexión y, en
general, información que sirva para realzar la navegación del cliente y permita
simular una conexión continua. Por ejemplo, gracias a las cookies el usuario podría
continuar la navegación por un sitio web en el último punto en el que lo dejó en su
última conexión.
Es de destacar que las cookies, como simples archivos de texto, no tienen la

posibilidad de realizar ningún tipo de acción sobre el equipo del cliente; es decir,
285
no pueden abrir ficheros del usuario, ejecutar programas en el equipo cliente,

establecer conexiones de red,... A pesar de ser inofensivas, el usuario puede, si así
lo desea, configurar su navegador web para que no acepte ningún tipo de cookie,
para que acepte únicamente las que proceden de determinados servidores o para
que pregunte al usuario antes de generar cualquier cookie.
11.2. GENERACIÓN DE COOKIES

Como se ha comentado, las cookies son generadas en el cliente pero por orden del
servidor; de manera que la generación de una cookie puede realizarse
perfectamente desde un programa PHP. En esta sección se verá cómo este proceso
es muy sencillo de realizar.
Es de destacar que cuando se realiza una transferencia HTTP entre un servidor y un

cliente, las cookies son incluidas en la cabecera HTTP, esto implica que cualquier
orden de generación de una cookie desde una página web debe ser dada antes de
cualquier comando HTML.
Para crear una cookie desde un programa PHP se utiliza la función

setcookie(). La sintaxis mínima de esta función es:
setcookie(nombre, valor)
y define una cookie con el nombre y valor indicados en los argumentos. En cierta
forma una cookie puede verse como una variable que tiene un identificador y un
valor asignado, de hecho, el nombre de la cookie se convertirá en nombre de una
variable PHP cuando la cookie sea transferida desde el cliente al servidor.
Recordar de nuevo que el script que incorpore la llamada a la función anterior debe
ser colocado delante de cualquier comando HTML.
La función setcookie() devuelve un valor numérico indicando si se produjo algún

fallo en el proceso. Si devuelve un valor distinto de cero significa que el proceso de
transferencia se realizó correctamente, aunque eso tampoco asegura que la cookie haya
sido creada en el equipo del cliente, ya que este podría no haberla aceptado.
El segundo de los argumentos de la función setcookie() es opcional, si no se

especifica ningún valor para la cookie lo que se estaría haciendo realmente es
borrar del cliente la cookie de nombre dado:
setcookie(nombre)
286
COOKIES
Además de este parámetro opcional, la función setcookie()tiene algunos

parámetros opcionales más, que permiten especificar, por ejemplo, una fecha de
expiración de la cookie, determinar la visibilidad de dicha cookie en el servidor
web, indicar un dominio en el que estará disponible, o indicar que la cookie solo
debe ser transferida bajo conexiones seguras HTTPS.
En concreto, la sintaxis completa de la función setcookie() es:
setcookie(string nombre, string valor, int expiracion, string

path, string dominio, int seguro)
Ejemplo 11.1:
Supóngase que se dispone de un formulario en el que se solicita al usuario que
escriba su nombre y que se desea que ese nombre pueda ser utilizado directamente
cuando el usuario visite otras páginas del servidor.
El código HTML de la página que define el formulario sería el siguiente:
<HTML>
<HEAD><TITLE>Registro</TITLE></HEAD>
<BODY>
<H1>Registro como usuario</H1>
Introduzca su nombre:
<FORM ACTION="cookie.php" METHOD="GET">
<INPUT TYPE="text" NAME="nombre"><BR>
<INPUT TYPE="submit" VALUE="Enviar">
</FORM>
</BODY>
</HTML>
Como puede apreciarse, la página dispone de un formulario con un campo de texto

llamado nombre y la acción a realizar al pulsar el botón de enviar será el envío de
los datos a una nueva página llamada cookie.php. Es en esta nueva página en la que
se generará la cookie, el código completo correspondiente es:
<?php
if (isset($nombre))
setcookie("nomusuario", $nombre);
?>
<HTML>
<HEAD><TITLE>Confirmación</TITLE></HEAD>
<BODY> Muchas gracias por registrarte.
</BODY>
</HTML>
287
Obsérvese que el script PHP que tiene la definición de la cookie está colocado antes de
cualquier comando HTML, incluso antes del comando <HTML>. Además se utiliza la
función isset() para asegurar que la variable $nombre tiene un valor asignado
correctamente desde el formulario. En el caso de que esta variable tenga un valor
asignado se está generando una cookie de nombre nomusuario y con el valor
introducido por el usuario en el formulario previo.
También es posible definir varias cookies bajo un nombre común, es decir, definir
arrays de cookies. Para ello se utiliza la notación habitual de definición de arrays
en PHP.
Ejemplo 11.2:
Imagínese que se desea guardar en un array de cookies las últimas películas vistas
por cada cliente de Cinem@s, las cookies podrían ser generadas de la siguiente
manera:
setcookie( "peliculas[1]", "Mar adentro" );

setcookie( "peliculas[2]", "Peter Pan" );
setcookie( "peliculas[3]", "Shrek 2" );
En este caso, cuando se recupere el valor de estas tres cookies, se obtendrá una
variable de tipo array y de nombre $peliculas.
11.3. RECUPERACIÓN DE LOS VALORES DE

LAS COOKIES
Un vez que la cookie ha sido generada, esta permanece en el equipo del cliente y
será enviada al servidor cuando se realice una nueva carga de una página del
servidor para la que la cookie sea visible.
Cualquier cookie enviada al servidor desde el cliente, automáticamente se

convertirá en una variable PHP con nombre igual al nombre de la cookie pero
precedida del signo $.
Ejemplo 11.3:
Supóngase que el cliente que se registró en el formulario anterior, y para el que se
ha generado una cookie con su nombre, visita ahora una nueva página del servidor;
288
COOKIES
esta nueva página tendrá acceso a una variable $nomusuario con la que podrá
preparar un contenido personalizado:
<HTML>
<HEAD><TITLE>Cartelera</TITLE></HEAD>
<BODY>
<H1> Nuestra cartelera </H1>
<?php
if (isset($nomusuario))
echo "$nomusuario, nuestros estrenos para ti
son:";
else
echo "Por favor, regístrese";
?>
<TABLE>
.............
.............
.............
</TABLE>
</BODY>
</HTML>
En este caso el uso de la función isset() permite asegurarse de que la cookie se

ha recibido correctamente desde el cliente, en caso de que no se reciba esa cookie
se muestra un mensaje solicitando al cliente que se registre.
Ejemplo 11.4:
En este nuevo ejemplo los procesos de generación y de recuperación de la cookie
tienen lugar en la misma página. Imagínese, que interesa en todo momento conocer
la fecha y hora del último acceso de cada cliente a la página; esto podría realizarse
fácilmente con ayuda de una cookie que se almacene en cada cliente. El código
completo de la página sería:
<?php
$v = date("d/m/Y \a \l\a\s H:i");
setcookie("visita", $v, time()+30*24*3600);
?>
<HTML>
<HEAD><TITLE>Página de inicio</TITLE></HEAD>
<BODY>
<H1>Bienvenido a nuestra página</H1>
<?php
if (isset($visita))
echo "La última vez que nos visitaste fue el $visita";
289
?>
....................................
....................................
</BODY>
</HTML>
Como puede verse, en primer lugar se genera una cookie con la fecha y hora de
acceso; este script está colocado antes de cualquier otro código. En el segundo
script se utiliza esa cookie para escribir en la página el momento de ese último
acceso.
Obsérvese igualmente, que en la generación de la cookie anterior se ha utilizado un

nuevo parámetro opcional de la función setcookie(), el parámetro que
determina la fecha de expiración de la cookie. En la próxima sección se explicará
con detalle el funcionamiento de este nuevo parámetro.
Cuando un cliente accede a una página, el servidor solicita los valores de todas las
cookies antes de realizar cualquier otra operación, una vez recibidos esos valores
comienza a procesar la página. Este hecho hace que la cookie generada en el
primer script no será visible hasta la siguiente carga de la página, ya que en primer
lugar el servidor recibe las cookies generadas y posteriormente actualiza su valor
para la siguiente carga.
PHP dispone de una variable global de tipo array en la que siempre se encuentran
almacenadas todas las cookies que el servidor ha recibido del cliente, dicho array
es $HTTP_COOKIE_VARS y se trata de un array asociativo en el que el índice de
cada elemento es el nombre de una cookie y el valor almacenado en el array el
valor de dicha cookie.
Ejemplo 11.5:
Si se ha definido una cookie de la siguiente manera:
setcookie("micookie", "Mar adentro");
se podrá acceder a su valor con cualquiera de las dos sintaxis siguientes:
$micookie
$HTTP_COOKIE_VARS["micookie"]
290
COOKIES
Utilizando la estructura iterativa foreach resulta muy sencillo generar en la

página un listado con los nombres y valores de todas las cookies visibles en cada
instante.
foreach($HTTP_COOKIE_VARS as $c) {
echo "$c <BR>";
}
Otra posibilidad para recorrer todas las cookies definidas sería:
while (list($n,$v)=each($HTTP_COOKIE_VARS)) {
echo "$n = $v <BR>";
}
A partir de la versión PHP 4.1.0 también se dispone del array de cookies definidas
en otra variable global de nombre $_COOKIE.
11.4. COOKIES DE SESIÓN Y COOKIES

PERMANENTES
Cuando se utiliza la sintaxis mínima para generar una cookie, es decir, la sintaxis
en la que únicamente se indica el nombre y el valor, la cookie solo estará definida
durante la sesión; cuando el usuario cierre su navegador, desaparecerá. En estos
casos la cookie, mientras dura la sesión, estará almacenada en la memoria principal
del equipo cliente.
Si se desea que la cookie permanezca en el equipo del usuario cuando este cierre la
sesión, deberá indicarse en su construcción un parámetro adicional con un periodo

de expiración. En este caso la cookie quedará almacenada en un fichero de texto en
el equipo cliente hasta que expire el periodo establecido, momento en el que
automáticamente desaparecerá.
setcookie(nombre,valor,expiracion)
El parámetro de expiración de la cookie debe indicarse sumando a la función

time() el número de segundos que se desea que permanezca la cookie en el
equipo del usuario. A continuación pueden verse algunos ejemplos de cookies con
diferentes periodos de expiración:
— Cookie con un periodo de expiración de 60 segundos:

setcookie("Cookie1","Valor1",time() + 60);
291
— Cookie con un periodo de expiración de 1 hora:

setcookie("Cookie2","Valor2",time() + 3600);
— Cookie con un periodo de expiración de 30 días:

setcookie("Cookie3","Valor3",time() + 30*24*3600);
Para borrar una cookie que tiene establecido un valor con periodo de expiración
antes de que dicho periodo finalice, debe utilizarse la sintáxis:
setcookie("NombreCookie", "", time());
Ejemplo 11.6:
En este ejemplo se utiliza una cookie para almacenar en el equipo cliente el
instante de tiempo correspondiente al último acceso a la página. El programa
comprobará si han transcurrido más de 7 días desde ese último acceso y en caso
afirmativo mostrará un mensaje avisando de ese hecho.
<?php
$ahora = time();
setcookie("ultima", $ahora, $ahora + 30*24*3600);
if(isset($ultima) and ($ahora - $ultima > 7*24*3600))
echo "Hace más de una semana que no nos
visitabas"
?>
<HTML>
<BODY>
....................................
....................................
....................................
</BODY>
</HTML>
En el script se utiliza la función time() para obtener el instante de tiempo actual,

ese valor se almacena temporalmente en una variable y se genera con ella la cookie
a la que se le da el nombre ultima. Esta cookie tendrá una validez de 30 días. Por
lo tanto, en caso de que transcurra ese plazo sin recibir una nueva visita del
usuario, la cookie se borrará automáticamente. Tras definir la cookie, en el
programa se pregunta si la variable $ultima se encuentra definida. Conviene
recordar que la generación de la cookie se produce con anterioridad a la lectura de
todas las cookies definidas, por tanto, cuando se leen esas cookies la variable
$ultima tomará el valor correspondiente a la anterior carga de la página.
292
COOKIES
Finalmente, en la estructura condicional se compara el valor de las variables

$ahora y $ultima que guardan los instantes de tiempo actual y del último
acceso, respectivamente. Si la diferencia entre ambas es mayor que 7 días
(7*24*3600 segundos) se mostrará el mensaje en la página.
Ejemplo 11.7:
En este nuevo programa se utilizará una cookie para generar un contador de
accesos individuales de cada usuario. El número de accesos acumulados por el
usuario será almacenado en una cookie de nombre nvis.
<?php
if(isset($nvis)) {
$nvis++;
setcookie("nvis", $nvis, time() + 30*24*3600);
} else {
setcookie("nvis", 1, time() + 30*24*3600);
$nvis=1;
}
?>
<HTML>
<BODY>
<?php
echo "Esta es tu visita nº $nvis";
?>
....................................
....................................
</BODY>
</HTML>
En este caso el script inicial pregunta en primer lugar si la variable $nvis se

encuentra definida, dicho de otra modo, si la cookie ya se definió en un acceso
previo. En caso afirmativo, se incrementa en una unidad el valor de esa variable y
se redefine la cookie para el siguiente acceso. En el caso de variable no definida, es
decir, primer acceso, se le asignará el valor 1 y se definirá la cookie. En ambos
casos, la cookie generada permanecerá en el equipo cliente 30 días. Finalmente,
obsérvese cómo en el cuerpo del documento HTML se encuentra un nuevo script
PHP que utiliza el valor de la variable $nvis para generar en todo momento un
mensaje indicando cuántas veces ha accedido el usuario a la página.
293
11.5. VISIBILIDAD DE LAS COOKIES EN EL

SITIO WEB
Por defecto, si una cookie ha sido generada desde una página del sitio web, su
valor podrá ser "visto" desde cualquier otra página del mismo directorio o
subdirectorios en el que reside la página inicial. Si se desea cambiar esta visibilidad
puede utilizarse un nuevo parámetro opcional en la definición de la cookie,
indicando la ruta concreta en el servidor a partir de la cual la cookie es visible.
A continuación se presentan dos ejemplos concretos:
— Cookie visible en todas las páginas alojadas en el servidor:

setcookie("miCookie","1",time()+60,"/");
— Cookie visible en las páginas alojadas a partir del directorio sub:

setcookie("miCookie","1",time()+60,"/sub/");
294
MANEJO DE
FICHEROS
12.1. MECANISMOS DE ALMACENAMIENTO

DE DATOS
El almacenamiento de información suele ser una de las necesidades básicas de
cualquier aplicación web. En muchas ocasiones esa información puede ser

almacenada en formato de texto, para lo cual se dispone de diferentes alternativas.
La primera es la estudiada en el capítulo anterior: las cookies. En este caso se opta
por descentralizar esa información, de manera que cada equipo cliente guarda en
ficheros de texto propios la información correspondiente.
En la mayoría de ocasiones el uso de las cookies no es suficiente. Puede ocurrir que

se desee tener siempre disponible la información de todos los clientes o que esa
información requiera tratamientos más complejos. En definitiva, lo que se trata es
de poder almacenar la información no en los clientes sino en el propio servidor.
Una primera alternativa es el uso de aplicaciones gestoras de bases de datos, tales

como MySQL. En estos casos se aprovecha las funcionalidades propias de esas
aplicaciones, se optimiza la gestión de los datos, la realización de búsquedas, la
295
generación de informes,... En los próximos capítulos se analizará cómo desde

cualquier programa PHP se puede establecer la conexión a una base de datos
MySQL y realizar todas estas operaciones.
Sin embargo, en ocasiones, el uso de simples ficheros de texto que se almacenen en

el servidor puede cubrir las necesidades de almacenamiento de datos de
aplicaciones web. Esto es precisamente lo que se estudiará en el presente capítulo.
Por supuesto, aunque las bases de datos ofrecen unas prestaciones mucho mayores,
en algunos casos el uso de ficheros puede tener algunas ventajas:
— Su uso resulta más sencillo.

— No es necesario el conocimiento de lenguajes de manipulación de datos.
— No requieren de la instalación de aplicaciones adicionales.
— No todos los proveedores de acceso y alojamiento de páginas web permiten
alojar páginas con acceso a bases de datos.
12.2. OPERACIONES DE MANIPULACIÓN DE

FICHEROS
El uso de ficheros de texto en los programas PHP implica la utilización de una
serie de operaciones básicas. La primera de esas operaciones es la apertura; una
vez abierto se realizarán las correspondientes operaciones de lectura/escritura, y
finalmente se procederá al cierre del fichero.
12.2.1. APERTURA Y CIERRE DE FICHEROS

Para abrir un fichero de texto desde un programa PHP se utiliza la función

fopen(). Como argumentos mínimos esta función recibe el nombre del fichero y
una cadena de caracteres que indicará el modo de apertura:
fopen(Nombrefichero, ModoApertura)
El nombre del fichero se indicará con la ruta relativa de acceso desde la página que
incorpora el script.
La función fopen() devuelve un número entero que actúa de identificador o

puntero al fichero y que se utilizará en todas las operaciones posteriores sobre él. Si
el número devuelto es 0 se entenderá que el proceso de apertura no ha podido
realizarse satisfactoriamente (fichero no existente, falta de permisos para la
apertura, daños en el fichero,...).
296
MANEJO DE FICHEROS
Respecto al modo de apertura del fichero, existen diferentes opciones dependiendo

de la cadena que se utilice como segundo argumento de la función. La Tabla 12.1
muestra esta opciones.
'r' Solo lectura. Puntero al inicio.

'r+' Lectura/escritura. Puntero al inicio.
'w' Solo escritura. Crea el fichero si no existe. Borra el contenido previo
del fichero.
'w+' Lectura/escritura. Crea el fichero si no existe Borra el contenido
previo.
'a' Solo escritura. Añade nuevos datos al final del fichero. Lo crea si no
existe.
'a+' Lectura/escritura. Añade nuevos datos al final del fichero. Lo crea si no
existe.
Tabla 12.1 Modos de apertura de un fichero
Ejemplo 12.1:
Si el fichero es abierto con la siguiente sentencia:
$f = fopen("Datos.txt", "r");
sobre el fichero Datos.txt solo se permitirán operaciones de lectura.
En cambio, una sentencia como la siguiente:
$f = fopen("Pruebas/comentarios.txt", "a");
abre el fichero comentarios.txt que se encuentra en el directorio Pruebas,

subdirectorio del directorio actual, para realizar sobre él solo operaciones de
escritura, creándole si no existe o añadiendo nuevos datos al final si ya existe.
Una vez abierto un fichero se realizarán sobre él las operaciones de lectura y/o
escritura y cuando ya no se utilice se debe proceder a cerrarlo. Para el cierre del
fichero existe una nueva función que recibe como argumento el identificador de
fichero que se genera en la operación de apertura. Esta función es:
fclose(idfichero)
De esta manera, la estructura básica de todo programa que trabaje con ficheros
sería:
297
$f = fopen("mifichero.txt", "a");
..........................
..........................
fclose($f);
12.2.2. OPERACIONES DE LECTURA DE DATOS

PHP dispone de un catálogo bastante amplio de funciones de lectura y escritura de
datos. En estas próximas secciones se presentarán algunas de las más utilizadas,
comenzando en primer lugar por analizar las operaciones que permiten leer los
datos almacenados en ficheros.
La primera función que se puede utilizar para la lectura de un fichero de texto es la

función fgets() que permite efectuar una lectura línea a línea del contenido del
fichero.
fgets(idfichero)
El parámetro de la función debe ser el identificador de un fichero abierto

previamente con permiso de lectura. En cada llamada a la función una línea
completa es leída y el apuntador que señala la posición de lectura del fichero
avanza hasta la siguiente línea.
Para saber si el apuntador interno del fichero ha alcanzado el final se puede utilizar
la función booleana feof().
Ejemplo 12.2:
El siguiente programa realiza una lectura línea a línea del contenido de un fichero
de texto y lo escribe en la propia página web:
<?php
$f = fopen ("datos.txt","r");
while(!feof($f)){
$linea=fgets($f);
print $linea."<BR>";
}
fclose($f);
?>
Como puede comprobarse, la lectura se realiza mediante un bucle que finaliza

cuando el fin del fichero sea alcanzado.
298
MANEJO DE FICHEROS
La función fgets() puede recibir opcionalmente un segundo argumento que

indique un número máximo de caracteres a leer:
fgets(idfichero, n+1)
Con esta sintaxis la función leería, a partir del apuntador interno del fichero, n
caracteres o hasta alcanzar un fin de línea, lo que antes ocurra.
Para la lectura de un número de caracteres predeterminado PHP dispone también

de una nueva función:
fread(idfichero, n)
Esta función lee n caracteres del fichero o hasta alcanzar el fin del fichero (lo que
antes ocurra).
Si se desea saber el número de caracteres que contiene el fichero puede usarse la

función:
filesize(nombrefichero)
Ejemplo 12.3:
Si se desea transferir el contenido completo del fichero a una variable en un
programa PHP se podrían realizar las siguientes operaciones:
<?php
$fnom = "/ficheros/mifichero.txt";
$f = fopen($fnom, "r");
$contenido = fread($f, filesize($fnom));

fclose($fd);
?>
Para una lectura completa del contenido del fichero en una sola operación PHP
dispone también de la función file(). Una ventaja de esta función es que no
necesita realizar la apertura previa del fichero con fopen() ni el cierre con
fclose(). La función devuelve directamente una array de cadenas de caracteres
con cada una de las líneas del fichero.
299
Ejemplo 12.4:
El siguiente programa utiliza la función file() para hacer una lectura completa
de un fichero en una sola operación, y posteriormente recorre el array resultante
para mostrar su contenido en la página:
<?php
$contenido = file('datos.txt');
foreach($contenido as $linea) {
print $linea;
print "<BR>";
}
?>
Finalmente, dentro de las funciones de lectura básicas puede citarse la función

fgetc() que permite una lectura carácter a carácter.
fgetc(idfichero)
Ejemplo 12.5:
El siguiente programa realiza una lectura completa del fichero y copia en la página
únicamente aquellos caracteres que ocupan posiciones pares dentro del fichero.
<?php
$f = fopen("mifichero.txt","r");
$nc = 0;
while(!feof($f)){
$c = fgetc($f);
$nc++;
if ($nc % 2 == 0)
print $c;
}
fclose($f);
?>
12.2.3. LECTURA CON FORMATO

Una de las funciones de lectura de ficheros más completa es la función
fscanf(), que permite leer datos de acuerdo a una especificación de formato. La
principal ventaja de esta función es el poder asignar valores a varias variables
simultáneamente en una única operación de lectura.
La función fscanf() tiene dos sintaxis diferentes:
300
MANEJO DE FICHEROS
fscanf(idfichero,formato)
fscanf(idfichero,formato,variables)
En la primera debe indicarse el identificador del fichero abierto para la lectura y

una cadena de caracteres indicando el patrón o formato de lectura. Los datos leídos
por la función serán devueltos por la función en un array.
En la segunda de las sintaxis posibles, además del identificador y la cadena de

formato se pueden indicar una lista de variables pasadas por referencia para que la
función almacene en ellas los datos leídos.
Las cadenas de formato de lectura incluyen una serie de codificaciones que señalan
el tipo de dato a leer. En concreto, los códigos de formato son los que se muestran
en la siguiente tabla:
%b Número entero en binario

%c Carácter
%d Número entero en base 10
%u Número entero sin signo
%f Número decimal
%o Número entero en octal (base 8)
%s Cadena de caracteres
%x o %X Número entero hexadecimal (base 16)
Tabla 12.2 Códigos de formato de lectura
Ejemplo 12.6:
Supóngase que Cinem@s dispone de un fichero de texto en el que guarda

información sobre sus clientes registrados; en concreto, el fichero contendrá el
nombre de cada cliente, su edad y el gasto total realizado en el último mes. El
contenido de este fichero podría ser:
Luis López Sánchez 18 76.4

Ana Antón Boo 21 50.2
Pedro Marcos Díez 24 82.5
Maria Martín Grau 33 12.7
Mónica Abad García 43 45.8
Jesús Bernal Cos 22 52.1
Como puede apreciarse este fichero está constituido por diferentes líneas en las que
se muestra para cada cliente su nombre, su edad y el gasto total separados por
301
tabulaciones. La lectura de los datos necesita conocer esta estructura para poder
leer en cada operación de lectura los tres datos de un cliente.
El programa PHP que realiza la lectura del fichero anterior y genera una lista
HTML a partir del contenido del mismo es:
<?php
$f = fopen("clientes.txt","r");
print "<UL>";
while ($datos = fscanf($f, "%s\t%d\t%f")) {
list($nombre, $edad, $gasto) = $datos;
print "<LI> $nombre de $edad años ha realizado " .
" un gasto total de $gasto euros. <BR>";
}
print "</UL>";
fclose($f);
?>
El programa anterior lo primero que realiza es la apertura del fichero con permiso de
lectura. A continuación genera la etiqueta HTML de inicio de lista y comienza el
bucle de lectura. En cada una de las iteraciones del bucle se realiza la llamada a la
función fscanf() para que lea, en este orden, una cadena de caracteres, un
tabulador, un número entero, otro tabulador y un número en coma flotante (cadena de
formato "%s\t%d\t%f"). Los tres valores leídos serán almacenados en el array de
nombre $datos. Cuando se alcance el final del fichero, y por tanto no existan más
datos a leer, la función fscanf() devolverá un valor booleano falso y por tanto el
bucle de lectura finalizará.
Dentro del cuerpo del bucle se utiliza la función list() para asignar valores a
tres variables ($nombre, $edad y $gasto) a partir de los tres valores que han
sido almacenados en el array $datos. Con esos tres valores de las variables se
genera el correspondiente ítem de la lista.
En concreto, el resultado del programa anterior sería una lista como la siguiente:
• Luis López Sánchez de 18 años ha realizado un gasto total de 76.4 euros.

• Ana Antón Boo de 21 años ha realizado un gasto total de 50.2 euros.
• Pedro Marcos Díez de 24 años ha realizado un gasto total de 82.5 euros.
• Maria Martín Grau de 33 años ha realizado un gasto total de 12.7 euros.
• Mónica Abad García de 43 años ha realizado un gasto total de 45.8 euros.
• Jesús Bernal Cos de 22 años ha realizado un gasto total de 52.1 euros.
302
MANEJO DE FICHEROS
La segunda de las sintaxis de la función fscanf() permitía indicar en su lista de

argumentos las variables en las que se desea que se almacenen directamente los
valores leídos. Estas variables deben ser pasadas por referencia, lo que significa
que deben ir precedidas del signo &.
Ejemplo 12.7:
Utilizando esta sintaxis alternativa, el programa del Ejemplo 12.6 podría escribirse
de la siguiente manera:
<?php
$f = fopen ("datos.txt","r");
print "<UL>";
while(!feof($f)){
$linea=fscanf($f,"%s\t%d\t%f",&$nombre,&$edad,&$gasto);
print "<LI> $nombre de $edad años ha realizado " .
" un gasto total de $gasto euros. <BR>";
}
print "</UL>";
fclose($f);
?>
12.2.4. OPERACIONES DE ESCRITURA DE DATOS

PHP dispone igualmente de funciones que permiten generar ficheros de texto o
escribir nuevos datos en ficheros ya existentes. Por supuesto, para poder utilizar
estas funciones es preciso que el fichero sea abierto con permiso de escritura, ya
que de otro modo se generaría un error.
La función que permite escribir cadenas de caracteres en un fichero de texto es

fwrite(), que admite dos sintaxis diferentes:
fwrite(idfichero, cadena)
fwrite(idfichero, cadena, numCaracteres)
En ambos caso se deben indicar en primer lugar el identificador del fichero de

destino y la cadena de caracteres a escribir. La segunda de las sintaxis recibe un
tercer parámetro que representa el número máximo de caracteres a escribir; en este
caso, si la cadena supera ese número será truncada. La función fwrite() dispone
de un alias o función sinónima que tiene exactamente la misma sintaxis y el mismo
uso, se trata de la función fputs().
303
Ejemplo 12.8:
Programa que genera un fichero de texto con los 100 primeros números pares:
<?php
$f = fopen("NumerosPares.txt","a");
for($i=1;$i<100;$i++) {
fwrite($f,2*$i."\t");
}
fclose($f);
?>
Ejemplo 12.9:
Utilizando las funcionalidades de lectura y escritura de ficheros en PHP se podría
crear en una página un sencillo contador de accesos. Bastaría con generar un
fichero de texto cuyo contenido inicial sea el valor 0 e incluir el siguiente programa
en la página correspondiente:
<?php
$f = fopen("contador.txt","r+");
$c = fgets($f);
$c++;
rewind($f);
fwrite($f,$c);
fclose($f);
print "Número de visitas de esta página: $c";
?>
El programa anterior abre el fichero contador.txt con permisos de lectura y

escritura, lee su contenido, almacenándolo en la variable $c, incrementa el valor de
esa variable en una unidad, reinicia el puntero del fichero al inicio del mismo
(función rewind()) y escribe el nuevo valor sobre el fichero borrando el anterior.
Con el valor de la variable muestra además un mensaje en la página indicando el
número total de accesos.
Otra sencilla utilidad de los ficheros podría ser la creación de un registro de

comentarios realizados por los visitantes de una página. En lugar de guardar
todos los comentarios sobre una base de datos se podría optar por añadirlos a
un fichero de texto.
Para comenzar se debería diseñar un formulario HTML a través del cual el usuario
hará sus comentarios. El formulario puede estar formado por una simple área de
texto y un botón de envío.
304
MANEJO DE FICHEROS
El aspecto final del formulario podría ser el que se muestra en la Figura 12.1 y su
código:
<html>
<head><title>Comentarios</title></head>
<body>
Por favor, ayúdenos a mejorar. <br>
Cualquier comentario que quiera realizar sobre nuestra
empresa nos será de utilidad
<form action="observaciones.php">
<textarea name="ob" rows=4 cols=30 >
</textarea>
<input type="submit" value="Enviar comentario">
</form>
</body>
</html>
Figura 12.1 Formulario de envío de comentarios
Cuando el usuario pulse sobre el botón de envío, su comentario será transferido en

una variable $ob a la página observaciones.php donde se encontrará el programa
que se encarga de escribirlo en el fichero. Este programa se incluye a continuación:
<?php
$f=fopen("Comentarios.txt","a");
fputs($f,"-------------------\n");
$fecha = date("d/m/Y");
fputs($f,"Fecha: $fecha \n");
305
fputs($f,"Comentario: \n$ob \n");

fclose($f);
print "Cinem@s le agradece su comentario";
?>
El fichero de texto generado tendrá una estructura como la que sigue:
-------------------
Fecha: 12/10/2004
Comentario:
Deberían hacer un esfuerzo por mejorar la limpieza de los
aseos
-------------------
Fecha: 14/10/2004
Comentario:
La verdad es que todo ha estado perfecto. Enhorabuena!!!
12.2.5. OTRAS FUNCIONES DE MANIPULACIÓN DE

FICHEROS
Existen otras funciones de manipulación de ficheros que pueden resultar útiles. Por
ejemplo, si se desea realizar una copia de un fichero puede usarse la función
copy(), cuya sintaxis es:
copy(nombreOrigen, nombreDestino)
Los argumentos que recibe esta función son los nombres del fichero de origen y el
de destino. En el caso que estos se encuentren en un directorio diferente al del
documento base (el que contiene el programa PHP) deberán indicarse los nombres
de los ficheros con sus respectivas rutas relativas. Cuando el fichero destino ya
existe, la operación de copiado borrará el fichero existente.
La función copy() devolverá un valor booleano indicando si la operación se

realizó satisfactoriamente.
Ejemplo 12.10:
Para realizar una copia de seguridad de un fichero cuyo nombre se encuentre en la
variable $nfichero, se podría utilizar la sentencia:
if (copy($nfichero, $nfichero.'.bak')) {
print ("Copia de seguridad realizada correctamente");
} else {
306
MANEJO DE FICHEROS
print ("Fallo en la copia de seguridad");

}
Si en lugar de hacer una copia del fichero lo que se desea es simplemente

cambiarle el nombre, podría utilizarse la función rename():
rename(nombreAntiguo, nombreNuevo)
De nuevo, la función devuelve un valor booleano indicando la realización

satisfactoria o no de la operación.
La operación de eliminación de un fichero de texto se puede realizar igualmente

desde un programa PHP. Para ello se dispone de la función unlink():
unlink(nombreFichero)
Las operaciones de manipulación de ficheros provocan errores cuando se tratan de

aplicar sobre ficheros que no existen, por ello puede ser interesante asegurarse
antes de la existencia de los mismos utilizando la función booleana
file_exists():
file_exists(nombreFichero)
12.3. ENVÍO DE FICHEROS A TRAVÉS DE

FORMULARIOS HTML
Para finalizar este capítulo destinado a presentar las funciones básicas de
manipulación de ficheros en PHP, se hace en esta sección una presentación de los

mecanismos del lenguaje HTML para el envío de todo tipo de archivos a través de
formularios y cómo los archivos enviados por los usuarios pueden ser recogidos
por los programas PHP.
El diseño de un formulario que permita el envío de ficheros exige el incluir en el

mismo un campo de tipo file e incluir en el comando de definición del formulario el
parámetro ENCTYPE indicando al formulario que se transferirán datos en archivos.
Ejemplo 12.11:
El siguiente formulario incluye uno de estos campos al que se le ha dado el nombre
fichero:
<FORM ENCTYPE="multipart/form-data"
307
ACTION="RecibirFichero.php" METHOD=POST>
<INPUT TYPE="hidden" name="MAX_FILE_SIZE" value="10000">
Fichero: <INPUT NAME="fichero" TYPE="file">
<INPUT TYPE="submit" VALUE="Enviar">
</FORM>
Como puede apreciarse, además del campo de tipo file, el formulario incluye un
campo oculto que permite indicar el tamaño máximo de los ficheros que se
permitirá al usuario enviar (MAX_FILE_SIZE).
El aspecto del formulario anterior sería el siguiente:
Cuando el usuario envía el fichero a través del formulario, se reciben en el

programa de destino (RecibirFichero.php en este caso) una serie de variables que
permitirán guardar el fichero enviado en el servidor:
— $fichero fichero temporal generado en el servidor

— $fichero_name nombre original del fichero
— $fichero_size tamaño del fichero
— $fichero_type tipo de fichero
El nombre de estas variables viene determinado por el nombre del correspondiente

campo del formulario HTML. En el caso del formulario anterior este campo tenía
precisamente como nombre fichero.
Al recibir los datos del formulario se genera en el servidor un fichero temporal

($fichero) que si se desea conservar es preciso renombrar con la función

rename(). Este proceso se podría realizar con el siguiente script:
<?php
print "Fichero recibido";
rename($fichero,$fichero_name);
?>
308
BASES DE DATOS
RELACIONALES Y EL
LENGUAJE SQL
13.1. INTRODUCCIÓN
Las bases de datos constituyen hoy en día los elementos clave sobre los que se
apoyan los sistemas de información de empresas e instituciones. Una base de datos
podría definirse como una colección de datos interrelacionados que son
almacenados en un soporte informático. Algunas razones que justifican su uso son
su capacidad para almacenar grandes volúmenes de información, la optimización
de su gestión, la facilidad para realizar consultas y la exactitud, rapidez y fiabilidad
en su administración.
Aunque en ocasiones son términos que se confunden, a la hora de hablar de las

bases de datos debe distinguirse lo que es propiamente la información almacenada
(datos, restricciones y relaciones) y el conjunto de programas que actúan de
intermediarios entre la información y el usuario (SGBD: Sistema Gestor de Bases
de Datos). En este libro se mostrará uno de los sistemas gestores de bases de datos
más populares: MySQL.
309
Por supuesto, en el desarrollo de aplicaciones web las bases de datos desempeñan

un papel esencial. Muchas de las páginas web a las que accedemos habitualmente
se generan como resultado de una consulta a una base de datos, poniendo de
manifiesto su carácter dinámico. El objetivo final que persigue este libro es generar
aplicaciones web dinámicas mediante el uso del lenguaje PHP, una parte
importante de ese dinamismo se conseguirá a través de la conectividad a bases de
datos. Es por ello que en estos tres próximos capítulos se presentan los
fundamentos de las bases de datos relacionales y el uso del sistema gestor MySQL,
al igual que la sintaxis básica del lenguaje de consulta SQL.
13.2. DISEÑO DE BASES DE DATOS
13.2.1. MODELO RELACIONAL

Para la generación de bases de datos se utiliza habitualmente el denominado
"modelo relacional". Este modelo se basa en representar los datos mediante tablas
con diferentes atributos a modo de columnas. La existencia de atributos comunes
en las tablas permite establecer relaciones entre ellas.
Ejemplo 13.1:
Un banco podría almacenar la información sobre sus clientes y los saldos en sus
cuentas bancarias mediante dos simples tablas:
Clientes Nombre DNI Nº cuenta Cuentas Nº cuenta Saldo

Luis López 73456123 1001 1001 12.523€

Ana Sánchez 56712765 1002 1002 5.650€
Antonio Briz 22871274 1002 1003 24.758€
Antonio Briz 22871274 1003 1004 2.651€
Sara Salas 12567234 1004
Cada una de las filas de las tablas se suele denominar tupla o registro, y a su vez
está formada por una serie de valores cuyo tipo coincide con el del correspondiente
atributo.
En este caso, el atributo común entre las dos tablas (Nº cuenta) es el que permite
relacionar los clientes con sus cuentas. Además, lo normal es que cada tabla tenga
un atributo o conjunto de atributos cuyo valor identifique de forma única a los
registros, este atributo es el que se denomina clave. En el caso de la tabla de
310
BASES DE DATOS RELACIONALES Y EL LENGUAJE SQL
clientes, el atributo DNI es una clave, ya que es imposible que dos clientes distintos
tengan el mismo DNI.
En la definición de una base de datos relacional se debe indicar claramente la
estructura de cada tabla, con los nombres y tipos de cada uno de sus atributos, así
como las diferentes claves y otras restricciones sobre los mismos.
El ejemplo anterior ilustra una situación bastante simplificada que, por supuesto,
tiene algunos inconvenientes que podrían ser superados con una mejor elección de
tablas. Por ejemplo, con el diseño anterior, cuando un cliente tiene más de una
cuenta, tal como ocurre en este caso, se duplican sus datos. La utilización de una
tabla intermedia que sirva de enlace entre los DNI y los números de cuenta evitaría
este problema. En definitiva, el correcto diseño de una base de datos no es algo
trivial y requiere una cuidadosa planificación. A este respecto existe una teoría
bastante desarrollada sobre el diseño de bases de datos para evitar las redundancias
e inconsistencias: la teoría de la normalización. No es el objetivo de este libro
profundizar en aspectos de diseño de bases de datos, aquel lector que esté
interesado en estos temas puede acudir a la amplia bibliografía específica.
13.2.2. DIAGRAMAS ENTIDAD/RELACIÓN

Los diseños de bases de datos suelen apoyarse en diagramas a través de los cuales
se tratan de visualizar las diferentes entidades que intervienen, las relaciones entre
ellas y el tipo de estas relaciones. Estos gráficos son de ayuda para decidir las
distintas tablas que deben ser utilizadas en la base de datos.
Existe una amplia variedad de herramientas, pertenecientes a la categoría de las

denominadas herramientas CASE (Computer Added Software Engineering), que
permiten realizar estos gráficos y al mismo tiempo generar la base de datos

propiamente dicha. En la próxima sección se utilizará precisamente una de estas
herramientas para generar una base de datos que servirá para desarrollar en torno a
ella toda una aplicación web.
13.3. UN EJEMPLO ILUSTRATIVO: CINEM@S

Supóngase que la empresa Cinem@s, cuyo sitio web se comenzó a desarrollar en el
Capítulo 3, está interesada en desarrollar un sistema para la consulta de la cartelera y
compra de entradas a través de Internet. Parece evidente que en este caso necesitará
disponer de una base de datos con toda la información relativa a las diferentes
proyecciones de cada sala y generar a partir de ella las páginas web de su portal.
Haciendo uso de PHP y MySQL se podrá diseñar no solo un sistema de consulta de
311
cartelera actualizada, sino también un sistema de consulta de horarios, búsquedas de

películas, consulta de disponibilidades de salas, compra de entradas,...
En esta sección se presentará la estructura de la base de datos a crear, para en los
capítulos posteriores analizar la forma de administrar esa base de datos con
MySQL, y llegar a efectuar operaciones de actualización y consulta desde las
páginas del propio sitio web. Una vez presentada la estructura, se hará un rápido
repaso a las sentencias básicas del lenguaje de definición y manipulación de datos
SQL.
Para comenzar es preciso identificar las entidades que intervienen en el problema

planteado, en este caso, estas podrían ser:
1. Las películas.
2. Las salas disponibles.
3. Las proyecciones.
4. Las entradas.
5. Los clientes.
Cada una de las entidades se caracterizará por unos atributos, así cada película
tiene un título, un director, una lista de actores, un género, un año de realización,...
A cada atributo se le asignará un tipo de datos concreto, así por ejemplo, el título
de una película puede ser tratado como una cadena de un máximo de 50 caracteres,
o el año como un número entero.
Una vez establecidos los atributos de cada entidad, el siguiente paso es definir las
relaciones entre las tablas o entidades. La existencia de una relación se concretará

en la inclusión como atributo en una tabla de la clave de la tabla relacionada. La
Figura 13.1 ilustra el modelo concreto de la base de datos que desarrollará,
incluyendo las entidades con sus atributos y tipos respectivos, y sus relaciones.
La Figura 13.1 ha sido generada mediante la herramienta CASEstudio

(http://www.casestudio.com). Con esta herramienta Case se pueden
diseñar bases de datos y crear diagramas Entidad/Relación soportando
NOTA más de 20 diferentes tipos de gestores de bases de datos, por ejemplo
Oracle, MySQL, MSSQL, Interbase, SybaseASE y otros sistemas de
bases de datos. Además del diagrama entidad/relación, CASEstudio
permitirá generar de forma automática el código SQL que construye
toda la base de datos.
312
Figura 13.1 Diagrama entidad/relación para la base de datos de Cinem@s

El tipo de relaciones que se aprecian en el diagrama entidad/relación corresponden

a lo que se suele denominar relaciones de uno a varios, por ejemplo, la relación
entre los clientes y las entradas establece que un cliente puede comprar todas las
entradas que desee, pero una entrada puede ser adquirida solo por un único cliente.
Los atributos que en cada tabla aparecen señalados con las siglas PK (Primary
Key) corresponden a las claves de cada una de ellas. En cambio, los señalados con
FK (Foreign Key) corresponden a atributos que son claves en otras tablas (claves
foráneas) y sirven para relacionar los registros de una tabla con los de la
subordinada.
Los atributos que tendrá cada una de las entidades consideradas son descritos en detalle
en la Tabla 13.1 (entidad Películas), Tabla 13.2 (entidad Proyecciones), Tabla 13.3
(entidad Salas), Tabla 13.4 (entidad Entradas) y Tabla 13.5 (entidad Clientes).
313
ENTIDAD PELÍCULAS
Nombre de atributo Tipo de datos Descripción
IDPELICULA Valor numérico que actuará de
Número entero
identificador de cada película
TITULO Cadena de caracteres Título de la película
ACTORES Listado de actores de la película que se
Cadena de caracteres
presentarán separados por comas
PRODUCCION Productor, o productores, en su caso, de
Cadena de caracteres
la película
DIRECCION Cadena de caracteres Director o directores de la película
GUION Cadena de caracteres Guionista o guionistas de la película
ANNO Número entero Año de realización de la película
DURACION Número entero Duración de la película en minutos
NACIONALIDAD Cadena de caracteres Nacionalidad de la película
Género de la película elegido entre una
GENERO Cadena de caracteres serie de opciones predeterminadas:
drama, comedia, acción....
Opción que establece restricciones de
EDAD_RESTRICCION Cadena de caracteres edad para los espectadores: apta, mayores
de 7, mayores de 13, mayores de 18
SINOPSIS Cadena de caracteres Breve resumen de la película
CARTELERA Imagen del cartel promocional de la
Imagen
película
Tabla 13.1 Atributos de la entidad Películas
ENTIDAD PROYECCIONES
IDPROY Valor numérico que actuará de
Número entero
identificador de cada proyección

IDPELICULA Valor numérico que identifica la
Número entero
película que se proyectará
NUM_SALA Número de la sala en donde se
Número entero
proyectará la película
HORA Hora Hora de inicio de la proyección
FECHA Fecha Fecha de la proyección
Indica si la proyección tiene o no una
TARIFA_REDUCIDA Lógico(verdadero/falso) tarifa reducida, por ejemplo, sesiones
matinales, proyecciones especiales,...
ESTRENO Indica si la proyección es emitida como
Lógico(verdadero/falso)
estreno o no
Tabla 13.2 Atributos de la entidad Proyecciones
314
ENTIDAD SALAS
NUM_SALA Valor numérico identificativo de cada
Número entero
sala
AFORO Número entero Número total de asientos de la sala.
NUM_FILAS Número entero Número total de filas de la sala
Cadena de caracteres que permitirá
OBSERVACIONES Cadena de caracteres almacenar cualquier tipo de observación
sobre la sala
Tabla 13.3 Atributos de la entidad Salas
ENTIDAD ENTRADAS
NUM_ENTRADA Valor numérico que actuará de
Número entero
identificador de cada entrada
IDPROY Valor numérico que identifica la
Número entero
proyección correspondiente
FILA Número entero Número de fila de la entrada
NUM_ASIENTO Número entero Número de asiento de la entrada
NUM_CLIENTE Valor numérico que identifica al cliente
Número entero
que compra la entrada
RECOGIDA Indica si la entrada ha sido recogida o

Lógico(verdadero/falso)
no por el cliente
Tabla 13.4 Atributos de la entidad Entradas

ENTIDAD CLIENTES
Valor de tipo numérico que actuará de
NUM_CLIENTE Número entero

identificación del cliente.
NOMBRE Cadena de caracteres Nombre del cliente
DIRECCION Cadena de caracteres Dirección postal del cliente
FECHANAC Fecha Indica la fecha de nacimiento del cliente
TELEF Cadena de caracteres Teléfono del cliente.
EMAIL Cadena de caracteres Dirección de e-mail del cliente
Valor numérico que almacenará el
PUNTOS_ACUM número total de puntos que va
Número entero
acumulando el espectador por la compra
de entradas
Indica una clave secreta que el cliente
CLAVE Cadena de caracteres tendrá que utilizar para realizar cualquier
operación de compra de entradas
Tabla 13.5 Atributos de la entidad Clientes
315
En las próximas secciones se verá la forma en la que la base de datos diseñada

puede ser implementada en un sistema gestor como MySQL, para ello será preciso
estudiar previamente, y de forma breve, las sentencias básicas del lenguaje SQL.
13.4. EL LENGUAJE SQL
13.4.1. INTRODUCCIÓN
SQL es un lenguaje de definición y manipulación de datos para bases de datos
relacionales. Es un lenguaje de definición porque permite definir la estructura de
las tablas que componen la base de datos, y de manipulación porque permite
efectuar consultas y realizar operaciones como inserción, borrado y actualización
de los datos que contiene.
El lenguaje SQL tiene sus orígenes en el lenguaje SEQUEL (Structured English

QUEry Language) desarrollado por IBM, un lenguaje para la especificación de las
características de las bases de datos que adoptaban el modelo relacional. En 1979
aparece el primer SGBD basado en SQL: ORACLE. Rápidamente comenzaron a
aparecer en el mercado múltiples productos de bases de datos basados en SQL:
SQL/DS, DB2, SYBASE, INTERBASE, INFORMIX y otros. El amplio desarrollo
del lenguaje hizo necesario un proceso de estandarización para conseguir que el
SQL soportado por los distintos sistemas tuviera una sintaxis común.
Las características destacables de este lenguaje son:

Posee una firme base teórica.
—
— Gran capacidad expresiva.
— Flexibilidad.
— Sus sentencias permiten manejar conjuntos de registros.
— Tiene una estructura simple.
— Alta productividad en la codificación (con una sola sentencia pueden
efectuarse consultas complejas).
— SQL no es un lenguaje de programación (su código no necesita
compilarse).
SQL puede usarse de dos maneras:
316
— Interactivamente, escribiendo directamente las sentencias y obteniendo

automáticamente el resultado. Es decir, como lenguaje autocontenido.
— Como lenguaje embebido en un lenguaje de programación anfitrión (4GL,
Cobol, Fortran, C, Basic,...). De esta forma SQL se complementa con la
capacidad expresiva, lógica y de cálculo del lenguaje anfitrión. Este uso
está reservado para los usuarios programadores.
En este libro se utilizará el SQL embebido dentro de programas PHP y también se

hará un uso interactivo a través de la línea de comandos de MySQL.
13.4.2. SENTENCIAS DE DEFINICIÓN DE DATOS
Creación de la base de datos

Las sentencias SQL de definición de datos permiten crear la base de datos y los
diferentes objetos que la componen, como por ejemplo, tablas, vistas, índices, etc.
La sentencia utilizada para la creación de objetos es CREATE.
La creación de un objeto requiere la asignación de un nombre que lo identifique

una vez creado, cualquier referencia posterior a él hace uso de ese identificador.
Los identificadores en SQL deben estar formados por letras, dígitos o signos de
subrayado, pero siempre comenzando por una letra y, por supuesto, sin coincidir
con ninguna de las palabras reservadas del lenguaje.
El primer objeto a crear es la propia base de datos, para ello se utilizará el siguiente
comando:
CREATE DATABASE nombre_base_de_datos
Donde nombre_base_de_datos es el identificador escogido para referenciar

a la base de datos que se está creando.
Ejemplo 13.2:
Para crear la base de datos de la empresa Cinem@s que se utilizará a lo largo de los
próximos capítulos, la sentencia es la siguiente:
CREATE DATABASE CINEMAS;
317
Todo objeto creado con la sentencia CREATE puede ser modificado con la
sentencia ALTER o destruido con la sentencia DROP, de manera que, si se quisiera
destruir la bases de datos anterior, la sentencia a utilizar sería:
DROP DATABASE CINEMAS;
El lenguaje SQL no distingue el uso de mayúsculas y minúsculas. En este

NOTA
libro se utilizará como convenio las mayúsculas para escribir todas las
sentencias SQL, de esta manera serán más fácilmente identificables.
Creación de tablas
Una vez creada la base de datos, el paso siguiente es la creación de la estructura de
cada una de sus tablas.
La sintaxis más simple de la sentencia de creación de tablas es la siguiente:
CREATE TABLE nombre_tabla (atrib1 dominio1,

atrib2 dominio2,
...............
...............
...............
atribN dominioN)
donde:
nombre_tabla es el identificador utilizado para referirse a la tabla.

atribX es el nombre de un atributo de la tabla.
dominioX es el dominio en el que puede tomar valores el atributo
correspondiente.
Respecto a los dominios de los atributos, SQL incorpora un conjunto de dominios

básicos, permitiendo definir atributos de tipo cadena de caracteres, de tipo
numérico, de fecha y hora,...
Además de indicar el dominio de cada atributo, a la hora de definir las tablas

pueden señalarse igualmente diferentes características de los mismos, como por
ejemplo si no se permitirán valores nulos para ese atributo, si el valor debe ser
único, valores por defecto,...
318
Ejemplo 13.3:
El código SQL que crea la tabla de la base de datos Cinem@s correspondiente a la
entidad Clientes sería:
CREATE TABLE CLIENTES (

NUM_CLIENTE SMALLINT NOT NULL AUTO_INCREMENT,
NOMBRE VARCHAR(40) NOT NULL,
DIRECCION VARCHAR(50),
FECHANAC DATE,
TELEF CHAR(9),
EMAIL CHAR(30),
PUNTOS_ACUM SMALLINT NOT NULL DEFAULT 0,
CLAVE CHAR(6) NOT NULL,
PRIMARY KEY (NUM_CLIENTE));
En el código anterior puede observarse cómo cada atributo tiene asociado un tipo
de dato; por ejemplo, el atributo NOMBRE será una cadena de un máximo de 40
caracteres (VARCHAR(40)), el atributo NUM_CLIENTE tendrá un valor numérico
de tipo entero en un rango pequeño (SMALLINT), o la fecha de nacimiento tendrá
un valor de tipo fecha (DATE). En el capítulo destinado al estudio del sistema
gestor MySQL se presentarán con detalle todos los tipos de datos admitidos.
En la definición de la tabla CLIENTES se observa igualmente cómo alguno de los

atributos tienen a continuación de su tipo las palabras NOT NULL; se trata de
palabras reservadas del lenguaje SQL que indican que el correspondiente atributo
no puede tomar valores nulos, es decir, todos los registros que sean incluidos en la
tabla deberán tener obligatoriamente un valor para ese atributo. Por ejemplo, en la
tabla CLIENTES, tal como está definida, los únicos atributos que obligatoriamente
deben tener un valor son: NUM_CLIENTE, NOMBRE, PUNTOS_ACUM y CLAVE,

de manera que a la hora de dar de alta un nuevo cliente no sería necesario dar su
dirección de correo electrónico o teléfono, por ejemplo.
Sobre el atributo NUM_CLIENTE de la tabla CLIENTES se deben hacer dos

observaciones adicionales. Por un lado, en la última línea de la definición de la
tabla se establece como clave de la tabla (PRIMARY KEY) precisamente ese
atributo; de esta manera el número de cliente identificará a cada cliente. Además de
eso, en la definición del atributo se ha utilizado la palabra AUTO_INCREMENT
para indicar que el valor de ese atributo en cada registro se generará de forma
automática de manera incremental.
Finalmente, la palabra DEFAULT se utiliza para dar valores por defecto a

determinado atributo, de manera que si al crear un registro no se da valor a ese
319
atributo este tomará el valor por defecto. Tal como se aprecia en la definición de la
tabla CLIENTES, el único atributo que tiene valor por defecto es PUNTOS_ACUM,
siendo este valor 0; esto provoca que cuando se produzca el alta de un nuevo
cliente, su saldo de puntos acumulados sea 0, a no ser que se dé otro valor.
La sentencia CREATE crea la estructura de la tabla pero no su contenido, es decir,

sus registros. Estos deberán ser añadidos posteriormente mediante la instrucción
INSERT. Esta sentencia INSERT podrá ser usada de forma interactiva o bien
dentro de un programa que se encargue de leer los datos a insertar, por ejemplo de
un fichero existente creado al efecto.
Ejemplo 13.4:
A continuación se incluye el código SQL completo de generación de todas las
tablas de la base de datos CINEMAS:
CREATE TABLE PELICULAS (

IDPELICULA SMALLINT NOT NULL AUTO_INCREMENT,
TITULO CHAR(50) NOT NULL,
ACTORES MEDIUMTEXT,
PRODUCCION MEDIUMTEXT,
DIRECCION MEDIUMTEXT,
GUION VARCHAR(40),
ANNO SMALLINT,
DURACION SMALLINT NOT NULL,
NACIONALIDAD VARCHAR(25),
GENERO ENUM('infantil','comedia','drama',
'acción','terror','erótica'),
EDAD_RESTRICCION ENUM('apta','mayores 7',
'mayores 13','mayores 18'),

SINOPSIS LONGTEXT,
CARTELERA BLOB,
PRIMARY KEY (IDPELICULA));
CREATE TABLE SALAS (

NUM_SALA SMALLINT NOT NULL,
AFORO SMALLINT NOT NULL,
NUM_FILAS SMALLINT NOT NULL,
OBSERVACIONES LONGTEXT,
PRIMARY KEY (NUM_SALA));
CREATE TABLE PROYECCIONES (

IDPROY SMALLINT NOT NULL AUTO_INCREMENT,
IDPELICULA SMALLINT NOT NULL,
NUM_SALA SMALLINT NOT NULL,
320
HORA TIME NOT NULL,

FECHA DATE NOT NULL,
TARIFA_REDUCIDA BOOL,
ESTRENO BOOL,
PRIMARY KEY (IDPROY));
CREATE TABLE ENTRADAS (

NUM_ENTRADA SMALLINT NOT NULL AUTO_INCREMENT,
IDPROY SMALLINT NOT NULL ,
FILA SMALLINT NOT NULL ,
NUM_ASIENTO SMALLINT NOT NULL ,
NUM_CLIENTE SMALLINT NOT NULL ,
RECOGIDA BOOL ,
PRIMARY KEY (NUM_ENTRADA));

NOMBRE VARCHAR(40) NOT NULL,
DIRECCION VARCHAR(50),
FECHANAC DATE,
TELEF CHAR(9),
EMAIL CHAR(30),
PUNTOS_ACUM SMALLINT NOT NULL DEFAULT 0,
CLAVE CHAR(6) NOT NULL,
PRIMARY KEY (NUM_CLIENTE));
Para mejorar la legibilidad, las sentencias SQL pueden partirse en

NOTA
tantas líneas como se desee y utilizar todos los espacios en blanco extra
que se quiera.
Modificación de tablas
Una vez creada una tabla, es posible su modificación utilizando la sentencia
ALTER.
Ejemplo 13.5:
A continuación se incluyen algunos ejemplos de usos de la sentencia ALTER para
modificar la tabla CLIENTES:
321
⎯ Cambio del nombre de la tabla CLIENTES:
ALTER TABLE CLIENTES RENAME TABLA_CLIENTES;
⎯ Cambio del nombre de un atributo de la tabla CLIENTES:
ALTER TABLE CLIENTES CHANGE FECHANAC FNACIMIENTO DATE;
⎯ Cambio del tipo de dato de un atributo de la tabla CLIENTES:
ALTER TABLE CLIENTES CHANGE CLAVE CLAVE VARCHAR(10);
⎯ Añadir un nuevo atributo a la tabla CLIENTES:
ALTER TABLE CLIENTES ADD E_CIVIL ENUM('soltero','casado',

'otros');
⎯ Eliminación de un atributo de la tabla CLIENTES:
ALTER TABLE CLIENTES DROP E_CIVIL;
Creación de índices
Otro de los aspectos a considerar a la hora de construir las tablas de la base de
datos es la posibilidad de definir índices. Un índice es un archivo estructurado que
facilita el acceso a los datos en las operaciones de búsqueda. Los índices se deben
crear sobre aquellos atributos que suelen ser utilizados con frecuencia en las
búsquedas. Normalmente los sistemas gestores crean automáticamente un índice
sobre los atributos declarados como claves, y el programador puede optar por
añadir nuevos índices, pero siempre con precaución de no abusar de su uso, ya que
si se tienen demasiados índices la gestión de los datos se hace más costosa.
Los índices son creados, como cualquier elemento, con la sentencia CREATE,
aunque con una sintaxis diferente.
Ejemplo 13.6:
A continuación se incluyen dos ejemplos de creación de índices, uno sobre el
atributo FECHA de la tabla PROYECCIONES y otro sobre el atributo TITULO de
la tabla PELICULAS:
322
CREATE INDEX FECHA_IDX ON PROYECCIONES(FECHA);

CREATE INDEX TITULO_IDX ON PELICULAS(TITULO);
También es posible utilizar la sentencia ALTER para añadir un índice a una tabla
creada previamente; por ejemplo:
ALTER TABLE CLIENTES ADD INDEX (NOMBRE);
Claves ajenas: relaciones entre tablas

En la definición de tablas se pueden definir claves ajenas (FOREIGN KEY), es
decir, atributos que son claves primarias de otras tablas, de esta manera ambas
tablas quedan relacionadas. La forma de hacerlo es incluir en la definición de la
tabla una instrucción con la siguiente sintaxis:
FOREIGN KEY (atributo) REFERENCES Tabla_enlazada

(atributo)
Ejemplo 13.7:
En la tabla de PROYECCIONES se incluyó un atributo (IDPELICULA) que hacía
referencia a otro atributo, en este caso del mismo nombre, de la tabla PELICULAS.
En principio, si no se definen claves ajenas podría darse la situación de existir una
proyección con un código de película inexistente en la tabla de películas, con la
correspondiente inconsistencia. La forma de evitar este problema es definir
precisamente en la tabla de proyecciones el correspondiente atributo como una
clave ajena que referencia a la tabla de películas. Como la tabla ya ha sido creada,
esta modificación se puede realizar mediante la sentencia ALTER:
ALTER TABLE PROYECCIONES ADD FOREIGN KEY (IDPELICULA)

REFERENCES PELICULAS (IDPELICULA);
Otra posibilidad es definir las claves ajenas de cada tabla de la misma manera en la
que se definen las claves primarias en la propia definición de la tabla.
Ejemplo 13.8:
La tabla de ENTRADAS podría haber sido definida incluyendo dos claves ajenas,
una referenciando a las proyecciones y otra a los clientes:

323

RECOGIDA BOOL ,
PRIMARY KEY (NUM_ENTRADA),
FOREIGN KEY (IDPROY) REFERENCES PROYECCIONES (IDPROY),
FOREIGN KEY (NUM_CLIENTE) REFERENCES CLIENTES
(NUM_CLIENTE) );
Cuando se produce una operación de modificación o borrado de los datos de una

tabla que se encuentra relacionada con otra, puede ser necesario que se produzca
una actualización en cascada de la tabla relacionada.
Ejemplo 13.9:
Si una película es dada de baja en la tabla PELICULAS, entonces se deberían
eliminar de la tabla de PROYECCIONES todos aquellos registros que hacían
referencia a esa película. La forma en la que se indica esta necesidad de borrado en
cascada es:

REFERENCES PELICULAS (IDPELICULA)
ON DELETE CASCADE ON UPDATE CASCADE;
En otros casos puede ser interesante que no se borren los registros relacionados y
que simplemente a los campos que han quedado con un valor no existente les sean
asignados el valor NULL, o incluso, que se queden con el valor inicial a pesar de su
inconsistencia. Para hacer esto, en la sentencia anterior debería cambiarse la
palabra CASCADE por SET NULL, en el primer caso, o NO ACTION, en el

segundo.
La forma en la que se trabaja con claves ajenas en MySQL es un tanto

NOTA
especial, por lo que se analizará con más detalle cuando se estudie la
integridad referencial en el capítulo dedicado al sistema gestor MySQL.
13.4.3. LA SENTENCIA INSERT

Una vez creadas la base de datos y sus tablas, el siguiente paso es añadir los datos,
ya que toda tabla generada con CREATE estará vacía.
324
La sentencia INSERT permite añadir una o varias filas (registros) a una tabla. En
la práctica, para insertar datos en una base de datos se utilizan programas de
entrada orientados a formularios o rutinas que importan los datos desde ficheros o
documentos, realizando procesos iterativos de lectura de datos. Uno de los
objetivos finales que persigue este libro es poder realizar esas operaciones de
inserción desde una página web, para ello será preciso utilizar las sentencias SQL
en programas PHP que a su vez estarán integrados en documentos HTML.
La sintaxis básica de la sentencia INSERT es la siguiente:
INSERT INTO nombre_tabla VALUES (lista_de_valores)
Con esta sintaxis, deben ser introducidos tantos valores como atributos de la tabla;
además, los valores deben darse en el mismo orden en el que se encuentren
definidos los respectivos atributos. Por supuesto, los valores introducidos deben
coincidir con el tipo del correspondiente atributo.
SQL admite un valor especial, el valor NULL, que indica que el correspondiente
atributo está vacío en el registro insertado. Únicamente pueden utilizarse estos
valores nulos sobre atributos que no tengan en su declaración la cláusula NOT
NULL.
Debe aclararse también que las filas de una tabla no están ordenadas, por lo que no
es posible insertar una fila "al comienzo" o "al final" o "entre dos filas" de la tabla.
Ejemplo 13.10:
A continuación se muestran dos ejemplos de inserción de registros en la tabla
SALAS y en la tabla CLIENTES:
INSERT INTO SALAS

VALUES (1, 300, 15, 'Zona para minusválidos');
Esta sentencia insertaría una nueva sala, cuyo número correspondería al 1, con
capacidad para 300 personas, distribuidas en 15 filas y se incluiría en el campo de
observaciones el hecho de tener una zona reservada para minusválidos.
INSERT INTO CLIENTES

VALUES (147, 'Luis Medina Ríos',
'Los Laureles, 129 – 39005 Santander',
'1965-2-21', '942323135',
'medinal@mimail.com', 0, 'lmr65b');
325
Esta sentencia inserta un nuevo cliente con número de identificación 147, de

nombre "Luis Medina Ríos", con la dirección indicada, nacido el 21 de febrero de
1965, siendo su teléfono 942323135, su dirección de correo electrónico
medinal@mimail.com, con un saldo de puntos inicial de 0 y con clave de
operaciones 'lmr65b'.
En SQL las cadenas de caracteres deben darse entre comillas simples.

Las fechas y horas también son dadas entre comillas y en principio se
NOTA pueden utilizar diferentes formatos. Al analizar el sistema MySQL se
indicarán estos formatos.
En la última inserción realizada en la tabla CLIENTES se puede observar cómo, a

pesar de que el atributo NUM_CLIENTE había sido definido como autoincremental
y el atributo PUNTOS_ACUM tenía un valor por defecto de 0, al insertar el registro
se asignaron también valores para esos dos atributos.
Surge, a la vista de esta situación, la necesidad de disponer de una sintaxis

adicional de la sentencia INSERT que permita insertar valores solo para
determinados atributos. En este caso, a la hora de insertar el registro se deberán
indicar los nombres de los atributos, sin ser necesario que el orden de los valores a
incluir y el de los atributos en la tabla coincidan. La sintaxis de esta variante es:
INSERT INTO nombre_tabla (lista_atributos)

VALUES (lista_valores)
Ejemplo 13.11:
Se podría insertar un nuevo cliente en la tabla con la sentencia:
INSERT INTO CLIENTES (NOMBRE, FECHANAC, EMAIL, CLAVE)

VALUES ('Andrea Fuentes Dávila', '1970-3-31',
'afd@tumail.com', 'and349');
Como puede observarse, en este caso no se dan valores para todos los atributos de
la tabla. En concreto, el atributo NUM_CLIENTE al no tener valor y haber sido
declarado como autoincremental, tomará automáticamente como valor el número
siguiente al valor más alto que se encuentre almacenado en la columna
NUM_CLIENTE de la tabla hasta ese momento. El atributo PUNTOS_ACUM, al no
habérsele dado ningún valor y tener definido uno por defecto, tomará
automáticamente este último (0 en este caso). Al resto de atributos a los que no se
326
les ha dado valor (DIRECCION y TELEFONO) se les asignará automáticamente el

valor especial NULL, siempre y cuando el correspondiente atributo admita ese
valor.
Ejemplo 13.12:
Se incluye a continuación una sentencia que permitiría dar de alta una nueva sala:
INSERT INTO SALAS (AFORO, NUM_FILAS, NUM_SALA)

VALUES (400, 20, 3);
Como se aprecia, no se dan valores a todos los atributos (faltaría el atributo

OBSERVACIONES) y además el orden en el que se dan los valores no coincide con
el orden de los atributos en la tabla.
Otra de las posibilidades de inserción de datos es la utilización de la conocida

como "sentencia de inserción multifila". Esta sentencia permite añadir múltiples
filas a una tabla en una sola sentencia. En este caso los valores para las nuevas filas
no son especificados explícitamente, sino que se utiliza una consulta (sentencia
SELECT) para obtener esos valores. Su sintaxis es:
INSERT INTO nombre_tabla (lista_atributos)

Consulta_SELECT
La sentencia INSERT multifila proporciona un modo eficiente y compacto de

copiar datos.
Ejemplo 13.13:
Si se dispone de una tabla adicional PELICULAS_TERROR para guardar en ella

todas las películas del género de terror con una estructura totalmente similar a la de
la tabla PELICULAS, estas podrían insertarse con una sentencia como la que
sigue:
INSERT INTO PELICULAS_TERROR

SELECT * FROM PELICULAS WHERE GENERO = 'terror';
En este caso, el uso del signo "*" es una forma de indicar todos los atributos de la
tabla.
327
13.4.4. LA SENTENCIA DELETE

Por supuesto, todo registro almacenado en una tabla puede ser eliminado en
cualquier momento. La sentencia que permite eliminar una o varias filas de una
tabla es DELETE, cuya sintaxis es:
DELETE FROM nombre_tabla WHERE condición
Esta sentencia elimina de la tabla indicada todas las filas que cumplan la condición
señalada. Si se suprime la cláusula WHERE, se borrarán todas las filas de la tabla,
pero no la tabla; recuérdese que la instrucción que destruye completamente la tabla
(datos y estructura) es DROP TABLE.
Las filas no pueden borrarse parcialmente, es decir, no pueden suprimirse valores

concretos de una fila.
Ejemplo 13.14:
Las sentencias de eliminación de registros serían:
⎯ Eliminación del cliente número 1456:
DELETE FROM CLIENTES WHERE NUM_CLIENTE = 1456;
⎯ Eliminación de las entradas de las primeras 5 filas para la proyección número 231:
DELETE FROM ENTRADAS WHERE FILA <= 5 AND IDPROY = 231;

Las sentencias DELETE con condiciones simples permiten seleccionar las filas a
suprimir basándose únicamente en los propios contenidos de las filas. Sin embargo,
también es posible efectuar la selección de las filas a suprimir en base a los datos
contenidos en otras tablas.
Ejemplo 13.15:
Si se desea eliminar todas las proyecciones de la película Refugio en el paraíso, se
podría utilizar la sentencia:
DELETE FROM PROYECCIONES WHERE

IDPELICULA = (SELECT IDPELICULA FROM PELICULAS WHERE
TITULO = 'Refugio en el paraíso');
328
13.4.5. LA SENTENCIA UPDATE

La sentencia UPDATE permite modificar los valores de los atributos de uno o
varios registros almacenados en la tabla. La sintaxis de la sentencia es:
UPDATE nombre_tabla SET lista_asignaciones WHERE condición
La parte final de la sentencia, la cláusula WHERE es opcional; en caso de no

indicarse, la actualización afectaría a todos los registros de la tabla.
En una misma sentencia se pueden actualizar los valores de varios atributos, indicando las
asignaciones separadas por comas.
Ejemplo 13.16:
Sentencias de actualización de registros serían:
⎯ Reducción del aforo de todas las salas en un 10%:
UPDATE SALAS SET AFORO = AFORO * 0.9;
⎯ Otorgar 100 puntos extra a todos los clientes que tengan un saldo de puntos
acumulados menor que 500:
UPDATE CLIENTES SET PUNTOS_ACUM = PUNTOS_ACUM + 100

WHERE PUNTOS_ACUM < 500;
⎯ Modificar el aforo y el número de filas de la sala número 7:

UPDATE SALAS SET AFORO = 500, FILAS = 25

WHERE NUM_SALA = 7;
Al igual que ocurría con la sentencia DELETE, también es posible efectuar la

selección de las filas a actualizar en base a los datos contenidos en otras tablas.
Ejemplo 13.17:
Se desea establecer tarifa reducida para todas las proyecciones de películas rodadas
antes de 1990, la sintaxis de la sentencia sería:
UPDATE PROYECCIONES SET TARIFA_REDUCIDA = 1

WHERE IDPELICULA =
329
(SELECT IDPELICULA FROM PELICULAS WHERE ANNO <

1990);
El tipo booleano o lógico no es uno de los tipos estándar de SQL; en el

caso de MySQL, se dispone del tipo BOOL que realmente es un sinónimo
del tipo TINYINT(1) que permite almacenar un número entero de 1 bit (0
NOTA ó 1). El valor 1 puede identificarse con el valor lógico "verdadero" y el
valor 0 con "falso".
13.4.6. LA SENTENCIA SELECT

Las consultas son la base del SQL, mediante ellas se extrae información de las
diferentes tablas de la base de datos, mostrándola en una estructura tabular.
Toda consulta en SQL se realiza con la sentencia SELECT. Esta es sin duda la
sentencia más poderosa y completa con la que cuenta el lenguaje SQL. Su sintaxis
completa es:
SELECT [Cuantificador_de_conjunto] items

FROM Nombre_de_tabla
[WHERE Condición_de_búsqueda]
[GROUP BY Columna_de_agrupación]
[HAVING Condición_de_búsqueda]
[ORDER BY Especificación_de_ordenación]
Todos los fragmentos que en esta sintaxis aparecen encerrados entre corchetes son
opcionales.
La sentencia SELECT consta de varias partes diferentes:
— Cláusula SELECT: en ella se indican los datos a recuperar en la consulta.

Los items indicados deben ir separados por comas y pueden ser:
o Un nombre de columna (atributo) de una tabla.
o Un asterisco (*), que es equivalente a especificar los nombres de
todas las columnas de la tabla.
o Una constante, indicando que el mismo valor constante va a
aparecer en todas las filas de los resultados de la consulta.
o Una expresión SQL, cuyo valor será calculado a partir de los
valores de los atributos.
— El cuantificador de conjunto es opcional, puede ser:
330
o ALL (opción por defecto): indica que en el resultado de la consulta

deben mostrarse todas las filas, incluyendo las repetidas.
o DISTINCT: indica que en el resultado de la consulta no deben
mostrarse las filas repetidas.
— Cláusula FROM: en ella se indican, separadas por comas, las tablas que
contienen los datos que se desean recuperar en la consulta.
— Cláusula WHERE: permite indicar una condición de búsqueda.
— Cláusula GROUP BY: permite obtener consultas resumen en las que todas
las filas similares son agrupadas y se genera una fila resumen para cada
grupo.
— Cláusula HAVING: permite indicar condiciones o filtros a verificar por los

diferentes grupos producidos por la cláusula GROUP BY.
— Cláusula ORDER BY: señala el modo de ordenación de los resultados de

la consulta. Si se omite, los resultados no aparecen ordenados.
Proyecciones de una tabla

Las únicas cláusulas obligatorias son SELECT y FROM. Con esta sintaxis mínima
se pueden generar las consultas más sencillas en SQL, las proyecciones de una
tabla, es decir, aquellas que solicitan columnas de datos de una única tabla en la
base de datos.
La sintaxis mínima es:
SELECT lista_columnas FROM nombre_de_tabla
Ejemplo 13.18:
Si se quisiera recuperar todos los registros de la tabla PELICULAS, se debería
utilizar la sentencia:
SELECT * FROM PELICULAS;
En cambio, si lo único que interesa es obtener un listado con los títulos y

nacionalidades de las películas, la sentencia a utilizar sería:
SELECT TITULO, NACIONALIDAD FROM PELICULAS;
331
Una consulta SQL puede incluir columnas calculadas cuyos valores se obtienen a
partir de los valores de los datos almacenados.
Ejemplo 13.19:
Se desea listar las salas disminuyendo el aforo en un 10%, la sentencia para ello sería:
SELECT NUM_SALA, AFORO * 0.9 FROM SALAS;
En estas consultas con campos calculados pueden utilizarse diferentes funciones de

SQL además de las propias de cada gestor de bases de datos. Por ejemplo, existen
funciones para tratamiento de fechas y horas, para tratamiento de cadenas de
caracteres,...
Eliminación de duplicados
Si una consulta incluye la clave primaria de una tabla en su lista de selección,
entonces cada fila de resultados será única; en cambio, si no se incluye la clave en
la lista de selección pueden aparecer filas duplicadas en el resultado. Se pueden
eliminar las filas duplicadas en la consulta insertando la palabra clave DISTINCT
en la sentencia SELECT justo antes de la lista de selección.
Ejemplo 13.20:
Al seleccionar todos los directores de las películas de la tabla PELICULAS pueden
aparecer algunos de ellos duplicados (los que han dirigido varias películas), por
tanto habría dos opciones para esta consulta:
⎯ Listar todos los directores de películas aunque se produzca duplicidad de

información:
SELECT DIRECTOR FROM PELICULAS;
⎯ Listar todos los directores de películas, sin duplicidad:
SELECT DISTINCT DIRECTOR FROM PELICULAS;
Consultas con condiciones de selección

Para especificar condiciones de selección en las consultas se utiliza la cláusula
WHERE. En este caso el resultado de la consulta estará formado por todas las filas
que cumplan la condición de búsqueda especificada.
332
Ejemplo 13.21:
Algunas consultas con condiciones de selección serían:
⎯ Obtener los títulos de todas las películas de una duración inferior a 120
minutos:
SELECT TITULO FROM PELICULAS WHERE DURACION < 120;
⎯ Obtener un listado con las direcciones de correo electrónico de todos los

clientes que tengan 1.000 puntos acumulados:
SELECT EMAIL FROM CLIENTES WHERE PUNTOS_ACUM = 1000;
⎯ Seleccionar las entradas para la proyección de número de identificación 341 y

que correspondan a filas comprendidas entre la 10 y la 14:
SELECT * FROM ENTRADAS WHERE IDPROY = 341

AND FILA BETWEEN 10 AND 14;
⎯ Obtener los títulos de todas las películas de nacionalidad española, francesa o

italiana:
SELECT TITULO FROM PELICULAS WHERE

NACIONALIDAD IN ('española','francesa','italiana');
⎯ Generar un listado con los títulos y directores de todas las películas en las que
participe Antonio Banderas:
SELECT TITULO,DIRECCION FROM PELICULAS WHERE

ACTORES LIKE '%Banderas%';
Como se puede apreciar en estos ejemplos, el lenguaje SQL tiene una sintaxis muy
similar al lenguaje natural, y ofrece una gran capacidad expresiva para generar
consultas.
Ordenación de los resultados de una consulta

Para ordenar los resultados de una consulta se utiliza la cláusula ORDER BY
seguida de una lista de especificaciones de ordenación separadas por comas. La
primera especificación de ordenación es la principal y las otras serán utilizadas en
caso de igualdad de valor en la primera. Cada especificación de ordenación está
dada por el nombre de un atributo seguido de una de las palabras siguientes:
333
ASC Indica orden ascendente.

DESC Indica orden descendente.
En caso de no indicar el tipo de orden, por defecto se entiende que es ascendente.
Ejemplo 13.22:
Se desea generar un listado de clientes en orden decreciente según el atributo de
puntos acumulados y en orden creciente según el nombre, la sentencia sería:
SELECT * FROM CLIENTES ORDER BY PUNTOS_ACUM DESC,NOMBRE

ASC;
Consultas multitabla
SQL permite también recuperar datos procedentes de diferentes tablas mediante
una única sentencia SELECT, esto es lo que se conoce como "composición".
Ejemplo 13.23:
A continuación se presentan algunos sencillos ejemplos de consultas multitabla:
⎯ Se desea saber todas las fechas en las que se proyecta la película El Señor de
los Anillos:
SELECT FECHA FROM PELICULAS,PROYECCIONES WHERE

TITULO = 'El Señor de los Anillos' AND
PELICULAS.IDPELICULA = PROYECCIONES.IDPELICULA;
En este caso, la consulta utiliza dos tablas y es preciso en la condición de

selección indicar la igualdad entre los dos atributos comunes a las dos tablas.
⎯ Se desea un listado con los nombres de todos los clientes que hayan adquirido
alguna entrada para ver la película El Señor de los Anillos:
SELECT NOMBRE FROM

PELICULAS,PROYECCIONES,ENTRADAS,CLIENTES
WHERE
TITULO = 'El Señor de los Anillos' AND
PELICULAS.IDPELICULA = PROYECCIONES.IDPELICULA
AND
PROYECCIONES.IDPROY = ENTRADAS.IDPROY AND
ENTRADAS.NUM_CLIENTE = CLIENTES.NUM_CLIENTE;
334
Al intervenir en las consultas anteriores columnas o atributos con el

mismo nombre, aunque en tablas diferentes, es necesario utilizar los
nombres cualificados, es decir, precedidos de los nombres de las tablas
NOTA a las que pertenecen.
Aún cuando no exista conflicto de nombres, también es posible utilizar

los nombres cualificados y evitar ambigüedades.
Consultas resumen
SQL permite resumir los datos mediante un conjunto de funciones denominadas
funciones de columna. Algunas de ellas son:
SUM() Calcula la suma total de los valores de una columna.

AVG() Calcula el valor promedio de una columna.
MIN() Encuentra el valor más pequeño de una columna.
MAX() Encuentra el valor más grande de una columna.
COUNT() Cuenta el número de valores de una columna.
Ejemplo 13.24:
A continuación se muestran ejemplos de consultas resumen:
⎯ Cálculo de la duración media de todas las películas del género comedia:

SELECT AVG(DURACION) FROM PELICULAS
WHERE GENERO = 'comedia';
⎯ Obtención de la capacidad de aforo de la sala más grande:
SELECT MAX(AFORO) FROM SALAS;
⎯ Cálculo de la suma de los puntos acumulados por los clientes número 321, 543,
287 y 721:
SELECT SUM(PUNTOS_ACUM) FROM CLIENTES

WHERE NUM_CLIENTE IN (321,543,287,721);
⎯ Obtener el número total de películas de nacionalidad española:
SELECT COUNT(*) FROM PELICULAS

WHERE NACIONALIDAD = 'española';
335
Consultas agrupadas
Las consultas agrupadas o resumen producen una única fila de resultados a modo
de "totales"; sin embargo, en ocasiones es interesante obtener resúmenes parciales
o agrupados por categorías. Esto se consigue con la cláusula GROUP BY.
Ejemplo 13.25:
Dos ejemplos de consultas agrupadas serían las siguientes:
⎯ Obtener para cada género de películas, la duración máxima:
SELECT MAX(DURACION) FROM PELICULAS GROUP BY GENERO;
⎯ Contar el número de entradas compradas por cada cliente:
SELECT NOMBRE, COUNT(NUM_ENTRADA) FROM CLIENTES,ENTRADAS

WHERE CLIENTES.NUM_CLIENTE = ENTRADAS.NUM_CLIENTE
GROUP BY NOMBRE;
Condiciones de búsqueda de grupos

De la misma manera que en las consultas agrupadas la cláusula WHERE puede ser
utilizada para rechazar filas individuales, la cláusula HAVING puede emplearse
para rechazar grupos de filas.
El formato de la cláusula HAVING es similar a la cláusula WHERE y permite indicar

una condición de búsqueda para grupos. A diferencia de lo que ocurría en la

cláusula WHERE, sí es posible utilizar funciones de columna en la condición de la
cláusula HAVING.
Ejemplo 13.26:
Se desea obtener el nombre de todos los clientes que hayan adquirido 20 o más
entradas; la forma de conseguirlo sería utilizando la sentencia:
SELECT NOMBRE, COUNT(NUM_ENTRADA) FROM CLIENTES,ENTRADAS

WHERE CLIENTES.NUM_CLIENTE = ENTRADAS.NUM_CLIENTE
GROUP BY NOMBRE
HAVING COUNT(NUM_ENTRADA) >= 20;
336
En principio la cláusula HAVING está pensada para su utilización conjunta con la

cláusula GROUP BY; sin embargo, también es posible utilizar HAVING sin GROUP
BY, en este caso SQL considera el conjunto entero de resultados como un único
grupo y le aplica la condición de selección de HAVING.
337
EL SISTEMA GESTOR
DE BASES DE DATOS
MYSQL
14.1. ¿QUÉ ES MySQL?

MySQL es un sistema de administración de bases de datos relacionales rápido,

sólido y flexible. Es ideal para crear bases de datos con acceso desde páginas web
dinámicas, para la creación de sistemas de transacciones on-line o para cualquier
otra solución profesional que implique almacenar datos, teniendo la posibilidad de
realizar múltiples y rápidas consultas.
MySQL ofrece varias ventajas respecto a otros sistemas gestores de bases de datos:
— Tiene licencia pública, permitiendo no solo la utilización del programa sino
también la consulta y modificación de su código fuente. Resulta por tanto fácil
de personalizar y adaptar a las necesidades concretas.
— El programa está desarrollado en C y C++, lo que facilita su integración en
otras aplicaciones desarrolladas igualmente en esos lenguajes.
— Puede ser descargado gratuitamente de Internet (http://www.mysql.com)
haciendo uso de su licencia GPL.
339
— Para aquellos que deseen que sus desarrollos basados en MySQL no sean
"código abierto" existe también una licencia comercial.
— MySQL utiliza el lenguaje SQL (Structured Query Languaje – Lenguaje de
Consulta Estructurado) que es el lenguaje de consulta más usado y
estandarizado para acceder a bases de datos relacionales. Soporta la sintaxis
estándar del lenguaje SQL para la realización de consultas de manipulación,
creación y de selección de datos.
— Es un sistema cliente/servidor, permitiendo trabajar como servidor
multiusuario y de subprocesamiento múltiple, es decir, cada vez que se
establece una conexión con el servidor, el programa servidor crea un
subproceso para manejar la solicitud del cliente, controlando el acceso
simultáneo de un gran número de usuarios a los datos y asegurando el acceso
solo a usuarios autorizados.
— MySQL dispone de un sistema sencillo de ayuda en línea, y de un monitor que
permite realizar todas las operaciones desde la línea de comandos del sistema,
sin necesitar ningún tipo de interfaze de usuario gráfica. Esto facilita la
administración remota del sistema utilizando telnet.
— Es portable, es decir, puede ser llevado a cualquier plataforma informática.
MySQL está disponible en más de veinte plataformas diferentes incluyendo las
distribuciones más usadas de Linux, sistema operativo Mac X, UNIX y
Microsoft Windows.
— Es posible encontrar gran cantidad de software desarrollado sobre MySQL o
que soporte MySQL. En concreto, son de destacar diferentes aplicaciones open
source para la administración de las bases de datos a través de un servidor web.
Todas estas características han hecho de MySQL uno de los sistemas gestores de
bases de datos más utilizado en la actualidad, no solo por pequeñas empresas sino
también por algunas grandes corporaciones, como puedan ser: Yahoo! Finance,
Google, CISCO, MP3.com, Motorola, NASA, Silicon Graphics, Texas
Instruments,... A mediados de 2004 se estimaba que existían más de 5 millones de
instalaciones activas del programa.
14.2. UTILIZACIÓN DE MySQL
14.2.1. ARRANQUE DEL SERVIDOR MySQL

MySQL dispone de dos programas principales: el servidor o motor y el cliente o
monitor MySQL. El primero de ellos se encarga de estar a la espera de posibles
340
EL SISTEMA GESTOR DE BASES DE DATOS MYSQL
peticiones recibidas de los clientes; mientras que el segundo es el encargado de

actuar de interfaz con el usuario.
Para comenzar a utilizar el sistema MySQL lo primero que se debe hacer es
arrancar su programa servidor. Este programa se ejecutará en un segundo plano
como un proceso o servicio, no tiene una interfaz de usuario y su único propósito
es estar a la espera de que alguien se conecte a él y le envíe una solicitud.
La forma de arrancar el servidor MySQL es ejecutar el programa mysqld desde la

línea de comandos del sistema. Este programa puede encontrarse dentro del
subdirectorio bin del directorio mysql. En el caso de Windows, la sentencia de
arranque del servidor es:
C:\mysql\bin> mysqld
Para comprobar si el servidor se ha arrancado correctamente puede usarse el

comando mysqlshow. Si el motor se ha iniciado, este comando mostrará un
listado con las bases de datos disponibles en ese momento.
C:\mysql\bin> mysqlshow
+-------------+
| Databases |
+-------------+
| mysql |
| test |
+-------------+
Al instalar MySQL, se crean dos bases de datos: mysql y test. La primera

contendrá información necesaria para el sistema (usuarios registrados, privilegios,...) y
la base de datos test es una base de datos vacía disponible para hacer pruebas sobre
ella. El usuario podrá generar posteriormente cuantas bases de datos desee.
Si se desea detener el servidor de MySQL la sentencia a utilizar sería:
C:\mysql\bin> mysqladmin shutdown
Por supuesto, una vez detenido el servidor no se podrá realizar ninguna operación
sobre las bases de datos.
Si se desea que el servidor se arranque automáticamente, en Windows

2000/XP puede usarse el Panel de Control de Herramientas
NOTA
Administrativas, en concreto, el apartado de servicios.
341
14.2.2. INICIO DEL MONITOR DE MYSQL

El programa cliente de MySQL, también conocido como monitor de MySQL, es
una internaz que permite a un usuario conectarse al servidor MySQL para realizar
operaciones sobre las bases de datos. Este monitor funciona a través de la línea de
comandos del sistema y aunque este hecho parezca un tanto arcaico, facilita
notablemente la administración del sistema de forma remota, por ejemplo, a través
de conexiones telnet.
Para poder arrancar el monitor de MySQL es preciso disponer de un usuario

autorizado. En MySQL todo usuario queda identificado por un nombre de usuario,
una contraseña y un servidor desde el que se realiza la conexión. Conviene aclarar
este último extremo, ya que el establecimiento de la conexión al servidor de
MySQL puede realizarse desde el propio equipo en el que está instalado MySQL
(localhost) o desde un equipo remoto.
Al instalar MySQL se crean automáticamente cuatro cuentas de usuario:

— Dos cuentas de usuario de nombre root y contraseña vacía, con todo tipo de
privilegios sobre las bases de datos. Existen dos cuentas de usuario root
porque en una de ellas se autoriza el acceso desde el mismo equipo en el que
está instalado el servidor de MySQL (localhost) y en la otra el acceso se
permite desde cualquier otro servidor (%).
— Dos cuentas de usuario invitado con nombre de usuario y contraseña vacías. De
nuevo existen dos cuentas de invitado, una para las conexiones desde el
localhost y otra para las conexiones desde otros servidores (%). Estas cuentas
permiten a cualquier usuario establecer una conexión con el servidor MySQL.
En principio estos usuarios únicamente tendrían acceso a la base de datos

test o cualquier base de datos cuyo nombre comience por 'test_', pero no
podrán realizar operaciones de tipo administrativo sobre el sistema. Sin
embargo, debe advertirse que en la versión Windows de MySQL los usuarios
invitados que se conecten desde el propio servidor localhost tendrán plenos
privilegios sobre todas las bases de datos.
Por supuesto, para garantizar la seguridad y privacidad de las bases de datos una de
las primeras operaciones que debería hacerse es el establecimiento de contraseñas
para los usuarios, sobre todo para el usuario root, ya que al tener contraseña vacía
cualquier persona podría acceder con todos los privilegios. Igualmente, en el caso
de trabajar sobre Windows, se recomienda eliminar la cuenta de usuario invitado
con privilegios de superusuario.
342
Más adelante se explicará la forma de realizar estos cambios, de momento se usará

una de las cuentas de usuario por defecto para entrar por primera vez en el monitor
de MySQL.
Para arrancar el monitor de MySQL debe escribirse en la línea de comandos del

sistema la instrucción:
C:\mysql\bin> mysql –p
si se desea acceder con la cuenta de usuario invitado, o la instrucción:
C:\mysql\bin> mysql –u root –p
si se desea acceder con la cuenta de usuario root. En cualquiera de los dos casos,
el sistema solicitaría la introducción del password, que cómo se ha comentado,
inicialmente es vacío.
Enter password:
Tras introducir ese password vacío se entraría en el monitor de MySQL,

apareciendo un mensaje de bienvenida como el siguiente:
Welcome to the MySQL monitor. Commands end with ; or \g.

Your MySQL connection id is 12 to server version:4.0.18-nt
Type 'help;' or '\h' for help. Type 'c\' to clear the

buffer.
Mysql>
La Figura 14.1 ilustra el proceso de arranque del servidor de MySQL,

comprobación de la correcta ejecución del mismo e inicio del monitor de MySQL
con el usuario root de contraseña vacía.
En general, la sintaxis para acceder al monitor con un usuario registrado es:
C:\mysql\bin> mysql –h nombreservidor –u nombreusuario –p
Opcionalmente se puede incluso añadir al final de la sentencia el nombre de la base

de datos con la que se desea trabajar. El modificador –h se utiliza para especificar
el equipo donde se encuentra el servidor MySQL, si es que es diferente del equipo
desde el que se establece la conexión, -u permite indicar el nombre del usuario y –
p hace que se solicite a continuación el password.
343
Figura 14.1 Arranque del servidor de MySQL desde la línea de comandos del sistema
14.3. EJECUCIÓN DE SENTENCIAS SQL

Una vez dentro del monitor de MySQL el símbolo o prompt del sistema cambia,
pasando a ser:
mysql>
A través de la línea de comandos del monitor de MySQL se podrán escribir

directamente sentencias en el lenguaje SQL que serán dirigidas al servidor.
Cuando se desee salir del monitor de MySQL y regresar a la línea de comandos del
sistema, se tendría que ejecutar la sentencia:
mysql> EXIT
o
mysql> QUIT
Dentro del monitor todas las sentencias SQL que se ejecuten deberán
finalizar con un signo de punto y coma, las sentencias pueden ocupar
varias líneas y el uso de letras mayúsculas o minúsculas es indiferente.
NOTA
Una vez dentro del monitor de MySQL, se pueden ejecutar directamente sentencias
SQL de manera interactiva.
344
Ejemplo 14.1:
Como primera orden se podría solicitar un listado de las bases de datos disponibles:
mysql> show databases;

+----------+
| Database |
+----------+
| mysql |
| test |
+----------+
2 rows in set (0.01 sec)
Ejemplo 14.2:
También se podría ejecutar una sencilla consulta de selección para solicitar al
servidor que muestre la fecha actual y la versión de MySQL que se encuentra
instalada:
mysql> SELECT CURRENT_DATE, VERSION();

+--------------+-----------+
| CURRENT_DATE | VERSION() |
+--------------+-----------+
| 2004-03-25 | 4.0.18-nt |
+--------------+-----------+
1 row in set (0.61 sec)
Ejemplo 14.3:
Es posible realizar sencillas operaciones matemáticas:
mysql> SELECT COS(EXP(2/3)), (3+5)*4;

+---------------+---------+
| COS(EXP(2/3)) | (3+5)*4 |
+---------------+---------+
| -0.368075 | 32 |
+---------------+---------+
Ejemplo 14.4:
También se puede solicitar que se muestre el usuario y la base de datos actual:
mysql> SELECT USER(),DATABASE();

+----------------+------------+
| USER() | DATABASE() |
+----------------+------------+
| root@localhost | |
+----------------+------------+
345
Como se aprecia en esta última consulta, los usuarios quedan identificados por un
nombre formado por el nombre de usuario y la identificación del servidor desde el
que se conectan separados por el signo '@'. En el caso de que el servidor desde el
que se conecta sea el mismo que el servidor en el que se encuentra instalado
MySQL, esta identificación se limita al nombre localhost.
También se aprecia en la consulta anterior que la base de datos actual aparece

vacía. MySQL puede tener muchas bases de datos, pero para poder utilizar una de
ellas debe ser seleccionada previamente. La sentencia para realizar esta operación
es USE.
Ejemplo 14.5:
Si se desea usar la base de datos mysql (una de las dos bases de datos creadas por
defecto), la sentencia sería:
mysql> USE MYSQL;

Database changed
Una vez seleccionada la base de datos con la que se desea trabajar, todas las
operaciones posteriores irán dirigidas a ella, a no ser que explícitamente se seleccione
una nueva base de datos. Si se realiza de nuevo la selección de la base de datos actual
se podría apreciar cómo ahora sí que aparece el nombre de la correspondiente base de
datos
mysql> SELECT DATABASE();

+------------+
| DATABASE() |
+------------+
| mysql |
+------------+
14.4. GESTIÓN DE USUARIOS
14.4.1. LA TABLA USER
La base de datos mysql consta de 6 tablas. Entre ellas destaca la tabla user, en
la que se incluyen todos los usuarios registrados por el sistema. Esta tabla contiene
no solo la información sobre los nombres, contraseñas y servidores de los usuarios,
346
sino también un gran número de campos para establecer los diferentes privilegios
de cada usuario; por ejemplo, si los usuarios pueden crear nuevas bases de datos,
realizar operaciones de actualización, inserción, borrado,...
Ejemplo 14.6:
Si se desea consultar las tablas de la base de datos mysql se podría utilizar la
siguiente instrucción:
mysql> SHOW TABLES;

+-----------------+
| Tables_in_mysql |
+-----------------+
| columns_priv |
| db |
| func |
| host |
| tables_priv |
| user |
+-----------------+
Cuando se desea ver una descripción completa de la estructura de una tabla puede
usarse la instrucción DESCRIBE o SHOW COLUMNS.
Ejemplo 14.7:
Para mostrar la estructura de la tabla user, se podría utilizar cualquiera de las dos
sentencias siguientes:
mysql> DESCRIBE USER;
mysql> SHOW COLUMNS FROM USER;
En ambos casos, en la consola aparecería una descripción de los campos de la

tabla, indicando el nombre de cada atributo, el tipo y otras características como la
aceptación de valores nulos o valores por defecto para el atributo. En concreto, los
campos que componen la tabla user son los que se muestran en la Tabla 14.1.
De todos los atributos de la tabla user, los tres primeros (host, user y
password) identifican a cada usuario y los restantes establecen sus privilegios.
Por ejemplo, el atributo Insert_priv puede tomar el valor 'N' (no) o el valor
'Y' (yes), siendo el primero el valor por defecto, y determina si el usuario tiene o
347
no privilegios para insertar datos en las tablas. El control de privilegios en MySQL

es bastante completo, permitiendo incluso establecer privilegios individuales para
cada tabla de cada base de datos; en el próximo capítulo se explicará con más
detalle la gestión de privilegios de usuarios.
Campo Tipo Atributos Nulo Def.

Host varchar(60) BINARY No
User varchar(16) BINARY No
password varchar(16) No
Select_priv enum('N', 'Y') No N
Insert_priv enum('N', 'Y') No N
Update_priv enum('N', 'Y') No N
Delete_priv enum('N', 'Y') No N
Create_priv enum('N', 'Y') No N
Drop_priv enum('N', 'Y') No N
Reload_priv enum('N', 'Y') No N
Shutdown_priv enum('N', 'Y') No N
Process_priv enum('N', 'Y') No N
File_priv enum('N', 'Y') No N
Grant_priv enum('N', 'Y') No N
References_priv enum('N', 'Y') No N
Index_priv enum('N', 'Y') No N
Alter_priv enum('N', 'Y') No N
Show_db_priv enum('N', 'Y') No N
Super_priv enum('N', 'Y') No N
Create_tmp_table_priv enum('N', 'Y') No N
Lock_tables_priv enum('N', 'Y') No N
Execute_priv enum('N', 'Y') No N

Repl_slave_priv enum('N', 'Y') No N
Repl_client_priv enum('N', 'Y') No N
ssl_type enum('','ANY','X509', No
'SPECIFIED')
ssl_cipher blob BINARY No
x509_issuer blob BINARY No
x509_subject blob BINARY No
max_questions int(11) No 0
max_updates int(11) UNSIGNED No 0
max_connections int(11) UNSIGNED No 0
Tabla 14.1 Campos de la tabla user
348
Ejemplo 14.8:
Si se desea obtener un listado con los nombres de usuario, contraseñas y servidores de
todos los usuarios registrados, se podría realizar una simple consulta de selección:
mysql> SELECT USER,PASSWORD,HOST FROM USER;

+------+----------+-----------+
| USER | PASSWORD | HOST |
+------+----------+-----------+
| root | | localhost |
| root | | % |
| | | localhost |
| | | % |
+------+----------+-----------+
En este momento pueden observarse los cuatro usuarios definidos por defecto, los
dos superusuarios root y los dos usuarios invitados.
14.4.2. ELIMINACIÓN DE USUARIOS

Como se ha recomendado anteriormente, una de las primeras operaciones a realizar
debería ser la supresión de los usuarios invitados (los que tienen nombre de usuario
vacío). La supresión de un usuario implica la eliminación del correspondiente
registro de la tabla user; por tanto, debería usarse la sentencia DELETE.
Ejemplo 14.9:
La eliminación de los usuarios de nombre vacío se haría de la siguiente manera:
mysql> DELETE FROM user WHERE user='';

Query OK, 2 rows affected (0.16 sec)
Una vez realizada la eliminación, se puede repetir la consulta de selección de usuarios

para comprobar que realmente los dos usuarios invitados han sido eliminados:
mysql> SELECT user,password,host FROM user;

+------+----------+-----------+
| user | password | host |
+------+----------+-----------+
| root | | localhost |
| root | | % |
+------+----------+-----------+
349
Sin embargo, se puede comprobar que si se sale del monitor (sentencia EXIT) y se
vuelve a entrar con usuario invitado (mysql –p), el sistema permitiría aún el
acceso. La razón es que para que los cambios de usuario tengan efecto, el servidor
MySQL debe reiniciarse. La forma de reiniciar el servidor es mediante la ejecución
del programa mysqladmin con la opción reload desde fuera del monitor
MySQL. A continuación se observa esta secuencia de operaciones:
mysql> exit
Bye
C:\mysql\bin>mysqladmin reload
C:\mysql\bin>mysql -p
Enter password:
ERROR 1045: Access denied for user: 'ODBC@localhost'
(Using password: NO)
C:\mysql\bin>mysql -u root -p
Enter password:
Your MySQL connection id is 22 to server version: 4.0.18-
nt
Type 'help;' or '\h' for help. Type '\c' to clear the

buffer.
Como puede observarse, una vez eliminados los usuarios invitados y reiniciado el
servidor, la única posibilidad sería entrar con el usuario root.
14.4.3. ESTABLECIMIENTO DE CONTRASEÑAS PARA

LOS USUARIOS
Otra de las operaciones que conviene realizar cuanto antes es el establecimiento de
una contraseña para el usuario root, ya que este usuario viene por defecto con
una contraseña vacía que evidentemente no ofrece ningún tipo de seguridad. Los
passwords se pueden asignar de varias maneras, una primera forma es utilizar la
sentencia SET PASSWORD.
Ejemplo 14.10:
Si se desea establecer como password la cadena 'miclave' para el usuario root
cuando se conecte desde el propio servidor local, la sentencia sería:
350
mysql> SET PASSWORD FOR 'root'@'localhost' =

-> PASSWORD('miclave');
La función PASSWORD() permite encriptar el password antes de guardarlo en la

tabla. Aunque su uso no es obligado, sí que resulta recomendable ya que de esta
manera si un usuario tiene acceso a la tabla user no podrá ver el password real al
hacer una consulta de selección.
Una vez realizada la operación de asignación de contraseña, se podría solicitar de

nuevo el listado de los usuarios registrados:
mysql> SELECT user,password,host FROM user;

+------+------------------+-----------+
| user | password | host |
+------+------------------+-----------+
| root | 0ff1bdab147337f1 | localhost |
| root | | % |
+------+------------------+-----------+
Como puede comprobarse el usuario root conectándose desde el localhost

tiene asignado un password, aunque el valor real de ese password no se muestra en
el resultado de la consulta.
La contraseña anterior también podría ser establecida usando la sentencia UPDATE

para modificar directamente la tabla user:
mysql> UPDATE user SET password = PASSWORD('miclave')

-> WHERE user = 'root';
En este ultimo caso se está asignando la contraseña al mismo tiempo para los dos
usuarios root (el que se conecta desde el servidor local y el que lo hace desde
cualquier otro servidor).
Cuando se modifica directamente la tabla user, para que los cambios tengan
efecto inmediato, debe decirse al sistema que vuelva a leer todas las tablas de
privilegios, de otra manera, los cambios no tendrían efecto hasta que se reinicie el
servidor MySQL. Esto se realiza con la sentencia:
mysql> FLUSH PRIVILEGES;
Finalmente, también es posible asignar contraseñas con el programa mysqladmin

desde fuera del monitor MySQL.
351
Para que cualquier cambio relativo a usuarios y sus privilegios tenga efecto, es
necesario ejecutar la sentencia FLUSH PRIVILEGES o reiniciar el servidor
MySQL desde fuera del monitor. Esto último puede hacerse usando el programa
mysqladmin:
C:\mysql\bin> mysqladmin reload
Una vez establecida la contraseña del usuario root, se debería entrar de nuevo en
el monitor con la sentencia:
C:\mysql\bin> mysql –u root -p
El monitor solicitará el nuevo password para entrar.
También es posible entrar en el monitor directamente introduciendo la contraseña

sin esperar a que el programa la solicite:
C:\mysql\bin> mysql –u root -pmiclave
En este caso la contraseña se indica a continuación del parámetro –p, sin dejar
ningún espacio entre ambos. Además si la contraseña contiene espacios en blanco o
caracteres especiales, esta debería darse entre comillas dobles.
Esta forma de indicar la contraseña no es recomendable por ser un método

sumamente inseguro de proporcionar la contraseña; ya que un usuario podría ver
los comandos que se están ejecutando en el sistema y en esos comandos aparecería
esta contraseña.
Por último, conviene aclarar que si a continuación del parámetro –p se coloca un

espacio, lo que sigue se interpreta como la base de datos sobre la que se desea
trabajar. Por ejemplo, la sentencia siguiente permitiría entrar en el monitor y
seleccionar directamente la base de datos mysql:
C:\mysql\bin> mysql –u root –p mysql
14.4.4. CREACIÓN DE NUEVOS USUARIOS

La creación de un nuevo usuario no es más que la inclusión de un nuevo registro en
la tabla user. En principio, no es necesario asignar explícitamente valores para
todos los campos de esa tabla, ya que todos ellos tienen valores por defecto.
352
Ejemplo 14.11:
Con la sentencia:
mysql> INSERT INTO user (Host , User , password)

-> VALUES ('localhost', 'operador',
PASSWORD('snoopy'));
se crea un nuevo usuario que se podrá conectar desde el propio servidor local, con
nombre de usuario operador y contraseña snoopy. Este usuario tendrá los
privilegios establecidos por defecto, estos privilegios solo le permiten el uso de la
tabla test.
A continuación puede verse cómo efectivamente este nuevo usuario tendrá un

acceso a MySQL limitado.
C:\mysql\bin>mysql -u operador -p
Enter password: ******
nt

buffer.
mysql> show databases;

+----------+
| Database |
+----------+
| test |
+----------+
Ejemplo 14.12:
Si se desea crear un nuevo usuario que tenga permisos solo para seleccionar e
insertar nuevos registros y que pueda conectarse desde cualquier servidor, la
sentencia de inserción debería ser:
mysql> INSERT INTO user (Host , User , password,

-> Select_priv , Insert_priv)
-> VALUES ('%', 'mantenimiento', PASSWORD('mickey'),
-> 'Y', 'Y');
353
Con estos privilegios el usuario mantenimiento podría ver los datos almacenados
en cualquier tabla de cualquier base de datos y podría insertar nuevos registros e
incluso crear nuevas tablas para insertar registros en ellos. Lo que no podría hacer
son operaciones de modificación de datos, eliminación de registros, creación de
nuevas bases de datos,...
MySQL admite una gestión de privilegios de usuario bastante completa. Más

adelante en este libro se analizarán algunas herramientas de gestión de MySQL que
permiten realizar las labores de administración de usuarios de una manera mucho
más cómoda.
14.5. BASES DE DATOS Y TABLAS EN MySQL

MySQL viene provisto por defecto de dos bases de datos, la primera tiene un uso
puramente administrativo y la segunda es una base de datos para la realización de
pruebas. Por supuesto, todo usuario con los privilegios adecuados puede crear
nuevas bases de datos. La creación implica el uso de la instrucción CREATE
DATABASE.
Ejemplo 14.13:
Para ilustrar el proceso completo de creación de la base de datos se tomará como
referencia la base de datos de los multicines Cinem@s que ya fue diseñada en el
capítulo anterior. El primer paso, por supuesto, es arrancar el monitor MySQL con
un usuario que tenga los privilegios necesarios. En este caso se utilizará el
superusuario root:
Enter password: ******
nt

buffer.
Una vez dentro, se debe crear la base de datos, utilizando para ello la sentencia
CREATE:
mysql> CREATE DATABASE cinemas;

Query OK, 1 row affected (0.00 sec)
354
Una vez creada, debe usarse la sentencia USE para seleccionarla como base de
datos activa.
mysql> USE cinemas;

Database changed
Una vez creada la base de datos, lo siguiente es la creación de las tablas que la
compondrán. La creación de esas tablas se realiza con la correspondiente
instrucción SQL. Por ejemplo, una de las tablas de la base de datos de Cinem@s es
la que permitirá guardar la información de todos los clientes; en concreto, la
creación de esta tabla se haría de la siguiente manera:
mysql> CREATE TABLE CLIENTES (
-> NUM_CLIENTE SMALLINT NOT NULL AUTO_INCREMENT,
-> NOMBRE VARCHAR(40) NOT NULL,
-> DIRECCION VARCHAR(50),
-> FECHANAC DATE,
-> TELEF CHAR(9),
-> EMAIL CHAR(30),
-> PUNTOS_ACUM SMALLINT NOT NULL DEFAULT 0,
-> CLAVE CHAR(6) NOT NULL,

-> PRIMARY KEY (NUM_CLIENTE));
Se puede comprobar la correcta creación de la tabla solicitando a MySQL que

muestre las tablas de la base de datos:
mysql> SHOW TABLES;

+-------------------+
| Tables_in_cinemas |
+-------------------+
| clientes |
+-------------------+
355
Incluso se puede utilizar la sentencia DESCRIBE para solicitar a MySQL que

muestre la estructura de la tabla recién creada:
mysql> DESCRIBE clientes;
+-------------+-------------+------+-----+---------+-------+--------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+--------+
| NUM_CLIENTE | smallint(6) | | PRI | NULL auto_increment |
| NOMBRE | varchar(40) | | | | |
| DIRECCION | varchar(50) | YES | | NULL | |
| FECHANAC | date | YES | | NULL | |
| TELEF | varchar(9) | YES | | NULL | |
| EMAIL | varchar(30) | YES | | NULL | |
| PUNTOS_ACUM | smallint(6) | | | 0 | |
| CLAVE | varchar(6) | | | | |
+-------------+-------------+------+-----+---------+----------------+
14.6. TIPOS DE DATOS

En la creación de una tabla debe indicarse un tipo de datos para cada uno de los
atributos que la componen, en esta sección se analizarán los diferentes tipos de
datos soportados por MySQL.
Cada uno de los tipos tiene asociado un espacio de almacenamiento en memoria

del cual a su vez depende el rango admisible de valores que puede tomar el dato.
Es responsabilidad del administrador de la base datos hacer un buen diseño de la

misma, en particular eligiendo adecuadamente los tipos de datos de cada uno de los
atributos de la tabla. Con esta elección debe buscarse la optimización del espacio
de memoria y la eficiencia y rapidez en la consulta de los datos.
Los diferentes tipos de datos pueden ser clasificados en varios grupos o categorías:
numéricos, cadena de caracteres, fecha y hora, conjuntos y enumeraciones,...
14.6.1. TIPOS NUMÉRICOS
Los tipos numéricos pueden, a su vez, ser de dos tipos: enteros y de coma flotante o
decimales. En ambos casos, existen diferentes opciones que permiten trabajar con
números en diferentes rangos.
356
Tipos Enteros
Nombre Rango Almacenamiento Descripción
TINYINT -128 a 127 1 byte Entero pequeño
BIT 0o1 1 bit Entero 0 o 1
BOOL 0o1 1 bit Entero 0 o 1
SMALLINT -32768 a 32767 2 bytes Entero pequeño
MEDIUMINT -8388608 a 8388607 3 bytes Entero mediano
INT -2147483648 a 2147483647 4 bytes Entero normal
INTEGER -2147483648 a 2147483647 4 bytes Sinónimo de INT
BIGINT -9223372036854775808 a
8 bytes Entero grande
9223372036854775807
Tabla 14.2 Tipos de datos numéricos enteros
Como puede apreciarse en la Tabla 14.2, existen varias posibilidades para trabajar
con tipos enteros, la elección concreta dependerá de lo que realmente se
almacenará en ese argumento; por ejemplo, si se desea definir un argumento para
guardar edades de personas, no parecería muy lógico utilizar el tipo INTEGER por
el enorme desperdicio de espacio en memoria que implicaría.
A la hora de definir un argumento de tipo entero se puede utilizar el argumento

UNSIGNED (sin signo) para impedir que dicho argumento acepte valores con signo
negativo, es decir, solo se podrán utilizar números positivos. El uso de este atributo
además permite duplicar el tamaño del número más grande que puede ser
almacenado; por ejemplo, el rango de valores del tipo TINYINT comprende todos
los números entre –128 y 127, en cambio, el rango de UNSIGNED TINYINT
variará entre 0 y 255.
Salvo en los tipos BIT y BOOL, en el resto de tipos de enteros se puede especificar
entre paréntesis el número máximo de dígitos con el que se mostrará el
correspondiente número. El valor máximo de este parámetro es 255.
Relacionado con esto, el argumento ZEROFILL utilizado para los valores

numéricos, completa con ceros a la izquierda los valores hasta alcanzar esa
longitud máxima. Si se le asigna a un atributo el modificador ZEROFILL
automáticamente se le asignará UNSIGNED.
357
Ejemplo 14.14:
Si se define un atributo:
NUM_SALA SMALLINT(4) ZEROFILL,
los números de las salas serán mostrados todos ellos con cuatro dígitos,
completando a la izquierda con ceros si fuese necesario.
Tipos numéricos en coma flotante

Básicamente hay dos tipos numéricos en coma flotante: FLOAT y DOUBLE; la
diferencia entre ellos está en el número de bytes que se utilizan para almacenar los
números; en el tipo FLOAT se utilizan cuatro bytes y en el DOUBLE el doble, es
decir, 8 bytes. Además de estos dos tipos básicos, existen una serie de tipos
"sinónimos" que tienen un comportamiento idéntico a ellos. Los tipos numéricos en
coma flotante admitidos por MySQL son los que se muestran en la Tabla 14.3.
Nombre Rango Almacenamiento Descripción
FLOAT ±1.175494351E-38 a Coma flotante de precisión

4 bytes
±3.402823466E+38 única.
DOUBLE ±1.797693134862315E+308 Coma flotante de precisión

8 bytes
a ±2.2507385850720E-308 única.
PRECISION
REAL Sinónimos de double
DECIMAL Número de coma flotante

NUMERIC Un byte para cada
almacenado como cadena de
DEC dígito del número
caracteres
Tabla 14.3 Tipos de datos numéricos en coma flotante
A la hora de definir atributos de tipo numérico en coma flotante también es posible

especificar el número de lugares decimales y el número de dígitos totales con los
que los números serán visualizados. Para hacerlo se deben colocar entre paréntesis
a continuación del nombre del tipo, y separados por coma, la longitud total de
visualización del número y el número máximo de dígitos decimales.
358
Ejemplo 14.15:
Si se define el atributo PRECIO de la siguiente manera:
PRECIO FLOAT(5,2) ZEROFILL,
Los valores serán visualizados con un máximo de 5 dígitos, dos de ellos

correspondientes a la parte decimal. Conviene indicar que se permitiría almacenar
números con un dígito más siempre que sean positivos.
14.6.2. TIPOS CADENA DE CARACTERES

Para almacenar datos de tipo cadena de caracteres, MySQL incorpora varios tipos
de datos diferentes, que podrían ser clasificados en dos grupos. Por un lado se
encuentran los tipos CHAR y VARCHAR, pensados para almacenar cadenas de
pequeña longitud. La única diferencia entre ambos es que las cadenas de tipo CHAR
se consideran de longitud fija y las VARCHAR de longitud variable; esto significa
que, por ejemplo, cuando en una cadena de longitud fija se incluye un dato con
menos caracteres que los previstos, la cadena se completa con espacios en blanco
hasta alcanzar su longitud. Cuando las cadenas, en cambio, tienen mayor longitud
que la admitida por el tipo de datos, los caracteres de la derecha se eliminan.
En ambos casos, a la hora de definir un atributo con tipo CHAR o VARCHAR, debe
indicarse entre paréntesis la longitud máxima que admitirá. La longitud máxima
posible para esta cadena es, en cualquier caso, de 255 caracteres.
Ejemplo 14.16:
La forma de declarar un atributo NOMBRE para almacenar cadenas de longitud
variable de 20 caracteres como máximo sería:
NOMBRE VARCHAR(20)
La principal ventaja de las cadenas de longitud fija respecto a las de longitud

variable es que las primeras se procesan con mayor rapidez; pero en cambio son
menos eficientes en el uso de memoria. Por ejemplo, si se almacena una cadena
con 3 caracteres en un campo de tipo CHAR(10) se estarían usando 10 bytes (uno
por cada carácter de la cadena más los 7 espacios en blanco que se añadirían) para
guardar ese dato. En cambio, esa misma cadena en un tipo de dato VARCHAR(10)
requeriría 4 bytes (3 para los caracteres y un byte adicional que sirve para
identificar el fin de la cadena).
359
MySQL no admite en la construcción de una tabla mezclar el uso de

cadenas de longitud fija y variable. Cuando el usuario defina una tabla
en la que aparezca, simultáneamente tipos CHAR y VARCHAR,
NOTA automáticamente todos serán convertidos a tipo VARCHAR. La única
excepción a esta regla se produce cuando se definen tipos VARCHAR de
4 o menos caracteres, en este caso serán convertidas a CHAR.
Por defecto, MySQL no distingue el uso de mayúsculas y minúsculas en las

cadenas de caracteres, de manera que, por ejemplo, las cadenas 'Shrek' y
'SHREK' son consideradas iguales a efectos de comparaciones en búsquedas,
ordenaciones o cualquier otra operación. Si se desea que sí que se distingan las
letras mayúsculas de las minúsculas, se puede indicar delante del tipo el atributo
BINARY.
Ejemplo 14.17:
La declaración:
COD BINARY VARCHAR(5)
define un atributo que almacenará cadenas de un máximo de 5 caracteres y

diferenciando mayúsculas de minúsculas.
El otro grupo de tipos de datos para almacenar cadenas de caracteres lo constituyen

los tipos TEXT y BLOB, pensados para almacenar grandes cantidades de caracteres.
Los atributos de tipo BLOB (binary large object, objeto binario grande) permiten
además almacenar cualquier tipo de fichero, como por ejemplo imágenes, sonidos,
documentos, programas,...
La diferencia entre un texto guardado en un dato TEXT o BLOB es que en el primer

caso no se diferencian mayúsculas de minúsculas, mientras que en un dato de tipo
BLOB sí que se produce tal diferenciación, lo que afecta a las operaciones de
comparación y ordenación.
Existen diferentes variaciones de los tipos TEXT y BLOB que afectan únicamente a
las longitudes máximas de las cadenas que admiten. En la Tabla 14.4 se incluyen
estas versiones junto con los otros tipos de cadenas analizados.
360
Longitud máxima
Nombre Almacenamiento Descripción
de caracteres
CHAR 1 1 bytes Un carácter.
CHAR(N) Cadena de longitud fija de N

255 N bytes
caracteres.
VARCHAR(N) Cadena de longitud variable de

255 N+1 bytes
N caracteres.
TINYTEXT Cadenas u objetos binarios de

TINYBLOB 255 L+1 bytes
tamaño pequeño
TEXT Cadenas u objetos binarios de

BLOB 65.535 L+2 bytes
tamaño normal
MEDIUMTEXT 16.777.215 Cadenas u objetos binarios de

MEDIUMBLOB L+3 bytes
(1,6 MB) tamaño mediano
LONGTEXT 4.294.967.295 Cadenas u objetos binarios de

LONGBLOB L+4 bytes
(4,2 GB) tamaño grande
Tabla 14.4 Tipos de cadenas de caracteres
14.6.3. TIPOS ENUM Y SET

Los tipos ENUM permiten definir atributos cuyos valores estén necesariamente en
una lista de valores predeterminados. A la hora de definir el atributo, los valores
deben ser dados entre paréntesis y separados por comas. El número máximo de
valores que admite MySQL es 65.535. Cuando se incorpore un nuevo registro a la
base de datos, para el valor del atributo de tipo ENUM se deberá elegir
necesariamente uno de los de la lista o utilizar el valor especial NULL.
Los tipos SET, en cambio, definen igualmente una lista de valores

predeterminados, pero se podría asignar al correspondiente campo ninguno, uno o
varios de esos valores. Cuando se inserte el registro, los valores de la lista deberán
ser introducidos dentro de una cadena entrecomillada y separados por comas. El
número máximo de elementos que admite MySQL para los conjuntos (SET) es 64.
361
Ejemplo 14.18:
A continuación se definen dos atributos, uno de tipo ENUM y otro SET:
SESION ENUM('matinal','tarde','noche')
PROY SET('L','M','X','J','V','S','D')
Debe destacarse que los tipos ENUM y SET son visualizados como si
fuesen cadenas de caracteres, pero internamente son tratados y
almacenados como valores numéricos. Cada valor predeterminado tiene
asociado el valor numérico correspondiente a su posición en la lista que
define el atributo. El hecho de que estos tipos de datos sean tratados
NOTA como números hace que su tratamiento sea mucho más rápido y eficaz
que el de las cadenas de caracteres.
14.6.4. TIPOS FECHA/HORA

Para el tratamiento de datos que hagan referencia a instantes de tiempo (fechas y horas)
MySQL también dispone de varios tipos de datos. Todos los valores correspondientes a
fechas y horas deben ser dados como cadenas de caracteres, es decir, entrecomillados,
aunque también es posible dar esos datos como valores numéricos.
Conviene advertir que MySQL utiliza un formato para las fechas en el cual en
primer lugar se indica el año, después el mes y finalmente el día. Para las horas el
formato es el habitual (horas:minutos:segundos). Es de destacar la gran
flexibilidad de MySQL en el momento de introducir una fecha.
Ejemplo 14.19:
Para MySQL cualquiera de las cadenas siguientes correspondería a la misma fecha:
el 31 de marzo de 1997:
'1997/3/31'
'1997-3-31'
19970331
Respecto a las horas, necesariamente debe usarse el signo ':' como separador o
bien indicar los dígitos correspondientes a las horas, minutos y segundos seguidos,
sin ningún separador. Por ejemplo, las 17 horas 5 minutos y 20 segundos se puede
expresar como:
'17:5:20'
170520
362
MySQL no comprueba si una fecha es válida en el momento de la

inserción de los datos, solo hace dos simples comprobaciones: que el
mes esté comprendido entre 0 y 12 y el día esté comprendido entre 0 y
NOTA
31. Esto hace que MySQL considere como fecha válida, por ejemplo,
'2005-2-31' (31 de febrero de 2005).
En la Tabla 14.5 se puede observar la variedad de tipos de fecha-hora que MySQL

soporta.
Tamaño de
Nombre Rango Descripción
almacenamiento
1000-01-01 Almacena una fecha con el
DATE 3 bytes
9999-12-31 formato YYYY-MM-DD
3 bytes
-838:59:59 Almacena una hora con el
TIME
838:59:59 formato HH:MM:SS
8 bytes
1000-01-01 00:00:00 Almacena una fecha y una hora
DATETIME con el formato
9999-12-31 23:59:59
YYYY-MM-DD HH:MM:SS
TIMESTAMP Instante de tiempo, combinación

1970-01-01 00:00:00
TIMESTAMP(M) 4 bytes de fecha y hora según diferentes
2037-01-01 00:00:00
formatos
Almacena un año con dos dígitos
YEAR(2) 70-69 (de 1970 a 2069) 1 byte (p.e. 97 corresponde a 1997)
YEAR Almacena un año con cuatro

YEAR(4) 1901 - 2155 1 byte
dígitos
Tabla 14.5 Tipos de dato fecha-hora
El tipo TIMESTAMP resulta especialmente útil ya que si una tabla dispone de un

atributo con este tipo, en él se almacenará de forma automática el "instante de
tiempo" (fecha y hora) en el que se realizó la inserción o última actualización del
correspondiente registro.
El formato en el que son almacenados los instantes de tiempo depende del valor del
parámetro que se haya colocado entre paréntesis en la definición del
correspondiente atributo. La Tabla 14.6 muestra los diferentes formatos asociados a
los diferentes parámetros.
363
Tipo especificado Formato

TIMESTAMP AAAAMMDDHHMMSS
TIMESTAMP(14) AAAAMMDDHHMMSS
TIMESTAMP(12) AAMMDDHHMMSS
TIMESTAMP(8) AAAAMMDD
TIMESTAMP(6) AAMMDD
TIMESTAMP(4) AAMM
TIMESTAMP(2) AA
Tabla 14.6 Formato de tipos TIMESTAMP
14.7. INTEGRIDAD REFERENCIAL EN MYSQL

MySQL soporta diferentes tipos de tablas: MyISAM, ISAM, HEAP, BDB, InnoDB.
En todas ellas el motor de MySQL admite el uso de la sintaxis para definir
integridad referencial, pero en algunos de los tipos anteriores la integridad
referencial no se encuentra actualmente implementada y por tanto el uso de esa
sintaxis no produce efecto alguno. El primer tipo de tabla que realmente permite
trabajar con restricciones de integridad referencial es el InnoDB, estando previsto
que próximamente también sea implementado para las tablas MyISAM.
A partir de la versión 4.0 de MySQL el soporte para tablas InnoDB es incluido en

la instalación básica del sistema. Para asegurarse de que el servidor MySQL sobre
el que se está trabajando soporta este tipo de tablas, podría consultarse el valor de
la variable have_innodb tal como se muestra a continuación:
mysql> show variables like 'have_innodb';

+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| have_innodb | YES |
+---------------+-------+
364
La integridad referencial está íntimamente relacionada con los conceptos de claves

primarias y claves foráneas; las primeras son las que permiten identificar los
registros de una tabla y las segundas permiten relacionar un registro con otro
registro de otra tabla diferente. Por ejemplo, en la tabla de PROYECCIONES se
hace referencia al número de una sala y el identificador de una película, de manera
que la tabla proyecciones contendrá dos claves foráneas una que la relaciona con la
tabla SALAS y otra que la relaciona con la tabla PELICULAS. La integridad
referencial exige que cuando un registro haga referencia a otro registro relacionado
este último debe existir en la tabla relacionada; de esta forma se impide, por
ejemplo, añadir proyecciones que referencien a salas o películas que no existan en
las respectivas tablas.
En las primeras versiones de MySQL no se incluía ningún tipo de control de

integridad referencial, pasando la responsabilidad de evitar situaciones de
inconsistencia (por ejemplo usar números de sala inexistentes) al programador y a la
aplicación que se utilice para gestionar la base de datos. Esta era una de las razones
por las que para muchos programadores MySQL no era apropiado para proyectos de
cierta envergadura. Con las nuevas funcionalidades de las últimas versiones de
MySQL esta reticencia está siendo superada.
14.7.1. DEFINICIÓN DE CLAVES FORÁNEAS

Para que un atributo sea considerado como clave foránea debe ser explícitamente
definido como tal en la sentencia de creación de la tabla. Ya se ha comentado que,
aunque la sintaxis es aceptada en todos los tipos de tablas, fueron las tablas InnoDB
las primeras en las que realmente esta funcionalidad se encuentra implementada.
En concreto, las tablas InnoDB permiten la definición de claves foráneas desde la

versión MySQL 3.23.43.
Para trabajar con claves foráneas es necesario que las dos tablas relacionadas sean
ambas definidas del tipo InnoDB, para ello se colocará al final de la tabla la
cláusula:
TYPE = INNODB
A continuación debe usarse la sintaxis:
FOREIGN KEY(campo) REFERENCES tabla_relacionada
365
para indicar el campo de la tabla primaria que se encuentra asociado con la clave
de la tabla relacionada. Por supuesto, ambos campos relacionados deben tener
asociado el mismo tipo de datos.
Finalmente es obligatorio crear un índice sobre el campo que ha sido declarado

como clave foránea. La creación de este índice se hace con la cláusula INDEX.
Ejemplo 14.20:
A continuación se muestra el código completo de creación de la base de datos
Cinem@s haciendo uso de la integridad referencial:

USE CINEMAS;

TITULO CHAR(50) NOT NULL ,
ACTORES MEDIUMTEXT ,
PRODUCCION MEDIUMTEXT ,
DIRECCION MEDIUMTEXT ,
GUION VARCHAR(40) ,
ANNO SMALLINT ,
DURACION SMALLINT NOT NULL ,
NACIONALIDAD VARCHAR(25) ,
GENERO ENUM('infantil','comedia','drama','acción',
'terror','erótica') ,
'mayores 13','mayores 18') ,
SINOPSIS LONGTEXT ,
CARTELERA BLOB ,
PRIMARY KEY (IDPELICULA)) TYPE = INNODB;

NUM_SALA SMALLINT NOT NULL ,
AFORO SMALLINT NOT NULL ,
NUM_FILAS SMALLINT NOT NULL ,
OBSERVACIONES LONGTEXT ,
PRIMARY KEY (NUM_SALA)) TYPE = INNODB;

NOMBRE VARCHAR(40) NOT NULL ,
DIRECCION VARCHAR(50) ,
FECHANAC DATE ,
TELEF CHAR(9) ,
366
EMAIL CHAR(30) ,
PUNTOS_ACUM SMALLINT NOT NULL DEFAULT 0 ,
CLAVE CHAR(6) NOT NULL ,
PRIMARY KEY (NUM_CLIENTE)) TYPE = INNODB;

IDPELICULA SMALLINT NOT NULL ,
HORA TIME NOT NULL ,
FECHA DATE NOT NULL ,
TARIFA_REDUCIDA BOOL ,
ESTRENO BOOL ,
PRIMARY KEY (IDPROY),
INDEX (IDPELICULA),
FOREIGN KEY (IDPELICULA) REFERENCES PELICULAS
(IDPELICULA),
INDEX (NUM_SALA),
FOREIGN KEY (NUM_SALA) REFERENCES SALAS (NUM_SALA)
) TYPE = INNODB;

RECOGIDA BOOL ,
PRIMARY KEY (NUM_ENTRADA),
INDEX (IDPROY),
FOREIGN KEY (IDPROY) REFERENCES PROYECCIONES (IDPROY),
INDEX (NUM_CLIENTE),
FOREIGN KEY (NUM_CLIENTE) REFERENCES CLIENTES
(NUM_CLIENTE)
) TYPE = INNODB;
Como puede observarse, todas las tablas han sido definidas del tipo InnoDB, y en
las tablas PROYECCIONES y ENTRADAS se definen dos claves foráneas en cada
una con sus respectivos índices.
Otra posibilidad para crear la base de datos con las restricciones de integridad
referencial es añadir las claves foráneas y los índices después de crear todas las
tablas haciendo uso en este caso de la sentencia ALTER TABLE. El código
completo correspondiente a esta alternativa se muestra a continuación:
367
USE CINEMAS;

TITULO CHAR(50) NOT NULL ,
ACTORES MEDIUMTEXT ,
PRODUCCION MEDIUMTEXT ,
DIRECCION MEDIUMTEXT ,
GUION VARCHAR(40) ,
ANNO SMALLINT ,
DURACION SMALLINT NOT NULL ,
NACIONALIDAD VARCHAR(25) ,
GENERO ENUM('infantil','comedia','drama','acción',
'terror','erótica') ,
'mayores 13','mayores 18') ,
SINOPSIS LONGTEXT ,
CARTELERA BLOB ,
PRIMARY KEY (IDPELICULA)) TYPE = INNODB;

AFORO SMALLINT NOT NULL ,
NUM_FILAS SMALLINT NOT NULL ,
OBSERVACIONES LONGTEXT ,
PRIMARY KEY (NUM_SALA)) TYPE = INNODB;

NOMBRE VARCHAR(40) NOT NULL ,
DIRECCION VARCHAR(50) ,
FECHANAC DATE ,
TELEF CHAR(9) ,
EMAIL CHAR(30) ,
PUNTOS_ACUM SMALLINT NOT NULL DEFAULT 0 ,
CLAVE CHAR(6) NOT NULL ,
PRIMARY KEY (NUM_CLIENTE)) TYPE = INNODB;

IDPELICULA SMALLINT NOT NULL ,
HORA TIME NOT NULL ,
FECHA DATE NOT NULL ,
TARIFA_REDUCIDA BOOL ,
ESTRENO BOOL ,
PRIMARY KEY (IDPROY)) TYPE = INNODB;
368

RECOGIDA BOOL ,
PRIMARY KEY (NUM_ENTRADA)) TYPE = INNODB;
ALTER TABLE PROYECCIONES ADD

INDEX IX_SE_PROYECTA (IDPELICULA);
REFERENCES PELICULAS (IDPELICULA);
ALTER TABLE PROYECCIONES ADD INDEX IX_PROYECTA (NUM_SALA);
ALTER TABLE PROYECCIONES ADD FOREIGN KEY (NUM_SALA)
REFERENCES SALAS (NUM_SALA);
ALTER TABLE ENTRADAS ADD INDEX IX_TIENE (IDPROY);
ALTER TABLE ENTRADAS ADD FOREIGN KEY (IDPROY)
REFERENCES PROYECCIONES (IDPROY);
ALTER TABLE ENTRADAS ADD INDEX IX_COMPRA (NUM_CLIENTE);
ALTER TABLE ENTRADAS ADD FOREIGN KEY (NUM_CLIENTE)
REFERENCES CLIENTES (NUM_CLIENTE);
La creación de la base de datos anterior desde el monitor de MySQL puede resultar

un tanto engorrosa; con objeto de facilitar la ejecución de sentencias SQL, MySQL
admite la posibilidad de ejecutar todas las sentencias que se encuentren en un
fichero de texto con la extensión .sql. La forma de hacerlo es usar el comando
SOURCE dentro del monitor, indicando a continuación el nombre del fichero con
su ruta de acceso.
Ejemplo 14.21:
Suponiendo que el fichero con las instrucciones de creación de las tablas se llama
cinemas.sql y que se encuentra en el directorio raíz, la creación de la base de
datos se podría hacer de la manera siguiente:
mysql> SOURCE c:/cinemas.sql;

Database changed
369
Desde dentro del monitor de MySQL es posible dar la orden de

ejecución de las sentencias que se encuentren incluidas en un fichero
externo usando el comando SOURCE que se acaba de ver. También es
posible ejecutar ese fichero externo desde la línea de comandos del
NOTA sistema al mismo tiempo que se entra en el monitor, la manera de
hacerlo es entrar en el servidor con la orden:
mysql –u usuario -p <C:\fichero.sql
En el caso de producirse algún error relativo a la integridad referencial, el monitor

de MySQL mostraría un mensaje como el siguiente:
ERROR 1005: Can't create table '.\cinemas\proyecciones.frm'
(errno: 150)
ERROR 1005: Can't create table '.\cinemas\entradas.frm' (errno:
150)
Por ejemplo, estos mensajes aparecerían si se tratan de crear las claves foráneas sin
crear los correspondientes índices.
Si no se produce ningún error, se puede comprobar que las cinco tablas de la base
de datos habrán sido generadas correctamente:
mysql> show tables;

+-------------------+
| Tables_in_cinemas |
+-------------------+
| clientes |
| entradas |
| peliculas |
| proyecciones |
| salas |
+-------------------+
Cuando se crea una tabla con una clave foránea MySQL asigna internamente un ID
que hará referencia a la restricción que establece sobre la tabla. Para conocer estos
ID se puede utilizar la instrucción SHOW CREATE TABLE.
A continuación se muestra a continuación la aplicación de esta sentencia sobre la

tabla PROYECCIONES.
370
mysql> SHOW CREATE TABLE PROYECCIONES;
+--------------+--------------------------------------------------------+
| Table | Create Table |
+--------------+--------------------------------------------------------+
| PROYECCIONES | CREATE TABLE `proyecciones` ( |
| | ÌDPROY` smallint(6) NOT NULL auto_increment, |
| | ÌDPELICULA` smallint(6) NOT NULL default '0', |
| | `NUM_SALA` smallint(6) NOT NULL default '0', |
| | `HORA` time NOT NULL default '00:00:00', |
| | `FECHA` date NOT NULL default '0000-00-00', |
| | `TARIFA_REDUCIDA` tinyint(1) default NULL, |
| | ÈSTRENO` tinyint(1) default NULL, |
| | PRIMARY KEY (ÌDPROY`), |
| | KEY ÌX_SE_PROYECTA` (ÌDPELICULA`), |
| | KEY ÌX_PROYECTA` (`NUM_SALA`), |
| | CONSTRAINT `proyecciones_ibfk_2` |
| | FOREIGN KEY (`NUM_SALA`) |
| | REFERENCES `salas` (`NUM_SALA`), |

| | CONSTRAINT `proyecciones_ibfk_1` |
| | FOREIGN KEY (ÌDPELICULA`) |
| | REFERENCES `peliculas` (ÌDPELICULA`) |
| | ) TYPE=InnoDB |
+--------------+--------------------------------------------------------+
Como se puede apreciar la clave foránea NUM_SALA de la tabla PROYECCIONES

quedará identificada como proyecciones_ibfk_2 y la clave foránea
IDPELICULA como proyecciones_ibfk_1. Estos identificadores se utilizan
371
por ejemplo para eliminar la correspondiente clave foránea con la sentencia ALTER
TABLE. Por ejemplo, si se quisiese suprimir la clave foránea NUM_SALA se podría
ejecutar la sentencia:
ALTER TABLE PROYECCIONES

DROP FOREIGN KEY proyecciones_ibfk_1;
14.7.2. INSERCIÓN DE REGISTROS EN TABLAS

RELACIONADAS
Para comprender el funcionamiento de la integridad referencial, se podrían incluir
en las tablas de la base de datos recién creada los primeros registros.
Ejemplo 14.22:
En primer lugar se insertará una película y dos salas en las respectivas tablas:
mysql> INSERT INTO PELICULAS(IDPELICULA,TITULO,ANNO)

-> VALUES(1,'Buscando a Nemo',2003);
mysql> INSERT INTO SALAS(NUM_SALA,AFORO,NUM_FILAS)
-> VALUES (1,240,12);

-> VALUES (2,180,10);
Una vez incluida la película, cuyo identificador es 1, y las salas, con identificadores
1 y 2 respectivamente, es posible, por ejemplo, dar de alta una nueva proyección de
la película 1 en la sala 2 para las 16:30 del día 16 de mayo de 2004; esta
proyección tendrá como identificador el número 1:
mysql> INSERT INTO PROYECCIONES(IDPROY,IDPELICULA,

-> NUM_SALA,HORA,FECHA)
-> VALUES(1,1,2,'16:30:00','2004-5-16');
En cambio, si se trata de insertar una nueva proyección que referencie a una sala
inexistente (sala 3) o una película inexistente (película 50), se produce una
violación de las restricciones de integridad referencial, MySQL detecta esa
violación, no incluye el registro y muestra un mensaje de error.
372

-> VALUES(2,1,3,'16:30:00','2004-5-17');
ERROR 1216: Cannot add or update a child row: a foreign
key constraint fails

-> VALUES(3,50,1,'20:15:00','2004-5-21');
ERROR 1216: Cannot add or update a child row: a foreign
key constraint fails
14.7.3. ELIMINACIÓN DE REGISTROS EN TABLAS

RELACIONADAS
Se pueden producir también violaciones de integridad referencial en las
operaciones de borrado.
Ejemplo 14.23:
MySQL no permitiría borrar la película 1 ni la sala 2 porque existen
proyecciones relacionadas que quedarían huérfanas en caso de producirse el
borrado. En cambio sí es posible borrar la sala 1 ya que no tiene ninguna
proyección relacionada.
mysql> DELETE FROM PELICULAS WHERE IDPELICULA=1;

ERROR 1217: Cannot delete or update a parent row: a
foreign key constraint fails
mysql> DELETE FROM SALAS WHERE NUM_SALA=1;


ERROR 1217: Cannot delete or update a parent row: a
foreign key constraint fails
Para poder borrar los registros correspondientes a la película 1 y sala 2 deberían

borrarse previamente el registro que lo relaciona en la tabla de proyecciones.
mysql> DELETE FROM PROYECCIONES WHERE IDPROY=1;

mysql> DELETE FROM PELICULAS WHERE IDPELICULA=1;

373

En el ejemplo anterior se ha visto cómo cuando se utilizan claves foráneas no es

posible eliminar un registro si previamente no se eliminan los registros
relacionados. Sin embargo, la definición de claves foráneas permite que estos
procesos de eliminación encadenados se produzcan de manera automática, esto es
lo que se denomina eliminación en cascada, o bien se realicen otro tipo de
operaciones automatizadas. En concreto, son cinco las opciones de borrado que se
pueden utilizar a la hora de definir la clave foránea:
⎯ ON DELETE RESTRICT: esta es la opción por defecto e impide

cualquier operación de borrado mientras existan registros relacionados.
o Ejemplo: no se podrá borrar una película mientras existan
proyecciones de la misma.
⎯ ON DELETE NO ACTION: produce el mismo efecto que la opción

anterior, es decir, se restringe la eliminación.
⎯ ON DELETE SET DEFAULT: al eliminar un registro, a los registros

relacionados con él se les asignará automáticamente el valor que haya sido
definido por defecto para la clave foránea (esta opción no está actualmente
disponible en MySQL).
⎯ ON DELETE SET NULL: al eliminar un registro, a los registros

relacionados con él se les asignará automáticamente el valor NULL para la
clave foránea, siempre que esta haya sido definida permitiendo este valor.
o Ejemplo: al borrar una película se pondrá el valor NULL en el
atributo IDPELICULA de todas las proyecciones relacionadas

(para que esto sea posible se tendría que eliminar la opción NOT
NULL que aparece en la definición del atributo IDPELICULA de
la tabla PROYECCIONES).
⎯ ON DELETE CASCADE: los registros serán eliminados en cascada.

o Ejemplo: al borrar una película se borrarán todas las
proyecciones de la misma.
Ejemplo 14.24:
Si se quisiera que los procesos de borrado se produjeran en cascada en la tabla de
proyecciones, lo primero que se debería hacer es modificar la definición de sus dos
374
claves foráneas para incluir la opción ON DELETE CASCADE. Estas

modificaciones se pueden realizar con la sentencia ALTER TABLE:
mysql> ALTER TABLE PROYECCIONES ADD FOREIGN

KEY(IDPELICULA)
-> REFERENCES PELICULAS(IDPELICULA) ON DELETE CASCADE;
Records: 0 Duplicates: 0 Warnings: 0
mysql> ALTER TABLE PROYECCIONES ADD FOREIGN KEY(NUM_SALA)

-> REFERENCES SALAS(NUM_SALA) ON DELETE CASCADE;
De esta forma, a partir de ahora cada vez que se suprima una película o una sala,
automáticamente se eliminarán todas las proyecciones de esa película o que tengan
lugar en esa sala.
Para comprobar el correcto funcionamiento de estas opciones se incluyen a

continuación unas series de registros en las tres tablas implicadas. En primer lugar
se insertan 4 películas:
mysql> INSERT INTO PELICULAS(IDPELICULA,TITULO)

-> VALUES (10,"Piratas del Caribe");

-> VALUES (11,"La ventana secreta");

-> VALUES (12,"Cuando menos te lo esperas");

-> VALUES (13,"La mala educación");
A continuación se insertan los registros correspondientes a 3 salas:

-> VALUES(1,180,10);
-> VALUES(2,120,12);
375

-> VALUES(3,90,10);
Finalmente, se añaden registros correspondientes a las proyecciones:

-> VALUES(1,10,2,'16:15','2004-7-23');

-> VALUES(2,10,3,'20:30','2004-7-24');

-> VALUES(3,11,3,'20:30','2004-7-25');

-> VALUES(4,12,1,'21:00','2004-7-25');
Con tres sencillas consultas de selección se podría consultar el contenido de las tres
tablas en este momento.
mysql> SELECT IDPELICULA,TITULO FROM PELICULAS;

+------------+----------------------------+
| IDPELICULA | TITULO |
+------------+----------------------------+
| 10 | Piratas del Caribe |
| 11 | La ventana secreta |
| 12 | Cuando menos te lo esperas |
| 13 | La mala educación |
+------------+----------------------------+
376
mysql> SELECT * FROM SALAS;

+----------+-------+-----------+---------------+
| NUM_SALA | AFORO | NUM_FILAS | OBSERVACIONES |
+----------+-------+-----------+---------------+
| 1 | 180 | 10 | NULL |
| 2 | 120 | 12 | NULL |
| 3 | 90 | 10 | NULL |
+----------+-------+-----------+---------------+
mysql> SELECT IDPROY,IDPELICULA,NUM_SALA,HORA,FECHA

-> FROM PROYECCIONES;
+--------+------------+----------+----------+------------+
| IDPROY | IDPELICULA | NUM_SALA | HORA | FECHA |
+--------+------------+----------+----------+------------+
| 1 | 10 | 2 | 16:15:00 | 2004-07-23 |
| 2 | 10 | 3 | 20:30:00 | 2004-07-24 |
| 3 | 11 | 3 | 20:30:00 | 2004-07-25 |
| 4 | 12 | 1 | 21:00:00 | 2004-07-25 |
+--------+------------+----------+----------+------------+
Por ejemplo, se desea eliminar la película Piratas del Caribe (cuyo identificador es
10); la sentencia sería:
mysql> DELETE FROM PELICULAS WHERE

-> TITULO='Piratas del Caribe';
Como puede apreciarse, el servidor de MySQL en este caso acepta la operación de

borrado y automáticamente borra esa película y las proyecciones número 1 y 2
(proyecciones que se encontraban relacionadas con la película 10). Esto puede

comprobarse volviendo a ejecutar la consulta de selección sobre la tabla de
PROYECCIONES.

+--------+------------+----------+----------+------------+
+--------+------------+----------+----------+------------+
| 3 | 11 | 3 | 20:30:00 | 2004-07-25 |
| 4 | 12 | 1 | 21:00:00 | 2004-07-25 |
+--------+------------+----------+----------+------------+
377
De la misma manera se puede borrar la sala número 3 y las proyecciones asociadas

(en este caso la proyección 3).


+--------+------------+----------+----------+------------+
+--------+------------+----------+----------+------------+
| 4 | 12 | 1 | 21:00:00 | 2004-07-25 |
+--------+------------+----------+----------+------------+
El contenido de las dos restantes tablas puede verse a continuación:
mysql> SELECT IDPELICULA,TITULO FROM PELICULAS;

+------------+----------------------------+
| IDPELICULA | TITULO |
+------------+----------------------------+
| 11 | La ventana secreta |
| 12 | Cuando menos te lo esperas |
| 13 | La mala educación |
+------------+----------------------------+

+----------+-------+-----------+---------------+
+----------+-------+-----------+---------------+
| 1 | 180 | 10 | NULL |
| 2 | 120 | 12 | NULL |
+----------+-------+-----------+---------------+
378
14.7.4. ACTUALIZACIÓN DE REGISTROS EN TABLAS

RELACIONADAS
Al igual que ocurre en las operaciones de borrado, en las actualizaciones de
registros también se pueden ver afectados registros de tablas relacionadas. Por
ejemplo, un cambio en la numeración de las salas afecta a la correspondiente clave
foránea de las proyecciones de dicha sala.
A la hora de definir las claves primarias se puede definir también la operación a

realizar cuando se modifican registros relacionados. En concreto, son tres las
opciones:
⎯ ON UPDATE RESTRICT: esta es la opción por defecto e impide

cualquier modificación mientras existan registros relacionados.
o Ejemplo: no se podrá cambiar el identificador de una sala o
película mientras existan proyecciones asociadas.
⎯ ON UPDATE SET NULL: se establecerán valores nulos para los atributos

relacionados cuando se produzca un cambio en la clave de la tabla
principal.
⎯ ON UPDATE CASCADE: se producirán las modificaciones en cascada de

todos los registros relacionados.
o Ejemplo: al cambiar el número de sala se cambiará
automáticamente el número de sala de todas las proyecciones que
tenían lugar en esa sala.
Si en la tabla ya se ha definido previamente alguna restricción de clave foránea,

esta tiene que ser previamente eliminada para poder incluir la restricción de
actualización. En la eliminación de la restricción debe usarse el identificador
interno que MySQL asocia a cada restricción de integridad referencial.
Ejemplo 14.25:
mysql> ALTER TABLE PROYECCIONES
-> DROP FOREIGN KEY proyecciones_ibfk_4;
Una vez eliminada la restricción anterior se vuelve a definir incluyendo en este

caso las dos opciones: la de borrado y la de actualización.
379
mysql> ALTER TABLE PROYECCIONES ADD FOREIGN KEY(NUM_SALA)

-> REFERENCES SALAS(NUM_SALA) ON DELETE CASCADE
-> ON UPDATE CASCADE;
Cuando en una misma definición de clave foránea se incluyen las dos

opciones: borrado (ON DELETE) y actualización (ON UPDATE),
NOTA necesariamente debe indicarse en primer lugar la de borrado y en
segundo lugar la de actualización.
Ejemplo 14.26:
A continuación se muestra el funcionamiento de la actualización en cascada. En
primer lugar se puede observar que la tabla SALAS incluye dos registros, uno de
los cuales (el correspondiente a la sala 1) se encuentra relacionado con un registro
de la tabla PROYECCIONES:

+----------+-------+-----------+---------------+
+----------+-------+-----------+---------------+
| 1 | 180 | 10 | NULL |
| 2 | 120 | 12 | NULL |
+----------+-------+-----------+---------------+

+--------+------------+----------+----------+------------+
+--------+------------+----------+----------+------------+
| 4 | 12 | 1 | 21:00:00 | 2004-07-25 |
+--------+------------+----------+----------+------------+
La siguiente sentencia modifica el número de la sala 1, pasando a ser a partir de

ahora la sala 3:
mysql> UPDATE SALAS SET NUM_SALA=3 WHERE NUM_SALA=1;

Rows matched: 1 Changed: 1 Warnings: 0
380
Como puede apreciarse, la modificación se produce sobre la tabla SALAS pero

también en el registro seleccionado de la tabla PROYECCIONES:

+----------+-------+-----------+---------------+
+----------+-------+-----------+---------------+
| 2 | 120 | 12 | NULL |
| 3 | 180 | 10 | NULL |
+----------+-------+-----------+---------------+

+--------+------------+----------+----------+------------+
+--------+------------+----------+----------+------------+
| 4 | 12 | 3 | 21:00:00 | 2004-07-25 |
+--------+------------+----------+----------+------------+
14.8. IMPORTACIÓN Y EXPORTACIÓN DE

DATOS
14.8.1. IMPORTACIÓN DE DATOS

Una vez definida la base de datos y establecidas las restricciones de integridad

referencial, se está en condiciones de hacer uso de la misma. Por supuesto, una de
las primeras labores a realizar será la inclusión en las diferentes tablas de los
registros con los datos a manejar. Una primera opción para insertar datos es el uso
de la sentencia INSERT, tal como se ha venido utilizando en los ejemplos
anteriores. Sin embargo, el uso de esta sentencia para la inclusión de un gran
número de registros resulta excesivamente laborioso; por ello, MySQL incorpora
mecanismos mucho más ágiles para cargar datos en las tablas desde ficheros
externos. En concreto, se puede utilizar el programa mysqlimport que se
encuentra en el directorio mysql/bin o el comando LOAD DATA INFILE del
monitor de MySQL. Además de estas opciones también sería posible escribir todo
un conjunto de sentencias INSERT en un fichero de texto y ejecutarlas todas ellas
con el comando SOURCE.
381
Ejemplo 14.27:
Supóngase que se dispone de un fichero de texto que contiene la siguiente
información:
1 Luis López Floranes 54, Santander 1970-3-31 942221133 llopez@coldmail.com 0 llp70
2 María Anta San Juan 22, Oviedo 1981-11-22 686776612 manta@tumail.com 0 as23b
3 Ana Palacios San Andrés 39, Madrid 1968-5-1 null apm55@tumail.com 0 aaa45b
4 Valeria Vázquez Moro 120, Almería 1990-2-13 645162377 vv90@coldmail.com 0 basw25
Como puede apreciarse, cada una de las líneas del fichero contiene los datos
correspondientes a un registro de la tabla CLIENTES, coincidiendo en número y
tipo los respectivos datos con los atributos de esa tabla, y estando separados los
datos por tabuladores.
Si se desea importar directamente esos datos desde el fichero de texto a la tabla

CLIENTES de la base de datos CINEMAS, lo primero que debe hacerse es nombrar
ese fichero como clientes.txt, obsérvese que es obligatorio que el nombre
del fichero coincida con el nombre de la tabla.
Una vez disponible el fichero anterior, desde la línea de comandos del sistema (no
desde dentro del monitor de MySQL) se haría una llamada a la utilidad
mysqlimport indicando, por este orden, el nombre de usuario para conectarse al
servidor, el parámetro para solicitar la contraseña, el nombre de la base de datos de
destino y el nombre y ruta del archivo de texto:
C:\mysql\bin>mysqlimport -u root -p cinemas

c:\clientes.txt
Enter password: *******
cinemas.clientes: Records: 4 Deleted: 0 Skipped: 0
Warnings: 0
Entrando al monitor de MySQL se observa que los datos han sido correctamente
importados.
nt

buffer.
mysql> USE cinemas;

Database changed
382
mysql> SELECT NUM_CLIENTE, NOMBRE FROM clientes;

+-------------+-----------------+
| NUM_CLIENTE | NOMBRE |
+-------------+-----------------+
| 1 | Luis López |
| 2 | María Anta |
| 3 | Ana Palacios |
| 4 | Valeria Vázquez |
+-------------+-----------------+
El programa mysqlimport cuenta con un gran número de parámetros

opcionales, algunos de los más destacados son:
-d o -delete: esta opción haría que se borraran todos los datos

existentes en la tabla antes de la importación.
-r o -replace: esta opción haría que aquellos registros de la tabla

cuya clave primaria coincida con alguna de las que se están importando
sean reemplazados.
-fields-enclosed-by=char: esta opción permite especificar el

carácter que encierra a los datos en el fichero de texto, por ejemplo, los
diferentes datos podrían estar encerrados entre comillas.
-fields-terminated-by=char: esta opción permite especificar el

carácter que delimita los campos en el fichero de texto. Por defecto el
delimitador es el tabulador.
-lines-terminated-by=str: esta opción permite especificar el

carácter o secuencia de caracteres que actúa de delimitador de registro en el
fichero de texto. Por defecto el delimitador es el cambio de línea.
Otra alternativa para importar datos que se encuentren en ficheros de texto es el uso
del comando LOAD DATA INFILE del monitor de MySQL. Para poder hacer uso
de este comando, a diferencia del caso anterior, se debe estar ya dentro del monitor
de MySQL, e incluso es posible su uso desde aplicaciones programadas al efecto.
En algunos aspectos el uso de este comando es muy similar al uso de la utilidad

mysqlimport ya que, por ejemplo, se pueden especificar los caracteres que
actúan de separadores de campos y registros.
383
Ejemplo 14.28:
Supóngase que se desea incluir en la tabla SALAS los 7 registros que se
encuentran en un fichero de texto llamado relacionsalas.txt y cuyo
contenido es:
1,300,15,Localidades para minusválidos

2,240,20
3,240,12,Sala renovada recientemente
4,120,10,Localidades para minusválidos
5,120,12
6,120,10,Poca visibilidad en zonas laterales
7,90,10
Como se aprecia, en este caso el carácter que actúa de separador de campos es

la coma y el separador de registros el cambio de línea. Este último es el
separador de registros por defecto, pero en cambio el separador de campos
por defecto es el tabulador.
Desde dentro del monitor de MySQL la secuencia de operaciones necesaria para

importar esos datos es:
mysql> USE CINEMAS;

Database changed
mysql> LOAD DATA INFILE "C:/relacionsalas.txt"
-> REPLACE INTO TABLE SALAS
-> FIELDS TERMINATED BY ',';
Records: 7 Deleted: 0 Skipped: 0 Warnings: 3
El parámetro opcional REPLACE indica que en caso de que ya existan registros con
la misma clave en la tabla destino, estos deben ser reemplazados. De igual manera,
se utiliza otro parámetro opcional (FIELDS TERMINATED BY) para indicar el
separador de campos.
Con una consulta SELECT se puede comprobar que los datos han sido
correctamente importados:
384

+----------+-------+-----------+-------------------------------------+
| NUM_SALA | AFORO | NUM_FILAS | OBSERVACIONES
+----------+-------+-----------+-------------------------------------+
| 1 | 300 | 15 | Localidades para minusválidos
| 2 | 240 | 20 | NULL
| 3 | 240 | 12 | Sala renovada recientemente
| 4 | 120 | 10 | Localidades para minusválidos
| 5 | 120 | 12 | NULL
| 6 | 120 | 10 | Poca visibilidad en zonas laterales
| 7 | 90 | 10 | NULL
+----------+-------+-----------+-------------------------------------+
Otro de los parámetros opcionales del comando LOAD DATA IN FILE es el

parámetro ENCLOSED BY, que permite indicar el carácter que se utiliza para
encerrar los campos. Por ejemplo, si los campos de los registros en el fichero de
texto se encontraran encerrados entre caracteres #, el comando a utilizar para la
importación sería:
LOAD DATA INFILE "C:/relacionsalas.txt" INTO TABLE SALAS

FIELDS TERMINATED BY ',' ENCLOSED BY '#';
Las dos opciones de importación de datos analizadas resultan especialmente útiles

cuando se dispone de los datos en otros soportes; por ejemplo, si se dispone de una
hoja de cálculo, se puede generar fácilmente un fichero de texto con los
separadores que se desee para luego importarlo desde MySQL.
14.8.2. EXPORTACIÓN DE DATOS

Al igual que resulta interesante disponer de mecanismos para importar los datos, no
menos interesante resulta poder generar ficheros de texto con los datos de las tablas
o resultados de consultas con objeto de ser exportados a otras aplicaciones.
Existen varias formas o mecanismos de exportación de datos; la primera es el

uso del programa mysqldump que permite generar un fichero de texto con
todos los comandos de SQL necesarios para reconstruir la base de datos. Este
fichero incluiría todas las sentencias de creación de tablas (CREATE TABLE)
con sus relaciones y todas las sentencias de inserción de los registros en cada
tabla (INSERT); de manera que ejecutando este fichero en MySQL o en otro
sistema gestor de bases de datos basado en SQL se podría reconstruir
completamente la base de datos.
385
La generación de este fichero debe hacerse desde la línea de comandos del sistema,
utilizando la sintaxis siguiente:
C:\mysql\bin>mysqdump -u root -p cinemas >respaldobd.txt

Si después del nombre de la base de datos se indica el nombre de una de sus tablas,
el fichero generado únicamente contendrá la definición de esa tabla y las sentencias
de inserción de sus registros.
Ejemplo 14.29:
Se puede generar un fichero de respaldo de la tabla clientes de la siguiente manera:
C:\mysql\bin>mysqdump -u root -p cinemas clientes

>rclie.txt
Incluso es posible indicar una condición de filtrado de registros, por ejemplo,

generar el fichero con los datos de las salas de aforo mayor que 200:
C:\mysql\bin>mysqdump -u root -p –w "AFORO>200" cinemas

salas >rsalas.txt
Desde dentro del monitor de MySQL también es posible la exportación de datos a

ficheros de texto, en este caso se utiliza el comando SELECT INTO OUTFILE.
A continuación se muestran un par de ejemplos de su uso desde el monitor de
MySQL.
Ejemplo 14.30:
mysql> USE CINEMAS;
Database changed
mysql> SELECT NOMBRE,PUNTOS_ACUM

-> INTO OUTFILE 'PuntosClientes.txt'
-> FIELDS TERMINATED BY ':'FROM CLIENTES;
Con esta instrucción se generaría un fichero de texto con los nombres y puntos
acumulados de todos los clientes, siendo el contenido del fichero el siguiente:
Luis López:0,María Anta:0,Ana Palacios:0,Valeria Vázquez:0,
386
Ejemplo 14.31:
También es posible indicar una condición de selección de registros, en este caso se
obtienen los nombres de todos los clientes de Santander:
mysql> SELECT NOMBRE INTO OUTFILE 'ClientesSant.txt'

-> FIELDS TERMINATED BY ':' FROM CLIENTES
-> WHERE DIRECCION LIKE '%Santander%';
El fichero de salida generado contendrá en este caso un solo registro.

387
PHPMYADMIN:
ADMINISTRACIÓN DE
BASES DE DATOS
MYSQL DESDE LA
WEB
15.1. INTRODUCCIÓN
La administración y gestión de las bases de datos de MySQL mediante el propio
monitor de MySQL resulta en ocasiones un tanto laboriosa, especialmente para
aquellos usuarios acostumbrados al uso de herramientas con interfaz gráfica de usuario.
Afortunadamente existen alternativas para la administración de las bases de datos

que resultan más intuitivas y sencillas de utilizar; muchas de estas herramientas de
gestión están desarrolladas en el lenguaje PHP y permiten la administración remota
a través de un servidor web. En concreto, una de las más conocidas es la
herramienta phpmyadmin, disponible de forma gratuita a través de Internet y
389
desarrollada en PHP por una comunidad de usuarios sin ánimo de lucro

(http://www.phpmyadmin.net).
La aplicación phpmyadmin no es más que un conjunto de páginas escritas en PHP y

que son copiadas directamente en el directorio que aloja las páginas web del
servidor. Mediante las diferentes páginas se pueden consultar las bases de datos
disponibles, crear nuevas bases de datos, tablas, realizar consultas, insertar
registros, administrar los usuarios y sus privilegios, hacer copias de seguridad de
las bases de datos,...
Por supuesto, para poder hacer uso de esta aplicación de administración de MySQL
es necesario disponer de un servidor web con un intérprete de PHP, ya que todas las
páginas están escritas en ese lenguaje. Además es preciso establecer los valores de
diferentes parámetros de configuración que se encuentran dentro del fichero
config.inc.php alojado en el directorio que contiene todas las páginas que
componen la aplicación. Dos de estos parámetros serían PmaAbsoluteUri, que
permite indicar el URL que identifica la localización exacta de la aplicación, y
auth_type, que permite indicar el tipo de autentificación que se utilizará (existen
tres opciones: autentificación basada en cookies, basada en http o inclusión en el
fichero de configuración de los datos de usuario).
15.2. ENTRADA A PHPMYADMIN

La forma de comenzar a utilizar phpmyadmin es simple, basta con utilizar el
navegador web para acceder a la página index.php que se encontrará en el
directorio correspondiente del servidor web.
En el caso de tener instalado el servidor web sobre el propio equipo (localhost) que
se utilizará para la administración, se deberá escribir en la barra de direcciones del
navegador:
http://localhost/phpmyadmin/
Para ello es necesario también que el servidor web tenga configuradas las páginas
index.php como páginas de inicio de directorio.
La aplicación dispone de tres métodos de autentificación diferentes basados en

nombres de usuario y contraseñas. El más simple, pero al mismo tiempo más
inseguro, es la escritura del nombre de usuario y la contraseña directamente en el
fichero de configuración. El segundo de los métodos se basa en cookies, y en este
390
PHPMYADMIN: ADMINISTRACIÓN DE BASES DE DATOS MYSQL DESDE LA WEB
caso solicita al usuario a través de un formulario de una página web el nombre y

contraseña cada vez que acceda.
Una vez autentificado como usuario registrado, se accede a la página de inicio de

phpmyadmin (véase Figura 15.1).
Figura 15.1 Página de inicio de phpmyadmin
A través de la página de inicio de phpmyadmin se accede de una forma sencilla e

intuitiva a las diferentes opciones disponibles. La página, como puede apreciarse,
está dividida en dos marcos, en el de la izquierda se podrá seleccionar en todo
momento una de las bases de datos que se encuentren disponibles en MySQL. En
el marco de la derecha aparecen una serie de enlaces que permiten realizar las
diferentes operaciones sobre la base de datos activa.
Como podrá comprobarse, todas las opciones disponibles se encuentran bien

documentadas a través de diferentes documentos de ayuda.
391
15.3. GESTIÓN DE BASES DE DATOS
15.3.1. CONSULTA DE LAS BASES DE DATOS

Una de las primeras operaciones que se puede realizar en phpmyadmin es la
consulta de las bases de datos disponibles en cada momento. Para ello, en el marco
izquierdo de la ventana aparece una lista desplegable con los nombres de esas
bases de datos; entre paréntesis se indica además el número de tablas de cada una
de ellas, tal como puede apreciarse en la Figura 15.2.
Figura 15.2 Selección de la base de datos activa

Figura 15.3 Estructura de la base de datos de Cinem@s
392
Una vez seleccionada una base de datos en esta lista, el marco de la derecha de
la ventana mostrará la estructura de dicha base de datos. Por ejemplo, al
seleccionar la base de datos de Cinem@s, la ventana del navegador tendrá el
aspecto que muestra la Figura 15.3.
A través de los enlaces de la parte superior se puede consultar la estructura de la

base de datos (vista por defecto), ejecutar sentencias SQL directamente sobre la
base de datos seleccionada, acceder a diferentes opciones para exportar datos,
realizar consultas de selección (búsquedas) de una forma intuitiva, sin necesidad de
dar el código SQL correspondiente, generar otro tipo de consultas de manera
interactiva y, finalmente, la posibilidad de eliminar completamente la base de datos
activa.
15.3.2. MANIPULACIÓN DE LAS TABLAS

Al analizar la estructura de la base de datos, se puede ver la lista de sus tablas, con
una serie de iconos para ejecutar diferentes acciones. Igualmente se puede obtener
información sobre el número de registros, tipo de tabla y tamaño de cada tabla.
Al pulsar la acción Examinar, se mostrarán todos los registros de la tabla. Por

ejemplo la Figura 15.4 muestra el contenido de la tabla SALAS.
Mediante los enlaces gráficos que aparecen delante de cada registro se podrán
editar sus campos o borrar el registro completamente. Además, pulsando sobre los
nombres de los campos que aparecen en las cabeceras de las columnas se puede
variar el orden en el que se muestran los registros (orden ascendente o descendente
sobre ese campo).
393
Figura 15.4 Contenido de la tabla SALAS

Por encima de la tabla anterior puede verse también la consulta SQL que el propio
programa ha generado, así como el tiempo empleado en la ejecución de la misma
(véase Figura 15.5). Esta es una interesante característica de phpmyadmin, ya que
al mostrar en todo momento las sentencias SQL su uso tiene también un cierto
grado pedagógico, permitiendo al usuario comprobar el código SQL de las
consultas que genere de manera interactiva.
Figura 15.5 Consulta SQL generad.

La segunda de las posibles acciones a realizar sobre las tablas es la de seleccionar.

Esta opción da acceso a una página en la que es posible generar de manera intuitiva
sencillas consultas de selección (SELECT). Por ejemplo, la Figura 15.6 muestra la
manera de obtener un listado, en orden decreciente de aforo, de los números de sala
y aforos de todas las salas con capacidad mayor o igual a 200. En la Figura 15.7
puede verse el resultado de esta consulta.
394
Figura 15.6 Consulta de los aforos de las salas

Figura 15.7 Resultado de la consulta de aforos
395
De nuevo, además de mostrar los registros, se muestra la sintaxis SQL de la

sentencia SELECT que se ha utilizado para obtenerlos.
La tercera de las opciones de manipulación de tablas es la inserción de nuevos

registros. Al igual que ocurre en los casos anteriores, la inserción se realizará a través
de sencillos formularios que liberarán al usuario de la generación de las
correspondientes sentencias INSERT.
Por ejemplo, si se desea añadir un nuevo registro a la tabla de clientes, se utilizaría

el formulario que se muestra en la Figura 15.8. Por supuesto, los datos introducidos
en los diferentes campos del formulario deben coincidir en tipo con los de los
correspondientes atributos de la tabla, que son mostrados en la segunda columna
del mismo. En la tercera columna del formulario se encuentran a su vez una serie
de listas desplegables que dan acceso a diferentes funciones predefinidas en
MySQL. Por ejemplo, en la inserción se utiliza la función PASSWORD que hace
que el contenido introducido en el correspondiente campo quede almacenado en la
tabla utilizando técnicas de encriptación, de esta manera cualquier operación de
selección posterior no mostraría el valor verdadero de ese atributo.
Figura 15.8 Inserción de un nuevo cliente
En la parte inferior del formulario existen dos botones de opción que permiten
especificar si se desea añadir un nuevo registro o simplemente volver a la
estructura de la base de datos.
396
Al pulsar el botón Continúe se realizará la inserción del registro y se mostrará

además la sentencia INSERT utilizada para dicha operación (véase Figura 15.9).
Figura 15.9 Sentencia de inserción del nuevo cliente
Puede examinarse la tabla CLIENTES para comprobar que la inserción se realizó

correctamente. Además puede comprobarse cómo el valor que se muestra en el
campo correspondiente a la clave aparece encriptado (véase Figura 15.10).
Figura 15.10 Nuevo registro

En el caso de tablas que contengan campos de texto largo, el formulario de
inserción incluye áreas de texto con barras de desplazamiento para poder introducir
los contenidos. La Figura 15.11 muestra parte del formulario para insertar nuevas
películas.
Figura 15.11 Formulario de inserción de nuevas películas
Además, para el caso de campos de tipo blob, preparados para recibir cualquier
tipo de archivo, el formulario permite directamente examinar el contenido del
equipo y seleccionar el archivo a almacenar en la tabla. Este es el caso del campo
CARTELERA de la tabla de PELICULAS (Figura 15.12).
397
Figura 15.12 Campo de tipo blob
La siguiente acción que se puede realizar sobre las tablas es la de ver sus
propiedades. En este caso se mostrará la estructura de la tabla, con los nombres y
tipos de sus argumentos, así como cualquier otra propiedad de la misma establecida
en tiempo de diseño (claves primarias, atributos no nulos, valores predeterminados,
índices,...). A través de esta opción no solo es posible consultar las propiedades de
la tabla sino también modificarlas. La próxima sección mostrará detalladamente las
distintas opciones accesibles desde la página de propiedades.
Finalmente, las dos últimas acciones a realizar sobre las tablas son las de eliminar
y vaciar. La eliminación borra la tabla completa (sentencia DROP TABLE),
mientras que el vaciado únicamente borra los registros que contiene la tabla pero la
mantiene vacía en la base de datos (sentencia TRUNCATE).
Al utilizar el enlace gráfico de eliminación aparecerá un cuadro de diálogo que

exige la confirmación de la acción, preguntando si realmente se quiere eliminar
dicha tabla (véase Figura 15.13).
Figura 15.13 Cuadro de confirmación de la acción de borrado
De la misma manera, cuando se realiza la acción de vaciado, se pide confirmación

al usuario.
Cuando se trabaja en MySQL con tablas que soporten la integridad referencial, las
operaciones de eliminación de tabla o de vaciado de registros solo son permitidas
cuando no se estén utilizando en otras tablas vinculadas.
15.3.3. ESTRUCTURA DE LAS TABLAS
A través de phpmyadmin es posible analizar la estructura completa de cada una de

las tablas, comprobando los nombres y tipos de los diferentes atributos,así como
398
cualquier otra propiedad que se haya establecido en su diseño. No solo es posible

analizar esa estructura sino también modificarla, cambiando los tipos de los
atributos, eliminando o añadiendo nuevos atributos,...
Para analizar la estructura de una de las tablas se puede pulsar sobre el enlace
correspondiente que aparece en el marco izquierdo de la página principal (Figura
15.14).
Figura 15.14 Lista de tablas de la base de datos
Al hacerlo, se accede a una página similar a la que aparece cuando se consultan las
propiedades de una tabla. En la parte superior de esa misma página aparecen una
serie de enlaces adicionales que permiten realizar todo tipo de acciones sobre la
tabla: examinar sus registros, ejecutar sentencias SQL, generar consultas de
selección, insertar nuevos registros, exportar datos, cambiar el nombre de la tabla,
cambiar su ubicación,... Algunas de estas acciones pueden realizarse también a
través de la página que muestra la estructura completa de la base de datos.
Al seleccionar una tabla, la página muestra por defecto sus propiedades, tal como
se ve en la Figura 15.15, para el caso de la tabla CLIENTES.
Figura 15.15 Propiedades de la tabla CLIENTES
399
La relación de campos de la tabla viene acompañada por información sobre sus

respectivos tipos, atributos especiales, posibilidad de admitir valores nulos, valores
predeterminados, uso de funciones especiales y, finalmente, una serie de iconos
que permiten realizar las siguientes acciones sobre cada uno de los atributos:
1. Cambiar el atributo: se pueden modificar su nombre, tipo, valor por

defecto y otros atributos.
2. Eliminar el atributo de la tabla.
3. Establecer dicho atributo como clave primaria de la tabla.
4. Definir un índice sobre ese atributo.
5. Establecer la propiedad de unicidad de valores en el atributo.
Debajo de la relación de campos de la tabla puede verse información sobre los

índices definidos sobre la misma y espacio utilizado por la tabla.
Finalmente, la página incluye algunos enlaces que permiten realizar acciones

interesantes (véase Figura 15.16). El primero de ellos (vista impresión) genera una
página con toda la información de la tabla en un formato más manejable de cara a
su impresión. También es posible incluir nuevas columnas o campos a la tabla y
ejecutar consultas SELECT en formato SQL o a través de un fichero externo. El último
enlace de la página permite introducir datos en la tabla procedentes de un fichero de
texto. En este caso deben establecerse los caracteres delimitadores de los campos y de
los registros.
15.4. CREACIÓN DE NUEVAS BASES DE DATOS

En la sección anterior se ha explicado la forma de consultar y gestionar las bases de
datos existentes en MySQL. Como ejemplo se ha tomado la base de datos de
Cinem@s que en su momento fue creada directamente mediante sentencias SQL a
través del monitor de MySQL. En esta sección se verá cómo con phpmyadmin resulta
sencillo el proceso de creación de una base de datos completa, sin necesidad de tener
ningún conocimiento del lenguaje de definición SQL.
En la página de inicio de phpmyadmin, la primera de las opciones disponibles es

precisamente la de creación de una nueva base de datos (Figura 15.17).
400
Figura 15.16 Opciones adicionales de manipulación de tablas
Figura 15.17 Opción de creación de una nueva base de datos

En primer lugar debe indicarse el nombre para la nueva base de datos, al pulsar el
botón Crear se accede a una nueva página (Figura 15.18) en la que se crearán las
diferentes tablas. En este caso se está creando una nueva base de datos de nombre
recursos_humanos cuyo objetivo podría ser mantener información sobre los
trabajadores de la empresa Cinem@s, turnos de trabajo, horas extraordinarias,... Al
crear la base de datos, la página muestra también la sentencia SQL correspondiente
e incluye un simple formulario para crear las diferentes tablas de la nueva base de
datos.
15.4.1. CREACIÓN DE TABLAS

La creación de nuevas tablas se realiza a través del formulario que incluye la página de
la Figura 15.18. En primer lugar debe indicarse el nombre de la tabla y el número de
campos que contendrá (estos valores podrán ser modificados posteriormente). Por
401
ejemplo, a continuación se creará una tabla de nombre empleados y con 7 campos

(Figura 15.19).
Figura 15.18 Creación de nuevas tablas

Figura 15.19 Creación de una tabla con 7 campos
Al formulario de creación de tablas puede accederse también desde la página que

muestra la estructura de una base de datos en el caso de bases de datos ya
existentes.
El siguiente paso, será definir los 7 campos de la tabla; para ello phpmyadmin
muestra un nuevo formulario en el que este proceso se realiza de forma intuitiva
(Figura 15.20). El formulario permite indicar los nombres de los campos, sus tipos,
402
longitud, atributos, admisión de valores nulos, valores predeterminados, definición

de claves, índices,... El formulario finaliza con una lista en la que es posible elegir
el tipo de tabla entre los tipos soportados por MySQL.
Figura 15.20 Formulario de definición de campos de la tabla
Al pulsar el botón Grabar del formulario, la tabla se creará y phpmyadmin

mostrará la sentencia SQL que la genera.
Accediendo a la página de la estructura de la base de datos se podrá repetir el

proceso para crear nuevas tablas.
15.5. OPERACIONES DE IMPORTACIÓN Y

EXPORTACIÓN DE DATOS
15.5.1. IMPORTACIÓN DE DATOS EXTERNOS EN LAS

TABLAS
Dada una base de datos con su conjunto de tablas, evidentemente, una de las
operaciones más habituales será la inserción de nuevos registros. Esta operación
puede realizarse de diferentes maneras, por un lado la ejecución directa de las
correspondientes sentencias INSERT, por otro, la utilización de los formularios de
inserción que phpmyadmin genera y que fueron presentados al explicar las
operaciones de manipulación de tablas. Una tercera opción disponible para crear
403
nuevos registros es la importación de datos de ficheros externos. Esta opción es

especialmente recomendable cuando se desea importar un gran volumen de
registros en una sola operación.
Supóngase que se dispone de un fichero de texto con el contenido de la Figura

15.21, como puede apreciarse, cada una de las líneas del fichero corresponderá a un
registro de la tabla EMPLEADOS, los valores para cada campo se encuentran
entrecomillados y separados entre sí por comas.
Figura 15.21 Fichero de texto con datos de empleados
Para importar todos esos datos a la tabla de empleados se tendría que pulsar sobre
el enlace Insertar archivo de texto en la tabla que aparece al final de la página que
muestra la estructura de la correspondiente tabla. Al hacerlo se accede al
formulario que muestra la Figura 15.22, en él se debe especificar el fichero fuente
de los datos y los diferentes caracteres que actuarán de separadores de campos y de
registros.
Figura 15.22 Formulario para la importación de datos desde ficheros de texto
404
Una vez pulsado el botón Enviar, se procederá a la inserción automática de los

correspondientes registros. Tras dicha operación puede examinarse la tabla para
comprobar la correcta inserción de los mismos (Figura 15.23).
Figura 15.23 Contenido de la tabla EMPLEADOS
Si se desea importar datos que se encuentren en una hoja de cálculo,

como por ejemplo Excel, puede utilizarse la opción de exportar a un
NOTA fichero de texto los datos de la hoja, para posteriormente importarlos
desde MySQL utilizando phpmyadmin.
15.5.2. EXPORTACIÓN DE DATOS

Cuando se desea utilizar los datos almacenados en MySQL por otras aplicaciones,
o incluso por otros sistemas gestores de bases de datos, se pueden utilizar las
opciones de exportación que incorpora phpmyadmin.
Existen dos posibilidades de exportación:
— Exportar la base de datos completa.
— Exportar tablas individuales.
Para exportar una base de datos debe activarse el enlace Exportar que aparece en la
página de inicio de phpmyadmin. Al hacerlo se accede a una nueva página en la
que en primer lugar habría que seleccionar la o las bases de datos que se desean
exportar y el formato de exportación (Figura 15.24).
Existen cuatro formatos de exportación:
405
— SQL: se generaría un documento de texto con todas las sentencias SQL

necesarias para crear la estructura de la base de datos y añadir todos sus
registros. Este documento podría ser ejecutado en otro sistema gestor de bases
de datos basado en SQL para reproducir exactamente la base de datos
exportada. Este formato de exportación incorpora una serie de opciones para
indicar si se desea utilizar las sentencias DROP antes de la creación.
— LaTeX: en este caso se generaría un documento con el código necesario para

visualizar las tablas de la base de datos en el formato LaTeX. LaTeX es un
editor de texto muy utilizado en el ámbito científico y para la edición de
publicaciones.
— CSV para Excel: se generaría un fichero de texto con los contenidos de las
tablas de la base de datos en formato CSV (valores separados por comas). Este
formato puede ser leído directamente por Excel para mostrar los contenidos de
las tablas en una hoja de cálculo.
— Datos CSV: exporta los datos de las tablas a formato CSV, pero en este caso se
permite que el usuario elija los caracteres delimitadores de campo y de registro,
los caracteres de fin de línea y los valores a utilizar para reemplazar los valores
nulos.
Figura 15.24 Exportación de bases de datos
Cualquiera que sea el formato de exportación elegido, la página de exportación

permite finalmente indicar si el resultado se desea visualizar directamente en el
navegador o enviar a un archivo. En el caso de que se opte por esta última opción,
406
se debe indicar el nombre del archivo a crear e incluso es posible especificar si se

desea que sea comprimido utilizando el formato ZIP o GZIP (Figura 15.25).
Figura 15.25 Opciones de envío a archivo
La exportación de una única tabla de la base de datos es una operación muy

similar. Se accede a ella seleccionado la tabla a exportar en el enlace
correspondiente del marco izquierdo de la página y posteriormente activando el
enlace Exportar de la parte superior del marco derecho. La página a la que se
accede es prácticamente igual a la del caso anterior, pero con dos diferencias:
— Existe un nuevo formato de exportación exclusivo para tablas: el formato

XML.
— La segunda diferencia es la posibilidad de elegir el número de registros que se

desean exportar y el registro a partir del cual se inicia la exportación.
15.6. GESTIÓN DE USUARIOS

15.6.1. USUARIOS Y PRIVILEGIOS

Todos los usuarios registrados en MySQL se encuentran almacenados en la tabla
user de la base de datos mysql. Por supuesto, el contenido de dicha tabla puede ser
visualizado desde phpmyadmin como el de cualquier otra tabla, bastaría seleccionar
la base de datos mysql en el marco izquierdo y examinar la tabla user.
En dicha tabla se almacena el nombre de usuario, su contraseña, servidor desde el

que se conecta y los privilegios globales que tendrá sobre las bases de datos de
MySQL. Cuando un usuario tiene permisos específicos sobre una base de datos
407
concreta, una tabla, o incluso una sola columna de una tabla, estos privilegios
quedan reflejados en sendos registros de las tablas: db, tables_priv y columns_priv.
Existe otra manera de consultar desde phpmyadmin los usuarios registrados.

Además, con esta opción resulta muy simple la creación de nuevos usuarios y la
asignación de privilegios.
En la página de inicio de phpmyadmin se encuentra el enlace Privilegios, que da

acceso a la página que puede verse en la Figura 15.26. En esta página se muestran
todos los usuarios registrados en MySQL y los privilegios globales de cada uno de
ellos. En el caso que se muestra existe un único usuario (el usuario root que se crea
por defecto al instalar MySQL) que tiene además todos los privilegios globales,
esto quiere decir que este usuario podrá realizar cualquier tipo de acción sobre
cualquier tabla de cualquier base de datos.
Por debajo de la información de usuarios se encuentra un enlace que permitirá

agregar nuevos usuarios.
Figura 15.26 Página de gestión de usuarios
15.6.2. CREACIÓN DE USUARIOS

Para crear un nuevo usuario se puede insertar directamente un nuevo registro en la
tabla user o utilizar la opción anterior (enlace Agregar nuevo usuario de la página
de Privilegios). Esta última alternativa permite definir privilegios específicos de
una manera simple.
408
Por ejemplo, supóngase que se desea crear un usuario de nombre cinemasadmin

que tenga todo tipo de privilegios sobre la base de datos cinemas, pero no sobre las
restantes bases de datos disponibles. Al pulsar sobre el enlace Agregar nuevo
usuario, se accede al formulario mostrado en la Figura 15.27. En este formulario
debe indicarse el nombre, servidor desde el que puede conectarse y contraseña,
además de señalar los privilegios globales que tendrá. Estos privilegios globales se
referirán a todas las bases de datos de MySQL; en este caso, el usuario
cinemasadmin no tendrá ningún privilegio global.
Figura 15.27 Inserción de un nuevo usuario
Al pulsar el botón Continúe, se accede a una nueva página en la que se podrá

especificar privilegios específicos (Figura 15.28).
409
Figura 15.28 Definición de privilegios específicos para el usuario
Lo primera será indicar sobre qué base de datos el usuario tendrá privilegios
específicos, para ello en la página aparece una lista con todas las bases de datos
disponibles. Al elegir la base de datos cinemas o escribir su nombre en el campo
que acompaña a la lista y pulsar Continúe, se accederá a una nueva página (Figura
15.29). En esta nueva página se pueden señalar los privilegios específicos sobre la
base de datos cinemas; como puede apreciarse se han señalado todos los
privilegios. Una vez señalados, bastaría pulsar el botón Continúe para que esos
privilegios queden registrados.
Figura 15.29 Definición de privilegios
Como puede apreciarse en la Figura 15.29, es posible incluso especificar

privilegios específicos para tablas concretas. Por ejemplo, supóngase que Cinem@s
quiere generar un nuevo usuario cuya labor sea el mantenimiento de la tabla de
películas, pero no se desea que tenga acceso a ninguna otra tabla. El proceso de
creación de este nuevo usuario se describe a continuación.
410
Lo primero será crear el nuevo usuario sin asignarle ningún privilegio global. El
proceso es idéntico al realizado con el usuario anterior. A continuación, de nuevo,
se señalará que se desea definir privilegios específicos para la base de datos
cinemas, en el formulario correspondiente, no se señalará ningún privilegio
específico para la base de datos y se indicará la tabla sobre la que sí se desean
definir privilegios, tal como puede verse en la Figura 15.30.
Figura 15.30 Asignación de privilegios específicos sobre una tabla
Tras señalar la tabla PELICULAS, se accede a una nueva página (Figura 15.31) en
la que es posible indicar las acciones que el usuario podrá realizar sobre las
diferentes tablas e incluso sobre los diferentes campos de cada tabla. En el caso
anterior se está indicando que el usuario podrá efectuar operaciones de selección,
inserción, actualización y borrado sobre todos los campos de la tabla de películas.
Pulsando el botón Continúe estos privilegios quedarán registrados en la base de
datos mysql.
411
Figura 15.31 Definición de las acciones permitidas sobre la tabla
Para que todos los cambios realizados sobre los usuarios tengan efecto
sobre MySQL, suele ser conveniente reiniciar el servidor de MySQL. Para
NOTA realizar esta acción, en la página de inicio de phpmyadmin hay un enlace:
Reinicio de MySQL.
Tras todos los procesos realizados, en la tabla user de la base de datos mysql habrá
dos nuevos registros correspondientes a los dos nuevos usuarios; en la tabla db
aparecerá un nuevo registro en el que se indica que el usuario cinemasadmin tiene
todos los privilegios sobre la base de datos cinemas; y finalmente, en la tables_priv
habrá un nuevo registro en el que se indican los privilegios del usuario
películas_op sobre la tabla películas de la base de datos cinemas.
412
CONECTIVIDAD A
BASES DE DATOS
MYSQL DESDE PHP
16.1. INTRODUCCIÓN
El elemento esencial en todo proceso de generación de páginas web dinámicas es la

conectividad con aplicaciones de gestión de bases de datos. Muchas de las páginas
que se pueden encontrar en Internet se generan como resultado de una consulta a
una base de datos. En estos casos es preciso utilizar el lenguaje de consulta de las
bases de datos relacionales (SQL) embebido dentro de un lenguaje de
programación que permita generar esas páginas. En este capítulo se mostrará cómo
es posible realizar este proceso usando el lenguaje PHP y cómo la conectividad a
bases de datos en MySQL se caracteriza por su sencillez y efectividad.
Al igual que en los capítulos precedentes, el objetivo no será una mera descripción
de las diferentes funciones de conexión y de sus sintaxis; más bien se tratará de
mostrar su funcionamiento a través de sencillos ejemplos tomando como referencia
el sitio web Cinem@s que se viene desarrollando a lo largo del libro. Usando PHP
413

PHP y MySQL Tecnologías para El Desarrollo de Apli... - (PG 230 - 431)

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

PHP y MySQL Tecnologías para El Desarrollo de Apli... - (PG 230 - 431)

Cargado por

Copyright:

Formatos disponibles

PHP Y MYSQL.

TECNOLOGÍAS PARA EL DESARROLLO DE APLICACIONES WEB

En este caso concreto, se está llamando a la función precio_normal(), y, por

El importe total de las 5 entradas es 22.5 euros.

Para obtener el día de la semana correspondiente al día actual se utiliza la función

Si se utilizan funciones variables, se debe tener especial cuidado en evitar la

bruscamente la ejecución del programa. Para asegurarse de que una función

function_exists() busca la correspondiente función tanto entre la funciones

Por ejemplo, una simple ejecución de las sentencias

8.1. CONCEPTOS FUNDAMENTALES

Este capítulo se centra en explicar los procesos de construcción de arrays y sus

Un array o matriz es un conjunto de datos que se almacenan bajo un nombre

los programas, pues permite la modificación posterior del array, suprimiendo o

8.1.1. CONSTRUCCIÓN DE ARRAYS

A la hora de añadir un último elemento no es necesario indicar el índice

de la función array(), de la siguiente forma:

$x = array(1, "¡¡hola!!",3, "Último");

En este primer ejemplo se ha mostrado la forma de construir un array indexado

$peliculasAño["La costilla de Adán"] = 1949;

Opcionalmente, con ayuda de la función array() se podría generar el array de la

$peliculasAño=array("La costilla de Adán" => 1949,

$peliculasAño["West Side Story"] = 1961;

echo "El año de producción de la película <i>Sabrina</i>

En el caso de que la palabra clave no contenga espacios en blanco, basta con

$a = $peliculasAño["Roma, ciudad abierta"];

Cualquier intento de acceso a un elemento del array mediante un índice

8.1.2. ARRAYS MULTIDIMENSIONALES

El lenguaje PHP permite la creación de arrays multidimensionales, es decir, arrays

La definición equivalente usando la función array() sería:

Por supuesto, es posible definir arrays asociativos multidimensionales, e incluso

Conviene advertir de la necesidad de tener especial cuidado al utilizar arrays

echo "Hoy se proyectará una producción de 1937 dirigida

echo "El director de la película

8.2. RECORRIDO DE TODOS LOS ELEMENTOS

Para la manipulación de los elementos de arrays se dispone de estructuras iterativas

$actors = array("Marlon Brando","Gary Cooper",

tanto en el caso de índices numéricos como en arrays asociativos, se puede utilizar

foreach(array as índice => valor)

$películasAño = array("La costilla de Adán" => 1949,

echo "<i>$indice,</i> ($valor) <br>\n";

el resultado generado sería:

La costilla de Adán, (1949)

En cada llamada a dicha función se recupera un elemento del array; cuando se

y los elementos del array.

El resultado generado por estas estructuras iterativas es:

Datos de La costilla de Adán:

Cuando se desea conocer el número de elementos de un array, puede usarse la

Considérese, por ejemplo, la necesidad de mostrar una tabla de distancias

Figura 8.1 Tabla de distancias kilométricas

8.3. FUNCIONES DE MANIPULACIÓN DE

8.3.1. TRANSFORMACIÓN DE LOS ÍNDICES

CASE_UPPER (conversión a mayúsculas) y CASE_LOWER (conversión a

$actores["Primer actor"] = "Gary Cooper";

produce la siguiente salida:

PRIMER ACTOR: Gary Cooper

— array_chunk(array,dimensión,valor_booleano): el array dado

foreach($valor as $indice => $valor){

0-> Horizontes de grandeza

De esta manera, el resultado obtenido sería:

8.3.3. CONTABILIZACIÓN DE ELEMENTOS

— array_count_values(array): devuelve un array formado por valores

— count(array): devuelve el número de elementos de un array. Es útil en

$a = array("a", "b", "c", "a", "d", "e", "b", "d", "a");