PHP Data Objects (PDO)

La extensión PDO (PHP Data Objects) permite acceder a distintas

bases de datos utilizando las misma funciones, lo que facilita la
portabilidad. En PHP 5 existen drivers para acceder a las bases de
datos más populares (MySQL, Oracle, MS SQL Server, PostgreSQL,
SQLite, Firebird, DB2, Informix, etc).
En esta lección se explica el acceso a MySQL y SQLite mediante
PDO. La extensión PDO no evalúa la correción de las consultas SQL.

 Conexión con la base de datos

o Conexión con MySQL
o Conexión con SQLite 3
o Conexión configurable
 Desconexión con la base de datos
 Consultas a la base de datos
 Seguridad en las consultas: consultas preparadas
o Consultas preparadas
o Restricciones en los parámetros de consultas preparadas
 Ejemplos de consultas
o Consultas CREATE DATABASE, DROP DATABASE,
CREATE TABLE
 Consultas en MySQL
 Consultas en SQLite
 Solución configurable
o Consultas DROP TABLE, INSERT INTO, UPDATE,
DELETE FROM
o Consulta SELECT
o Consulta SELECT LIKE
o Consultas de unión de tablas

Conexión con la base de datos

Para conectar con la base de datos hay que crear una instancia de la
clase PDO, que se utiliza en todas las consultas posteriores. En cada
página php que incluya consultas a la base de datos es necesario
conectar primero con la base de datos.
Si no se puede establecer la conexión con la base de datos, puede
deberse a que la base de datos no esté funcionando, a que los datos
de usuario no sean correctos, a que no esté activada la extensión pdo
o (en el caso de SQLite) que no exista el camino donde se guarda la
base de datos.

Conexión con MySQL

En el caso de MySQL, la creación de la clase PDO incluye el nombre

del servidor, el nombre de usuario y la contraseña.
Para poder acceder a MySQL mediante PDO, debe estar activada la
extensión php_pdo_mysql en el archivo de configuración php.ini
(véase el apartado extensión pdo_mysql en la lección de configuración
de Apache y PHP).
// FUNCIÓN DE CONEXIÓN CON LA BASE DE DATOS MYSQL
function conectaDb()
{
try {
$db = new PDO("mysql:host=localhost", "root", "");
$db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY,
true);
return($db);
} catch (PDOException $e) {
cabecera("Error grave");
print "<p>Error: No puede conectarse con la base de
datos.</p>\n";
// print "<p>Error: " . $e->getMessage() . "</p>\n";
pie();
exit();
}
}

// EJEMPLO DE USO DE LA FUNCIÓN ANTERIOR

// La conexión se debe realizar en cada página que acceda a
la base de datos
$db = conectaDB();

Conexión con SQLite 3

En SQLite, no se hace una conexión a un servidor, sino que

simplemente se indica el archivo que va a contener la base de datos.
En SQLite no hay un servidor que gestiona todas las bases de datos,
sino que cada base de datos es un archivo independiente (que debe
estar situado en un directorio que exista y en el que el servidor web
tenga permisos de escritura).
Para poder utilizar SQLite mediante PDO, debe estar activada la
extensión php_pdo_sqlite en el archivo de configuración php.ini (véase
el apartado extensión pdo_sqlite en la lección de configuración de
Apache y PHP).
// FUNCIÓN DE CONEXIÓN CON LA BASE DE DATOS SQLITE
function conectaDb()
{
try {
$db = new
PDO("sqlite:/tmp/mclibre_baseDeDatos.sqlite");
return($db);
} catch (PDOException $e) {
cabecera("Error grave");
print "<p>Error: No puede conectarse con la base de
datos.</p>\n";
// print "<p>Error: " . $e->getMessage() . "</p>\n";
pie();
exit();
}
}

// EJEMPLO DE USO DE LA FUNCIÓN ANTERIOR

// La conexión se debe realizar en cada página que acceda a
la base de datos
$db = conectaDB();

Nota: En las soluciones de los ejercicios proporcionadas en estos

apuntes, los archivos se guardan en el directorio /tmp/mclibre. Se
debe crear ese directorio para que funcione las soluciones o cambiarlo
a otro.

Conexión configurable

Si se incluyen ambas conexiones en el mismo programa, cada usuario

puede elegir la base de datos más conveniente en cada caso.
En los ejercicios en este curso se propone al alumno organizar los
programas de manera que puedan trabajar tanto con SQLite como con
MySQL y hacerlo de forma organizada, para que se puedan añadir
fácilmente otras bases de datos.
Para ello se crearán dos bibliotecas, una dedicada a MySQL y otra a
SQLite, que contengan las funciones específicas de cada base de
datos. Además habrá una biblioteca general en la que se pueda
seleccionar la biblioteca a utilizar (MySQL o SQLite). Así, cada página
llamará a la biblioteca general y esta llamará a la biblioteca específica.
Por ejemplo, para el caso de la función de conexión, el resultado sería:
 en cualquier fichero que quiera conectar con la base de datos se
llamaría a la biblioteca general y se llamaría a la función
genérica conectaDB():
 // EJEMPLO DE USO DE CONEXIÓN CONFIGURABLE
 // La conexión se debe realizar en cada página que acceda
a la base de datos
 require_once "biblioteca.php";
$db = conectaDB();

 biblioteca.php: en ella se selecciona la biblioteca específica a

cargar:
 // biblioteca.php
 define("MYSQL", "MySQL"); // Base de
datos MySQL
 define("SQLITE", "SQLite"); // Base de
datos SQLITE

 $dbMotor = SQLITE; // Base de
datos empleada (MYSQL o SQLITE)

 if ($dbMotor == MYSQL) {
 require_once "biblioteca_mysql.php";
 } elseif ($dbMotor == SQLITE) {
 require_once "biblioteca_sqlite.php";
}

 biblioteca_mysql.php: contiene la definición de la función

conectaDB() específica para trabajar con MySQL
 // biblioteca_mysql.php
 function conectaDb()
 {
 try {
 $db = new PDO(MYSQL_HOST, MYSQL_USUARIO,
MYSQL_PASSWORD);
 $db-
>setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY,
true);
 return($db);
 } catch(PDOException $e) {
 cabecera("Error grave", MENU_PRINCIPAL);
 print "<p>Error: No puede conectarse con la base
de datos.</p>\n";
 print "<p>Error: " . $e->getMessage() . "</p>\n";
 pie();
 exit();
  }
}

 biblioteca_sqlite.php: contiene la definición de la función

conectaDB() específica para trabajar con SQLite
 // biblioteca_sqlite.php
 function conectaDb()
 {
 global $dbDb;

 try {
 $db = new PDO("sqlite:" . $dbDb);
 return($db);
 } catch(PDOException $e) {
 cabecera("Error grave", MENU_PRINCIPAL);
 print "<p>Error: No puede conectarse con la base
de datos.</p>\n";
 print "<p>Error: " . $e->getMessage() . "</p>\n";
 pie();
 exit();
 }
}

Volver al principio de la página

Desconexión con la base de datos

Para desconectar con la base de datos hay que destruir el objeto

PDO. Si no se destruye el objeto PDO, PHP lo destruye al terminar la
página.
$db = null;

Volver al principio de la página

Consultas a la base de datos

Una vez realizada la conexión a la base de datos, las operaciones se

realizan a través de consultas.
El método para efectuar consultas es  PDO->query($consulta),
que devuelve el resultado de la consulta. Dependiendo del tipo de
consulta, el dato devuelto debe tratarse de formas distintas.
 Si es una consulta que no devuelve registros, sino que
simplemente realiza una acción que puede tener éxito o no (por
ejemplo, insertar un registro), el método devuelvetrue o false.
No es necesario guardar el resultado de la consulta en ninguna
variable, pero se puede utilizar para sacar un mensaje diciendo
que todo ha ido bien (o no). Por ejemplo,
 // EJEMPLO DE CONSULTA DE INSERCIÓN DE REGISTRO
 require_once "biblioteca.php";
 $db = conectaDB();

 $consulta = "INSERT INTO $dbTabla
 (nombre, apellidos)
 VALUES ("$nombre", "$apellidos")";
 if ($db->query($consulta)) {
 print "<p>Registro creado correctamente.</p>\n";
 } else {
 print "<p>Error al crear el registro.<p>\n";
 }

$db = null;

 Pero si la consulta devuelve registros, el método devuelve los

registros correspondientes o false. En ese caso sí que es
conveniente guardar lo que devuelve el método en una variable
para procesarla posteriormente. Si contiene registros, la variable
es de un tipo especial llamado recurso que no se puede acceder
directamente, pero que se puede recorrer con un
bucle foreach(),
 // EJEMPLO DE CONSULTA DE SELECCIÓN DE REGISTROS
 require_once "biblioteca.php";
 $db = conectaDB();

 $consulta = "SELECT * FROM $dbTabla";
 $result = $db->query($consulta);
 if (!$result) {
 print "<p>Error en la consulta.</p>\n";
 } else {
 foreach ($result as $valor) {
 print "<p>$valor[nombre]
$valor[apellidos]</p>\n";
 }
 }
 
$db = null;

En los ejemplos, se define una variable $consulta que contiene la

consulta y a continuación se ejecuta la consulta, pero podría estar en
una sola:
// En dos líneas
$consulta = "SELECT * FROM $dbTabla";
$result = $db->query($consulta);

// En una sola línea

$result = $db->query("SELECT * FROM $dbTabla");

Se recomienda utilizar la primera versión, que permite por ejemplo

imprimir la consulta mientras se está programando para comprobar
que no tiene errores:
$consulta = "SELECT * FROM $dbTabla";
print "<p>Consulta: $consulta</p>\n";
$result = $db->query($consulta);

Volver al principio de la página

Seguridad en las consultas: consultas preparadas

Para evitar ataques de inyección SQL (en la lección  Inyecciones

SQL se comentan los ataques más elementales), se recomienda el
uso de sentencias preparadas, en las que PHP se encarga de
"desinfectar" los datos en caso necesario. En general, cualquier
consulta que incluya datos introducidos por el usuario debe realizarse
mediante consultas preparadas.

Consultas preparadas

El método para efectuar consultas es primero preparar la consulta

con PDO->prepare($consulta) y después ejecutarla con PDO-
>execute(array(parámetros)), que devuelve el resultado de la
consulta.
// Consulta preparada
$consulta = "SELECT * FROM $dbTabla";
$result = $db->prepare($consulta);
$result->execute();

Dependiendo del tipo de consulta, el dato devuelto debe tratarse de

formas distintas, como se ha explicado en el apartado anterior.
Si la consulta incluye datos introducidos por el usuario, los datos
pueden incluirse directamente en la consulta, pero en ese caso, PHP
no realiza ninguna "desinfección" de los datos, por lo que estaríamos
corriendo riesgos de ataques:
$nombre = $_REQUEST["nombre"];
$apellidos = $_REQUEST["apellidos"];

$consulta = "SELECT COUNT(*) FROM $dbTabla

WHERE nombre=$nombre
AND apellidos=$apellidos"; //
DESACONSEJADO: PHP NO DESINFECTA LOS DATOS
$result = $db->prepare($consulta);
$result->execute();
if (!$result) {
print "<p>Error en la consulta.</p>\n";
...

Para que PHP desinfecte los datos, estos deben enviarse al ejecutar
la consulta, no al prepararla. Para ello es necesario indicar en la
consulta la posición de los datos. Esto se puede hacer de dos
maneras, mediante parámetros o mediante interrogantes, aunque se
aconseja la utilización de parámetros:

 mediante parámetros (:parametro)

En este caso la matriz debe incluir los nombres de los

parámetros y los valores que sustituyen a los parámetros (el
orden no es importante), como muestra el siguiente ejemplo:
$nombre = $_REQUEST["nombre"];
$apellidos = $_REQUEST["apellidos"];

$consulta = "SELECT COUNT(*) FROM $dbTabla

WHERE nombre=:nombre
AND apellidos=:apellidos";
$result = $db->prepare($consulta);
$result->execute(array(":nombre" => $nombre,
":apellidos" => $apellidos));
if (!$result) {
print "<p>Error en la consulta.</p>\n";
...

 mediantes interrogantes (?)

 En este caso la matriz debe incluir los valores que sustituyen a
los interrogantes en el mismo orden en que aparecen en la
consulta, como muestra el siguiente ejemplo:
$nombre = $_REQUEST["nombre"];
$apellidos = $_REQUEST["apellidos"];

$consulta = "SELECT COUNT(*) FROM $dbTabla

WHERE nombre=?
AND apellidos=?";
$result = $db->prepare($consulta);
$result->execute(array($nombre, $apellidos));
if (!$result) {
print "<p>Error en la consulta.</p>\n";
...

Aunque no vayan a causar problermas en las consultas, sigue siendo

conveniente tratar los datos recibidos para eliminar los espacios en
blanco iniciales y finales, tratar los caracteres especiales del html, etc.,
como se comenta en la lección de Recogida de datos.

Restricciones en los parámetros de consultas preparadas

Debido a que las consultas preparadas se idearon para optimizar el

rendimiento de las consultas, el uso de parámetros tiene algunas
restricciones. Por ejemplo

 los identificadores (nombres de tablas, nombres de columnas,

etc) no pueden sustituirse por parámetros
 los dos elementos de una igualdad no pueden sustituirse por
parámetros
 en general no pueden utilizarse parátros en las consultas DDL
(lenguaje de definición de datos) (nombre y tamaño de los
campos, etc.)

Si no podemos usar parámetros, no queda más remedio que incluir los

datos en la consulta. Como en ese caso PHP no hace ninguna
desinfección de los datos, la tenemos que hacer nosotros
previamente.
Como en estos casos los valores introducidos por el usuario suelen
tener unos valores restringidos (por ejemplo, si el usuario puede elegir
una columna de una tabla, los nombres de las columnas están
determinadas y el usuario sólo puede elegir uno de ellos). Podemos
crear una función de recogida de datos específica que impida
cualquier tipo de ataque de inyección por parte del usuario, como
muestra el siguiente ejemplo
// FUNCIÓN DE RECOGIDA DE UN DATO QUE SÓLO PUEDE TOMAR
DETERMINADOS VALORES
$campos = array(
"nombre",
"apellidos");

function recogeCampo($var, $var2)

{
global $campos;

foreach($campos as $campo) {
if (isset($_REQUEST[$var]) && $_REQUEST[$var] ==
$campo) {
return $campo;
}
}
return $var2;
}

// EJEMPLO DE USO DE LA FUNCIÓN ANTERIOR

$campo = recogeCampo("campo", "apellidos");
$nombre = $_REQUEST["nombre"];

$consulta = "SELECT * FROM $dbTabla

WHERE nombre=:nombre
ORDER BY $campo ASC";
$result = $db->prepare($consulta);
$result->execute(array(":nombre" => $nombre));
if (!$result) {
print "<p>Error en la consulta.</p>\n";
...

Volver al principio de la página

Ejemplos de consultas

En los ejemplos de este apartado, se han utilizado sentencias

preparadas en los casos en los que las consultas incluyen datos
proporcionados por el usuario y consultas no preparadas cuando no
incluyan datos proporcionados por el usuario. En la mayoría de los
casos se podrían haber gastado sentencias preparadas aunque no
haya datos proporcionados por el usuario.
Volver al principio de la página

Consultas CREATE DATABASE, DROP DATABASE, CREATE TABLE

Estas consultas no son iguales en MySQL y SQLite. En los ejercicios

propuestos para que se pueda utilizar una u otra base de datos, estas
consultas se incluyen en las bibliotecas específicas.

 En el caso de utiliza SQLite, no tiene sentido crear o borrar la

base de datos ya que con SQLite cada base de datos es un
fichero distinto y al conectar con la base de datos ya se dice con
qué archivo se va a trabajar y se crea en caso necesario.
 Para crear una tabla, se utiliza la consulta CREATE TABLE. Las
consultas de creación de tabla suelen ser específicas de cada
base de datos. Los ejemplos no utilizan sentencias preparadas
(en caso de utilizarse sentencias preparadas, las variables no
podrían ir como parámetros por tratarse de sentencias DDL).

Consultas en MySQL

Para crear una base de datos, se utiliza la consulta CREATE

DATABASE.
// EJEMPLO DE CONSULTA DE CREACIÓN DE BASE DE DATOS EN MYSQL
$consulta = "CREATE DATABASE $dbDb
CHARACTER SET latin1 COLLATE latin1_spanish_ci";
if ($db->query($consulta)) {
print "<p>Base de datos creada correctamente.</p>\n";
} else {
print "<p>Error al crear la base de datos.</p>\n";
}

Nota: El juego de carácteres utilizado en este curso es  iso-8859-1, por

lo que en la base de datos MySQL se utiliza el juego de
caracteres latin1 y el cotejamientolatin1_spanish_ci.
Para borrar una base de datos, se utiliza la consulta DROP
DATABASE.
// EJEMPLO DE CONSULTA DE BORRADO DE BASE DE DATOS EN MYSQL
$consulta = "DROP DATABASE $dbDb";
if ($db->query($consulta)) {
print "<p>Base de datos borrada correctamente.</p>\n";
} else {
print "<p>Error al borrar la base de datos.</p>\n";
}
Para crear una tabla, se utiliza la consulta CREATE TABLE. Las
consultas de creación de tabla suelen ser específicas de cada base de
datos. El ejemplo no utiliza sentencias preparadas (en caso de
utilizarse sentencias preparadas, las variables no podrían ir como
parámetros por tratarse de sentencias DDL).
// EJEMPLO DE CONSULTA DE CREACIÓN DE TABLA EN MYSQL
$consulta = "CREATE TABLE $dbTabla (
id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
nombre VARCHAR($tamNombre),
apellidos VARCHAR($tamApellidos),
PRIMARY KEY(id)
)";
if ($db->query($consulta)) {
print "<p>Tabla creada correctamente.</p>\n";
} else {
print "<p>Error al crear la tabla.</p>\n";
}

Consultas en SQLite

En el caso de utiliza SQLite, no tiene sentido crear o borrar la base de

datos ya que con SQLite cada base de datos es un fichero distinto y al
conectar con la base de datos ya se dice con qué archivo se va a
trabajar y se crea en caso necesario. Es suficiente borrar y crear las
tablas.
// EJEMPLO DE CONSULTA DE BORRADO DE TABLA EN SQLITE
$consulta = "DROP TABLE $dbTabla";
if ($db->query($consulta)) {
print "<p>Tabla borrada correctamente.</p>\n";
} else {
print "<p>Error al borrar la tabla.</p>\n";
}

Para crear una tabla, se utiliza la consulta CREATE TABLE. Las

consultas de creación de tabla suelen ser específicas de cada base de
datos. El ejemplo no utiliza sentencias preparadas (en caso de
utilizarse sentencias preparadas, las variables no podrían ir como
parámetros por tratarse de sentencias DDL).
// EJEMPLO DE CONSULTA DE CREACIÓN DE TABLA EN SQLite
$consulta = "CREATE TABLE $dbTabla (
id INTEGER PRIMARY KEY,
nombre VARCHAR($tamNombre),
apellidos VARCHAR($tamApellidos)
)";
 if ($db->query($consulta)) {
print "<p>Tabla creada correctamente.</p>\n";
} else {
print "<p>Error al crear la tabla.</p>\n";
}

Solución configurable

El resultado sería

 en el fichero que quiera reiniciar la base de datos se llamaría a

la biblioteca general y se llamaría a la función genérica
borraTodo():
 // EJEMPLO DE USO DE CONEXIÓN CONFIGURABLE// La conexión
se debe realizar en cada página que acceda a la base de
datos
 require_once "biblioteca.php";
 $db = conectaDb();
 borraTodo($db);
$db = null;

 biblioteca_mysql.php: contiene la definición de la función

borraTodo() específica para trabajar con MySQL y que borra la
base de datos, la crea y crea la tabla:
 // biblioteca_mysql.php
 $consultaCreaTabla = "CREATE TABLE $dbTabla (
 id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
 nombre VARCHAR($tamNombre),
 apellidos VARCHAR($tamApellidos),
 PRIMARY KEY(id)
 )";

 function borraTodo($db)
 {
 global $dbDb, $consultaCreaTabla;

 $consulta = "DROP DATABASE $dbDb";
 if ($db->query($consulta)) {
 print "<p>Base de datos borrada
correctamente.</p>\n";
 } else {
  print "<p>Error al borrar la base de
datos.</p>\n";
 }
 $consulta = "CREATE DATABASE $dbDb";
 if ($db->query($consulta)) {
 print "<p>Base de datos creada
correctamente.</p>\n";
 $consulta = $consultaCreaTabla;
 if ($db->query($consulta)) {
 print "<p>Tabla creada correctamente.</p>\n";
 } else {
 print "<p>Error al crear la tabla.</p>\n";
 }
 } else {
 print "<p>Error al crear la base de
datos.</p>\n";
 }
}

 biblioteca_sqlite.php: contiene la definición de la función

borraTodo() específica para trabajar con SQLite y que borra la
tabla y la crea:
 // biblioteca_sqlite.php
 $consultaCreaTabla = "CREATE TABLE $dbTabla (
 id INTEGER PRIMARY KEY,
 nombre VARCHAR($tamNombre),
 apellidos VARCHAR($tamApellidos)
 )";

 function borraTodo($db)
 {
 global $dbTabla, $consultaCreaTabla;

 $consulta = "DROP TABLE $dbTabla";
 if ($db->query($consulta)) {
 print "<p>Tabla borrada correctamente.</p>\n";
 } else {
 print "<p>Error al borrar la tabla.</p>\n";
 }
 $consulta = $consultaCreaTabla;
 if ($db->query($consulta)) {
 print "<p>Tabla creada correctamente.</p>\n";
  } else {
 print "<p>Error al crear la tabla.</p>\n";
 }
}

Volver al principio de la página

Consultas DROP TABLE, INSERT INTO, UPDATE, DELETE FROM

Para borrar una tabla, se utiliza la consulta DROP TABLE.

// EJEMPLO DE CONSULTA DE BORRADO DE TABLA
$consulta = "DROP TABLE $dbTabla";
if ($db->query($consulta)) {
print "<p>Tabla borrada correctamente.</p>\n";
} else {
print "<p>Error al borrar la tabla.</p>\n";
}

Para añadir un registro a una tabla, se utiliza la consulta INSERT

INTO.
// EJEMPLO DE CONSULTA DE INSERCIÓN DE REGISTRO
$nombre = recoge("nombre");
$apellidos = recoge("apellidos");

$consulta = "INSERT INTO $dbTabla

(nombre, apellidos)
VALUES (:nombre, :apellidos)";
$result = $db->prepare($consulta);
if ($result->execute(array(":nombre" => $nombre, ":apellidos"
=> $apellidos))) {
print "<p>Registro creado correctamente.</p>\n";
} else {
print "<p>Error al crear el registro.</p>\n";
}

Para modificar un registro a una tabla, se utiliza la consulta UPDATE.

// EJEMPLO DE CONSULTA DE MODIFICACIÓN DE REGISTRO
$nombre = recoge("nombre");
$apellidos = recoge("apellidos");
$id = recoge("id");

$consulta = "UPDATE $dbTabla

SET nombre=:nombre, apellidos=:apellidos
 WHERE id=:id";
$result = $db->prepare($consulta);
if ($result->execute(array(":nombre" => $nombre, ":apellidos"
=> $apellidos, ":id" => $id))) {
print "<p>Registro modificado correctamente.</p>\n";
} else {
print "<p>Error al modificar el registro.</p>\n";
}

Para borrar un registro de una tabla, se utiliza la consulta DELETE

FROM.
Nota: En el ejemplo, los registros a borrar se reciben en forma de
matriz y se recorre la matriz borrando un elemento en cada iteración.
// EJEMPLO DE CONSULTA DE BORRADO DE REGISTRO
$id = recogeMatriz("id");

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

$consulta = "DELETE FROM $dbTabla
WHERE id=:indice";
$result = $db->prepare($consulta);
if ($result->execute(array(":indice" => $indice))) {
print "<p>Registro borrado correctamente.</p>\n";
} else {
print "<p>Error al borrar el registro.</p>\n";
}
}

Volver al principio de la página

Consulta SELECT

Para obtener registros que cumplan determinados criterios se utiliza

una consulta SELECT.

 Si se produce un error en la consulta, la consulta devuelve el

valor false .
 // EJEMPLO DE CONSULTA DE SELECCIÓN DE REGISTROS

 $consulta = "SELECT * FROM $dbTabla";

 $result = $db->query($consulta);

 if (!$result) {

 print "<p>Error en la consulta.</p>\n";

} else {
  print "<p>Consulta ejecutada.</p>\n";
}

 Si la consulta devuelve un único registro se puede utilizar la

función PDOStatement->fetchColumn() para recuperar la
primera columna.
 // EJEMPLO DE CONSULTA DE SELECCIÓN DE REGISTROS
 $consulta = "SELECT COUNT(*) FROM $dbTabla";

 $result = $db->query($consulta);

 if (!$result) {

 print "<p>Error en la consulta.</p>\n";

} else {

 $encontrados = $result->fetchColumn();

 print "<p>Se han encontrado $encontrados

registros.</p>\n";
}

 Si la consulta se ejecuta correctamente, la consulta devuelve los

registros correspondientes. 
o Para acceder a los registros devueltos por la consulta, se
puede utilizar un bucle foreach.
o // EJEMPLO DE CONSULTA DE SELECCIÓN DE REGISTROS
o $consulta = "SELECT * FROM $dbTabla";
o $result = $db->query($consulta);
o if (!$result) {
o print "<p>Error en la consulta.</p>\n";
o } else {
o foreach ($result as $valor) {
o print "<p>Nombre: $valor[nombre] -
Apellidos: $valor[apellidos]</p>\n";
o }
}

o O también se puede utilizar la función PDOStatement-

>fetch().
o // EJEMPLO DE CONSULTA DE SELECCIÓN DE REGISTROS
o $consulta = "SELECT * FROM $dbTabla";
o $result = $db->query($consulta);
o if (!$result) {
o print "<p>Error en la consulta.</p>\n";
o } else {
o while ($valor = $result->fetch()) {
 o print "<p>Nombre: $valor[nombre] -
Apellidos: $valor[apellidos]</p>\n";
o }
}

 Si la consulta no devuelve ningún registro, los dos bucles

anteriores (foreach o fetch) no escribirían nada. Por ello se
recomienda hacer primero una consulta que cuente el número
de resultados de la consulta y, si es mayor que cero, hacer la
consulta.

El ejemplo siguiente utiliza la función  PDOStatement-

>fetchColumn(), que devuelve la primera columna del primer
resultado (que en este caso contiene el número de registros de
la consulta).
// EJEMPLO DE CONSULTA DE SELECCIÓN DE REGISTROS
$consulta = "SELECT COUNT(*) FROM $dbTabla";
$result = $db->query($consulta);
if (!$result) {
print "<p>Error en la consulta.</p>\n";
} elseif ($result->fetchColumn() == 0) {
print "<p>No se ha creado todavía ningún registro
en la tabla.</p>\n";
} else {
$consulta = "SELECT * FROM $dbTabla";
$result = $db->query($consulta);
if (!$result) {
print "<p>Error en la consulta.</p>\n";
} else {
foreach ($result as $valor) {
print "<p>Nombre: $valor[nombre] -
Apellidos: $valor[apellidos]</p>\n";
}
}
}

Volver al principio de la página

Consulta SELECT LIKE

La consulta SELECT permite efectuar búsquedas en cadenas

utilizando el condicional LIKE o NOT LIKE y los comodines _
(cualquier carácter) o % (cualquier número de caracteres).
Ejemplos de consultas:
  Registros en los que el apellido empieza por la cadena recibida:
 // EJEMPLO DE CONSULTA DE SELECCIÓN DE REGISTROS
 $apellidos = recoge("apellidos");

 $consulta = "SELECT COUNT(*) FROM $dbTabla
 WHERE apellidos LIKE :apellidos";
 $result = $db->prepare($consulta);
 $result->execute(array(":apellidos" => "$apellidos%"));
 if (!$result) {
 print "<p>Error en la consulta.</p>\n";
 } else {
 print "<p>Se han encontrado " . $result-
>fetchColumn() . " registros.</p>\n";
}

 Registros en los que el apellido contiene la cadena recibida:

 // EJEMPLO DE CONSULTA DE SELECCIÓN DE REGISTROS
 $apellidos = recoge("apellidos");

 $consulta = "SELECT COUNT(*) FROM $dbTabla
 WHERE apellidos LIKE :apellidos";
 $result = $db->prepare($consulta);
 $result->execute(array(":apellidos" => "%$apellidos%"));
 if (!$result) {
 print "<p>Error en la consulta.</p>\n";
 } else {
 print "<p>Se han encontrado " . $result-
>fetchColumn() . " registros.</p>\n";
}

Volver al principio de la página

Consultas de unión de tablas

Se pueden también realizar consultas de unión entre varias tablas (el

ejemplo está sacado del ejercicio de Biblioteca):
Nota: Escribir como consulta preparada.
// EJEMPLO DE CONSULTA DE UNIÓN DE TABLAS
$consulta = "SELECT $dbPrestamos.id AS id, $dbUsuarios.nombre
as nombre,
$dbUsuarios.apellidos as apellidos, $dbObras.titulo as
titulo,
$dbPrestamos.prestado as prestado, $dbPrestamos.devuelto
as devuelto
FROM $dbPrestamos, $dbUsuarios, $dbObras
 WHERE $dbPrestamos.id_usuario=$dbUsuarios.id AND
$dbPrestamos.id_obra=$dbObras.id and
$dbPrestamos.devuelto='0000-00-00'
ORDER BY $campo $orden";
$result = $db->query($consulta);
if (!$result) {
print "<p>Error en la consulta.</p>\n";
} else {
...

Volver al principio de la página

Última modificación de esta página: 8 de diciembre de 2014

Páginas web con PHP por Bartolomé Sintes Marco

se distribuye bajo una Licencia Creative Commons Reconocimiento-
CompartirIgual 4.0 Internacional (CC BY-SA 4.0).