Si bien los programas CGI, no son los más adecuados, por cuestiones de seguridad y

performance existen situaciones donde se quiere utilizar PHP en este modo. Por ejemplo,
en situaciones en las que por alguna razón no se desea integrar PHP como módulo de algún
software de servidor web, o en donde se espera usar PHP con diferentes tipos de capas que
envuelven el entorno CGI para crear ambientes chroot y setuid seguros para la ejecución de
scripts. Esta configuración usualmente involucra la instalación de un binario ejecutable del
intérprete PHP en el directorio cgi-bin del servidor web. El aviso de seguridad de CERT
CA96.11 justamente recomienda evitar la colocación de cualquier intérprete bajo cgi-bin,
con lo cual se deberá reforzar las configuraciones para evitar cualquier situación de peligro.
A continuación se describirá una de las vulnerabilidades más conocidas provocada por esta
configuración y la forma de prevenirla desde una buena configuración de PHP.
Acceso a cualquier documento en el servidor
Al instalar un servidor web, se debe especificar ciertos directorios donde se puede a acceder
desde
afuera, obviamente, con los permisos adecuados. Pero se ve en el siguiente ejemplo que si
cualquier navegador ingresa a la url:
http://mi.servidor/cgi-bin/php/zona_secreta/doc.html
Puede verse que se le está indicando al programa PHP, instalado en cgi-bin, que abra e
interprete el documento que se encuentra en el directorio “zona_secreta”.
Solución Propuesta
Al compilar PHP se pueden utilizar algunas directivas para evitar este tipo de accesos no
permitidos.
Específicamente, la configuración en tiempo de compilación --enable-force-cgi-redirect y
las
directivas de configuración en tiempo de ejecución doc_root y user_dir pueden ser usadas
para
prevenir este tipo de ataques, si el árbol de documentos del servidor llegara a tener algún
directorio
con restricciones de acceso.
El problema es que incluir contenido activo en los directorios de documentos del servidor
web, como
scripts y ejecutables, es considerada en ocasiones una práctica insegura.
4.1.2. Instalación como módulo de Apache
Como se mencionó anteriormente, PHP también se lo puede instalar como un módulo de
Apache. En este caso, hereda los permisos del usuario de Apache (generalmente los del
usuario "nobody"). Este hecho representa varios impactos sobre la seguridad y las
autorizaciones.
Seguridad del sistema de archivos
PHP fue diseñado para permitir acceso al nivel de usuarios al sistema de archivos. Por este
motivo es posible escribir un script que permita leer archivos del sistema como /etc/passwd,
modificar
conexiones tipo ethernet, enviar trabajos de impresión masivos, etc. Esto tiene algunas
implicaciones obvias, en el sentido en que hay que asegurarse que los archivos desde los
que lee y hacia los que escribe datos, sean los correctos.
4.3. Acceso seguro a la Bases de Datos
Entre más acciones se tome para incrementar la protección de su base de datos, menor será
la
probabilidad de que un ataque tenga éxito exponiendo o abusando de cualquier información
almacenada. Un buen diseño del esquema de la base de datos y de la aplicación es
fundamental.
4.3.1. Diseño de Bases de Datos
Una buena práctica en el diseño de BBDD es crear diferentes usuarios de la base de datos
para cada
aspecto de su aplicación con derechos muy limitados sobre los objetos de la base de datos.
Sólo
deben otorgarse los privilegios estrictamente necesarios, y evitar que el mismo usuario
pueda
interactuar con la base de datos en diferentes casos de uso. Esto quiere decir que si un
intruso gana acceso a la base de datos usando las credenciales de sus aplicaciones, él solo
puede efectuar tantos cambios como su perfil se lo permita.
4.3.2. Aspectos relacionados con la conexión a la Base de Datos
Una de las pautas recomendadas con la conexión a la BBDD es utilizar SSL(5) para
encriptar las
comunicaciones cliente/servidor, para incrementar el nivel de seguridad, o hacer uso de ssh
para
encriptar la conexión de red entre los clientes y el servidor de la base de datos. Si
cualquiera de estos recursos es usado, entonces monitorear el tráfico y adquirir información
sobre la base de datos dificultará o identificará posibles ataques a la BBDD.
4.3.3. Modelo de Almacenamiento Encriptado
Otro aspecto a tener en cuenta es que si el ataque adquiere acceso directo a su base de datos
(evitando el paso por el servidor web), los datos almacenados estarán expuestos a menos
que la
información esté protegida en la base de datos misma. La encriptación de datos es una
buena forma de mitigar esta amenaza.
PHP posee varias extensiones, como Mcrypt y Mhash, las cuales cubren una amplia
variedad de algoritmos de encriptación. El script encripta los datos antes de insertarlos en la
base de datos, y los desencripta cuando los recupera.
4.3.4. Uso de un campo de contraseñas encriptado
En el siguiente ejemplo se muestra básicamente como debería guardarse una contraseña
(encriptando) y como debería recuperarse de la base (desencriptando):
<?php
// almacenamiento de resumen criptográfico de la contraseña
$consulta = sprintf("INSERT INTO usuarios(nombre,contr)
VALUES('%s','%s');",
addslashes($nombre_usuario), md5($contraseña));
$resultado = pg_query($conexion, $consulta);
// consulta de verificación de la contraseña enviada
$consulta = sprintf("SELECT 1 FROM usuarios WHERE nombre='%s' AND
contr='%s';",
addslashes($nombre_usuario), md5($contraseña));
$resultado = pg_query($conexion, $consulta);
if (pg_num_rows($resultado) > 0) {
echo '&iexcl;Bienvenido, $nombre_usuario!';
}
else {
echo 'No pudo autenticarse a $nombre_usuario.';
}
?>
4.3.5. SQL Injection
Es una vulnerabilidad a nivel de validación de las entradas a la base de datos de una
aplicación. Esto
se debe al filtrado incorrecto de las variables utilizadas en un programa con código SQL.
4.4. Reporte de Errores
Una táctica de ataque típica involucra la acumulación de un perfil de datos del sistema
alimentándolo con datos inapropiados, y luego chequear los tipos de errores que son
devueltos, y sus contextos.
Esto permite que un cracker del sistema pueda adquirir información del servidor, para así
determinar posibles debilidades. Por ejemplo, si un atacante ha recogido información sobre
una página creada a partir de los datos de un formulario, podría intentar sobrescribir las
variables o modificarlas.
4.5. Uso de Register Globals
Quizás el cambio más controversial en la historia de PHP se ha dado cuando la directiva
register_globals pasó de tener como valor por defecto ON al valor OFF a partir de PHP
Hace que el GET, POST y COOKIE, las sesiones de variables y los archivos de upload
sean
accedidos directamente como variables globales en PHP.
4.5.1. Detección de envenenamiento simple de variables
Si se sabe previamente con exactitud el lugar de donde debería provenir una variable, puede
chequearse si los datos enviados provienen de una fuente inadecuada. Aunque esto no
garantiza que la información no haya sido falsificada, esto requiere que un ataque adivine el
medio apropiado para falsificar la información. Si no importa de dónde proviene la
información, se puede usar
$_REQUEST ya que allí se incluye una mezcla de variables que provienen de datos GET,
POST y
COOKIE.
<?php
if (isset($_COOKIE['COOKIE_MAGICA'])) {
// COOKIE_MAGICA proviene de una cookie.
// Asegurarse de validar los datos de la cookie!
} elseif (isset($_GET['COOKIE_MAGICA']) || isset($_POST['COOKIE_MAGICA'])) {
mail("admin@example.com", "Posible intento de intromisión",
$_SERVER['REMOTE_ADDR']);
echo "Violaci&oacute;n de seguridad, el administrador ha sido
alertado.";
exit;
} else {
// COOKIE_MAGICA no fue definida en este REQUEST
}
?>
Una buena solución es el uso de import_request_variables(), agrega un prefijo a todas las
variables importadas, elimina el factor de sobreescribir variables internas a través de
requests.
bool import_request_variables ( string tipos [, string prefijo] )
Importa las variables GET/POST/COOKIE en el contexto global. Es útil si se ha
deshabilitado
register_globals, pero se desea ver algunas variables en el contexto global.
4.6. Datos Enviados por el Usuario
Debe examinarse siempre y cuidadosamente su código para asegurar que cualquier variable
siendo enviada desde un navegador web sea chequeada apropiadamente
4.6.1. Variables Peligrosas
<?php
// eliminar un archivo del directorio personal del usuario .. o
// quizás de alguien mas?
unlink ($variable_malvada);
// Imprimir el registro del acceso... o quizás una entrada de /etc/passwd?
fwrite ($desc_archivo, $variable_malvada);
// Ejecutar algo trivial.. o rm -rf *?
system ($variable_malvada);
exec ($variable_malvada);
?>
Puede considerarse la deshabilitación de register_globals, magic_quotes u otros parámetros
convenientes que pueden causar confusión sobre la validez, fuente o valor de una
determinada
variable.
4.6.2. Magic Quotes
Las comillas mágicas (o "Magic Quotes"[Ref53] ) se refieren a un proceso que
automáticamente
escapa datos de entrada en los scripts de PHP. Es recomendable escribir código con las
comillas
mágicas deshabilitadas, y en su lugar escapar los datos en tiempo de ejecución, a medida
que se
necesite.
Cuando se habilitan, todos los caracteres ' (comilla sencilla), " (comilla doble), \ (barra
invertida) y
NULL se escapan con una barra invertida de forma automática. Esto es idéntico a lo que
hace
addslashes().
4.7. Migración desde PHP 4 a PHP 5
PHP4 está implementando en millones de aplicaciones y fue discontinuado en 2008 aunque
van a
seguir aplicando parches hasta agosto de ese mismo año.
Las nuevas aplicaciones se desarrollan en PHP5 pero la realidad muestra que las
aplicaciones que
están corriendo normalmente en PHP4 difícilmente migren a PHP5.[Ref65]
La desaparición completa de PHP4 entonces se vuelve menos real, incluso se estima que
varias
aplicaciones seguirán corriendo con PHP4 indefinidamente.
Estando tan próximos a una salida oficial de PHP6, se estima en 2009, la migración a PHP5
se torna
un poco más lenta todavía.
4.7.1. Cambios incompatibles
A continuación se listan algunos cambios incompatibles entre las dos versiones:
• Existen algunas palabras clave nuevas
• strrpos() y strripos() ahora usan la cadena string entera en la búsqueda .
• El uso de índices de cadena inválidos generan errores de tipo E_ERROR en lugar de
E_WARNING.
Un ejemplo de uso inválido es:
$cadena = 'abc';
unset($cadena[0]);.
4.7.2. Reporte de Errores
A partir de PHP 5, la nueva constante de reporte de errores E_STRICT se encuentra
disponible con el valor 2048. Ésta habilita sugerencias en tiempo de ejecución por parte de
PHP sobre la
interoperabilidad de su código y compatibilidad hacia adelante, que le ayudarán a
sincronizarse con los últimos y mejores métodos de escritura de código. Por ejemplo, un
mensaje STRICT puede
advertirle cuando use funciones obsoletas. Nota: E_ALL no incluye E_STRICT, así que
esta
constante no está habilitada por defecto.
4.7.3. register_globals y magic_quotes_gpc
En un intento para fomentar a los desarrolladores a adoptar buenas prácticas de
programación, en
PHP 5 register_globals y magic_quotes_gpc han sido deshabilitadas, cuando en PHP 4
estaban
habilitadas.
Combinaciones de register_globals y allow_url_open pueden causar graves riesgos de
seguridad

En este artículo vamos a explorar cómo puedes usar una base de datos MySQL para llevar a
cabo operaciones CRUD (crear, leer, actualizar y borrar, o create, read, update y delete en
inglés) con PHP. Si quieres ponerte a trabajar con conectividad de bases de datos en PHP,
este artículo es un gran punto de partida.
Si acabas de iniciar con PHP, probablemente te hayas dado cuenta de que la conectividad
de bases de datos es una característica esencial con la que necesitarás familiarizarte tarde o
temprano. En la mayoría de los casos, una base de datos es la columna vertebral de
cualquier aplicación web y contiene los datos de la misma. Por lo tanto, como desarrollador
de PHP necesitarás saber cómo tratar con las operaciones en la base de datos.

En este artículo mantendremos las cosas simples y exploraremos cómo usar las funciones
básicas de mysqli. En futuros artículos de esta serie, exploraremos un par de formas
diferentes para gestionar la conectividad de las bases de datos.

Hoy revisaremos los fundamentos de la conectividad de bases de datos en PHP, y usaremos

la base de datos MySQL como nuestro back-end de base de datos. Echemos un vistazo
rápido a lo que vamos a cubrir en este artículo:

 cómo crear una conexión a una base de datos

 cómo seleccionar una base de datos
 cómo insertar y actualizar registros
 cómo obtener registros
 cómo borrar registros

Vamos a suponer que tienes una instalación funcional de PHP y de MySQL, y que conoces
los fundamentos de MySQL. Además, debes asegurarte de que la extensión mysqli esté
habilitada en tu instalación de PHP, ya que la usaremos para llevar a cabo operaciones en la
base de datos MySQL.

Si no estás seguro de la extensión mysqli, puedes revisar usando la función phpinfo() . En

la salida de phpinfo() puedes verificar si hay una sección titulada mysqli. También
deberás ver el encabezado Mysqli Support | enabled (Soporte de Mysqli | habilitado) si la
extensión mysqli está habilitada.

También hay una manera fácil de verificar usando la interfaz CLI. Puedes ejecutar el
siguiente comando para mostrar todas las extensiones que estén habilitadas en tu instalación
de PHP.

1 $php -m
Este debe imprimir una lista de extensiones, y si contiene la palabra clave mysqli significa
que dicha extensión está habilitada.

Ahora que estamos listos, vamos a comenzar a crear una conexión a una base de datos.

Cómo establecer una conexión a una base de datos

Existen dos formas en las que puedes usar la extensión mysqli, que son por procedimientos
y orientada a objetos, pero usaremos la manera por procedimientos en esta publicación para
mantener las cosas simples.

Primero revisemos la sintaxis de la función mysqli_connect , que se usa para establecer

una conexión con el back-end de MySQL.

<?php
1
$connection_obj = mysqli_connect("{MYSQL_HOSTNAME}", "{MYSQL_USERNAME}", "{MYSQL
2
"{MYSQL_DATABASE}");
3
?>
La función mysqli_connect recibe cuatro argumentos y devuelve el objeto con la
conexión si la conexión tuvo éxito. Echemos un vistazo a cada argumento:

 MYSQL_HOSTNAME : Este debe ser sustituido con el nombre del host o la

dirección IP del servidor MySQL. Si estás trabajando con el servidor de MySQL en
tu sistema local, puedes usar localhost o 127.0.0.1 .
 MYSQL_USERNAME : El nombre de usuario de tu usuario de MySQL.
 MYSQL_PASSWORD : La contraseña de tu usuario de MySQL.
 MYSQL_DATABASE : La base de datos a la que quieras conectarte.

Después de logar una conexión exitosa, la variable $connection_obj contiene el objeto de

la conexión. Con este objeto estás listo para ejecutar consultas en la base de datos que fue
proporcionada en el argumento MYSQL_DATABASE .

Por otro lado, si la conexión no tiene éxito podemos ejecutar una depuración como se
muestra en el siguiente fragmento de código:

<?php
1
$connection_obj = mysqli_connect("{MYSQL_HOSTNAME}", "{MYSQL_USERNAME}", "{MYSQL
2
"{MYSQL_DATABASE}");
3
4
if (!$connection_obj) {
5
echo "Error No: " . mysqli_connect_errno();
6
echo "Error Description: " . mysqli_connect_error();
7
exit;
8
}
9
?>
En la siguiente sección veremos cómo puedes seleccionar una base de datos específica
usando el objeto de la conexión.
Cómo seleccionar una base de datos

En la sección anterior discutimos cómo establecer la conexión a una base de datos usando
la función mysqli_connec t. En esta sección veremos cómo seleccionar una base de datos
una vez que la conexión a MySQL haya sido exitosa.

Desde luego, como ya hemos visto siempre puedes enviar una base de datos en el cuarto
argumento de la propia función mysqli_connect . Pero también hay otra manera en la que
puedes hacer esto, en caso de que quieras cambiar una base de datos después de que te
hayas conectado a MySQL. Puedes usar la función mysqli_select_db para seleccionar una
base de datos con la que quieras trabajar.

Revisemos el ejemplo discutido en la sección anterior para ver cómo es que puede
funcionar.

<?php
01
$connection_obj = mysqli_connect("{MYSQL_HOSTNAME}",
02
"{MYSQL_USERNAME}", "{MYSQL_PASSWORD}");
03
04
if (!$connection_obj) {
05
echo "Error No: " . mysqli_connect_errno();
06
echo "Error Description: " . mysqli_connect_error();
07
exit;
08
}
09
10
mysqli_select_db($connection_obj, "{MYSQL_DATABASE}");
11
?>
Como puedes ver hemos enviado solamente tres argumentos en la
función mysqli_connect , y eso debe darnos una conexión exitosa a una base de datos. En
vez de enviar una base de datos en el cuarto argumento, seleccionamos la base de datos
usando la función mysqli_select_db .

La función mysqli_select_db recibe dos argumentos: el objeto de conexión y la base de

datos a la que quieras conectarte.

Advertisement

Cómo crear (insertar) y actualizar registros

En las secciones anteriores discutimos cómo establecer una conexión con MySQL y
seleccionar una base de datos para trabajar con ella. Ahora veremos cómo ejecutar
diferentes tipos de consultas en la base de datos seleccionada. Primero veamos cómo
insertar y actualizar registros.

Si quieres seguir los ejemplos discutidos en este artículo, necesitarás crear la siguiente tabla
de MySQL en tu base de datos. Es la tabla que vamos a usar en todos los ejemplos de ahora
en adelante.

1 CREATE TABLE `employee` (

2 `id` int(11) NOT NULL AUTO_INCREMENT,
3 `name` varchar(50) COLLATE utf8mb4_unicode_ci NOT NULL,
4 `email` varchar(50) COLLATE utf8mb4_unicode_ci NOT NULL,
5 `phone` varchar(50) COLLATE utf8mb4_unicode_ci NOT NULL,
6 PRIMARY KEY (`id`)
7 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
Ejecutar el comando anterior en tu base de datos de MySQL debe crear la tabla employee .

Cómo crear registros

Para mantener las cosas simples vamos a inicializar los valores que necesitan ser insertados
en la tabla employee al inicio de la secuencia de comandos. Sin embargo, en la mayoría de
los casos estos datos provienen de la entrada del usuario en las
variables $_POST enviadas usando un formulario.

01<?php
02$connection_obj = mysqli_connect("{MYSQL_HOSTNAME}",
03"{MYSQL_USERNAME}", "{MYSQL_PASSWORD}", "{MYSQL_DATABASE}");
04
05if (!$connection_obj) {
06 echo "Error No: " . mysqli_connect_errno();
07 echo "Error Description: " . mysqli_connect_error();
08 exit;
09}
10
11// initialize variables for the insert query
12$name = 'John Smith';
13$email = 'john.smith@yahoo.com';
14$phone = '541-754-1234';
15
16// prepare the insert query
17$query = "INSERT INTO employee(`name`,`email`, `phone`)
18VALUES ('". mysqli_real_escape_string($connection_obj, $name) ."','".
19mysqli_real_escape_string($connection_obj, $email) ."','".
20mysqli_real_escape_string($connection_obj, $phone) ."')";
21
22// run the insert query
23mysqli_query($connection_obj, $query);
24
// close the db connection
mysqli_close($connection_obj);
?>
En la secuencia de comandos anterior primero hemos inicializado las variables que vamos a
usar en la consulta insert. A continuación hemos preparado la consulta insert y la hemos
asignado a la variable $query .

Es importante destacar que hemos usado la función mysqli_real_escape_string para

escapar los valores de tipo cadena que vamos a usar en la consulta insert. Debes usar esta
función cuando estés trabajando con valores de tipo cadena enviados a través de
variables $_POST . Esto garantiza que tus usuarios no inyecten código malicioso en tus
consultas a la base de datos.

Finalmente, ejecutamos la consulta insert usando la función mysqli_query . La

función mysqli_query se usa para ejecutar una consulta en la base de datos activa. Para
terminar, usamos la función mysqli_close para cerrar la conexión activa.

Cómo actualizar registros

En la sección anterior discutimos cómo puedes insertar nuevos registros en la tabla de
MySQL. En esta sección veremos cómo puedes actualizar un registro que ya existe en la
tabla.

Voy a asumir que ya existe un registro en la tabla employee, y que el id de ese registro tiene
el valor 1. En el siguiente ejemplo vamos a actualizar un registro que tiene un valor de 1 en
la columna id.

01 <?php
02 $connection_obj = mysqli_connect("{MYSQL_HOSTNAME}", "{MYSQL_USERNAME}", "{MYSQ
03
04 if (!$connection_obj) {
05 echo "Error No: " . mysqli_connect_errno();
06 echo "Error Description: " . mysqli_connect_error();
07 exit;
08 }
09
10 // initialize variables for the insert query
11 $id = 1;
12 $phone = '333-555-4444';
13
14 // prepare the insert query
15 $query = "UPDATE employee SET `phone` = '". mysqli_real_escape_string($connection_obj, $phone)
16
17 // run the insert query
18 mysqli_query($connection_obj, $query);
19
20 // close the db connection
21 mysqli_close($connection_obj);
22 ?>
Como puedes ver en el ejemplo anterior, queremos actualizar la columna phone de la
tabla employee en donde id es igual a 1. Esto es muy similar a la consulta insert, pero
estamos usando UPDATE en vez de INSERT .

Cómo obtener registros

Hasta ahora hemos discutido cómo insertar y actualizar registros en la tabla de MySQL. En
esta sección veremos cómo obtener (recuperar) registros de la tabla de MySQL.

Echa un vistazo al siguiente ejemplo:

01 <?php
02 $connection_obj = mysqli_connect("{MYSQL_HOSTNAME}", "{MYSQL_USERNAME}", "{MYSQ
03 "{MYSQL_DATABASE}");
04
05 if (!$connection_obj) {
06 echo "Error No: " . mysqli_connect_errno();
07 echo "Error Description: " . mysqli_connect_error();
08 exit;
09 }
10
11 // prepare the select query
12 $query = "SELECT * FROM employee";
13
14 // execute the select query
15 $result = mysqli_query($connection_obj, $query) or die(mysqli_error($connection_obj));
16
17 // run the select query
18 while ($row = mysqli_fetch_array($result, MYSQLI_BOTH)) {
19 echo "ID:" . $row['id'] . "<br/>";
20 echo "Name:" . $row['name'] . "<br/>";
21 echo "Phone:" . $row['phone'] . "<br/>";
22 echo "Email:" . $row['email'] . "<br/>";
23 echo "<br/>";
24 }
25
26 // close the db connection
27 mysqli_close($connection_obj);
?>
Lo primero que debes hacer para recuperar registros de una base de datos es ejecutar la
consulta select usando la función mysqli_query . Después de haber ejecutado con éxito la
consulta select, la función mysqli_query devuelve el objeto mysqli result , y eso es lo que
hemos almacenado arriba en la variable $result .

A continuación recorremos el conjunto de resultados usando la

función mysqli_fetch_array en un bucle while. La función mysqli_fetch_array obtiene
una sola fila a la vez del conjunto de mysqli result.

La función mysqli_fetch_array recibe dos argumentos: el objeto de los resultados y el tipo

de los resultados. El tipo indica qué tipo de arreglo será devuelto por la
función mysqli_fetch_array . Puede ser numérico, asociativo o ambos. Es un argumento
opcional, y puedes enviar uno de estos tres
valores: MYSQLI_ASSOC , MYSQLI_NUM o MYSQLI_BOTH . MYSQLI_ASSOC
indica que quieres acceder a las columnas por sus nombres, y MYSQLI_NUM indica que
quieres acceder a las columnas por sus números.

Si envías el valor MYSQLI_NUM en el segundo argumento de la

función mysqli_fetch_array , puedes acceder a las columnas como $row[0] , $row[1] y
así sucesivamente. En nuestro caso hemos enviado el valor MYSQLI_BOTH , de manera
que podemos acceder a las columnas de las dos formas. Si quieres acceder solamente con
valores asociativos, en vez de esto puedes usar la función mysqli_fetch_assoc .

En la siguiente y última sección veremos cómo borrar registros de una base de datos.

Cómo borrar registros

En esta sección veremos cómo borrar registros de una base de datos.

Revisa el siguiente ejemplo.

<?php
01
$connection_obj = mysqli_connect("{MYSQL_HOSTNAME}", "{MYSQL_USERNAME}", "{MYSQ
02
"{MYSQL_DATABASE}");
03
04
if (!$connection_obj) {
05
echo "Error No: " . mysqli_connect_errno();
06
echo "Error Description: " . mysqli_connect_error();
07
exit;
08
}
09
10
// initialize variables for the delete query
11
$id = 1;
12
13
// prepare the insert query
14
$query = "DELETE FROM employee WHERE `id` = '". (int) $id ."'";
15
16
// run the delete query
17
mysqli_query($connection_obj, $query);
18
19
// close the db connection
20
mysqli_close($connection_obj);
21
?>
Como puedes ver, funciona básicamente de la misma manera en la que lo hacen las
consultas insert y update. La función mysqli_query ejecuta la consulta DELETE , y esta
eventualmente elimina el registro de la tabla employee .

Seleccionar datos de una base de datos

MySQL
La instrucción SELECT se usa para seleccionar datos de una o más tablas:

SELECT column_name(s) FROM table_name

o podemos usar el carácter * para seleccionar TODAS las columnas de una

tabla:

SELECT * FROM table_name

Para obtener más información sobre SQL, visite nuestro tutorial de SQL .
Seleccionar datos con MySQLi
El siguiente ejemplo selecciona las columnas id, nombre y apellido de la
tabla MyGuests y lo muestra en la página:

Ejemplo (orientado a objetos MySQLi)

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";

// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);
// Check connection
if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
}

$sql = "SELECT id, firstname, lastname FROM MyGuests";

$result = $conn->query($sql);

if ($result->num_rows > 0) {
// output data of each row
while($row = $result->fetch_assoc()) {
echo "id: " . $row["id"]. " - Name: " . $row["firstname"]. "
" . $row["lastname"]. "<br>";
}
} else {
echo "0 results";
}
$conn->close();
?>

Ejecutar ejemplo »

Líneas de código para explicar del ejemplo anterior:

Primero, configuramos una consulta SQL que selecciona las columnas id,
firstname y lastname de la tabla MyGuests. La siguiente línea de código
ejecuta la consulta y coloca los datos resultantes en una variable llamada $
result.

Luego, la function num_rows() verifica si hay más de cero filas devueltas.

Si se devuelven más de cero filas, la función fetch_assoc() coloca todos los

resultados en una matriz asociativa que podemos recorrer. El ciclo
while while() recorre el conjunto de resultados y genera los datos de las
columnas id, firstname y lastname.

El siguiente ejemplo muestra lo mismo que el ejemplo anterior, en la forma

de procedimiento MySQLi:

Ejemplo (procedimiento de MySQLi)

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";

// Create connection
$conn = mysqli_connect($servername, $username, $password, $dbname);
// Check connection
if (!$conn) {
die("Connection failed: " . mysqli_connect_error());
}

$sql = "SELECT id, firstname, lastname FROM MyGuests";

$result = mysqli_query($conn, $sql);

if (mysqli_num_rows($result) > 0) {
// output data of each row
while($row = mysqli_fetch_assoc($result)) {
echo "id: " . $row["id"]. " - Name: " . $row["firstname"]. "
" . $row["lastname"]. "<br>";
}
} else {
echo "0 results";
}

mysqli_close($conn);
?>

Ejecutar ejemplo »
También puede poner el resultado en una tabla HTML:

Ejemplo (orientado a objetos MySQLi)

<?php
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";

// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);
// Check connection
if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
}

$sql = "SELECT id, firstname, lastname FROM MyGuests";

$result = $conn->query($sql);

if ($result->num_rows > 0) {
echo "<table><tr><th>ID</th><th>Name</th></tr>";
// output data of each row
while($row = $result->fetch_assoc()) {
echo "<tr><td>".$row["id"]."</td><td>".$row["firstname"]."
".$row["lastname"]."</td></tr>";
}
echo "</table>";
} else {
echo "0 results";
}
$conn->close();
?>

Ejecutar ejemplo »
Seleccionar datos con PDO (+
declaraciones preparadas)
El siguiente ejemplo utiliza declaraciones preparadas.

Selecciona las columnas id, firstname y lastname de la tabla MyGuests y la

muestra en una tabla HTML:

Ejemplo (PDO)
<?php
echo "<table style='border: solid 1px black;'>";
echo "<tr><th>Id</th><th>Firstname</th><th>Lastname</th></tr>";

class TableRows extends RecursiveIteratorIterator {

function __construct($it) {
parent::__construct($it, self::LEAVES_ONLY);
}

function current() {
return "<td style='width:150px;border:1px solid black;'>" .
parent::current(). "</td>";
}

function beginChildren() {
echo "<tr>";
}

function endChildren() {
echo "</tr>" . "\n";
}
}

$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDBPDO";

try {
$conn = new PDO("mysql:host=$servername;dbname=$dbname",
$username, $password);
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 $stmt = $conn->prepare("SELECT id, firstname, lastname FROM
MyGuests");
$stmt->execute();

// set the resulting array to associative

$result = $stmt->setFetchMode(PDO::FETCH_ASSOC);
foreach(new TableRows(new RecursiveArrayIterator($stmt-
>fetchAll())) as $k=>$v) {
echo $v;
}
}
catch(PDOException $e) {
echo "Error: " . $e->getMessage();
}
$conn = null;
echo "</table>";
?>