Trabajo seguro con base de datos mysql. Soporte de bases de datos en PHP. Eliminar registros de la base de datos
Llamé a mi base de datos "phptest". Después de hacer clic en el botón "Crear", debería ser transferido automáticamente a la base de datos que creó.
Crear una tabla en la base de datos.
Tampoco hay nada complicado en este procedimiento. Creemos una tabla en la que almacenaremos el título de nuestros artículos y el texto en sí:
Como habrás notado, puse el número 3 en el número de campos, ¿por qué? Después de todo, necesitamos crear dos campos, uno para el título y otro para el texto. El punto es que una tabla en la base de datos debe tener un campo adicional.¿Para qué? Este campo representa la alternativa número de identificación, (es decir, parece que contamos nuestras filas en la tabla) de esta manera obtenemos cada fila de la tabla su propio número único. Esto será útil para encontrar la cadena que necesitamos en la base de datos. Este campo generalmente se llama id y se establece en él. AUTO_INCREMENT(Les mostraré a continuación dónde se exhibe). AUTO_INCREMENT le permite asignar a cada línea su propio número único, por lo que no encontrará un registro con el mismo número en la tabla de la base de datos.
Después de completar el nombre y la cantidad de campos, haga clic en "Aceptar" y accederá a la página de creación de campos. Les confieso que no entiendo muy bien lo que hago al crear campos, pero eso no me impide trabajar con ellos, rellenémoslo así:
Y complete los dos campos que necesitamos:
¿Por qué sólo dos? Porque el primer campo de identificación se completará automáticamente debido a AUTO_INCREMENT. Haga clic en "Aceptar". Ahora, en la pestaña "Descripción general", puede ver la línea que creamos en la tabla:
Bueno, hemos aprendido cómo crear tablas y filas a través del panel phpmyadmin, esto ya es un progreso. Por cierto, me gustaría señalar que la interfaz de este panel es intuitiva, puedes presionar fácilmente los botones allí y descubrir qué hay. qué
Es hora de aprender a crear, eliminar y actualizar filas en tablas creadas usando PHP. Para que puedas percibir mejor lo que te estoy contando, escribiremos un pequeño panel de administración para el sitio y, a medida que vayan las cosas, te diré qué y cómo.
Salida de registros de la base de datos
Comencemos con esto, ya que al crear cualquier proyecto es necesario ver claramente el proceso, y sin resultado es muy difícil hacerlo (trabajaré con el archivo test.php, no se sorprenda cuando vea enlaces en el código a este archivo). ¿Cómo nos retiraremos? Bueno, primero necesitamos conectarnos a la base de datos, después de usar el bucle do while (Aprendizaje PHP - Bucles) recuperaremos registros de la base de datos. Empecemos
Conexión a la base de datos
¿Cómo se hace la conexión? Atención a la sintaxis:
mysql_select_db(Nombre de la base de datos, mysql_connect(Servidor, nombre de usuario de la base de datos, contraseña de usuario de la base de datos));
El nombre de la base de datos, el usuario del servidor y la contraseña los crea usted o los proporciona su proveedor de alojamiento. Usando el ejemplo servidor local, usted mismo crea algunos datos o utiliza los ya creados. Así es como se verán las conexiones a la base de datos que creé:
//CONECTARSE A LA BASE DE DATOS (DB)
El servidor, usuario y contraseña fueron creados por defecto (en en este caso podemos decir que casi todos los datos nos los proporciona el hosting). De mis datos solo indiqué el nombre de la base de datos. Por cierto, esto codigo php, y por lo tanto debe estar entre paréntesis especiales ()
Salida de datos
Necesitamos mostrar datos de la tabla de páginas. Preste atención a la sintaxis de salida:
$resultado = mysql_query("SELECCIONAR lo que extraemos DEL nombre de la tabla en la base de datos");
La primera línea nos permite especificar qué columnas necesitamos extraer y de qué base de datos.
La segunda línea pone todo lo encontrado en una variable...
ATENCIÓN Hay un par de puntos que me gustaría aclarar. Resolvamos algunos problemas:
- Necesitamos extraer todos los campos de la tabla.
¿Cómo extraer todos los campos de la tabla de páginas? como esto:
$resultado = mysql_query("SELECCIONAR * DE la página");
$mifila = mysql_fetch_array($resultado);
Quizás hayas notado que puse un asterisco (*) después de SELECT. El asterisco significa que necesito extraer todos los campos de la tabla
- Necesitamos extraer solo un campo de la tabla.
¿Cómo extraer solo el campo de texto de una tabla? como esto:
$resultado = mysql_query("SELECCIONAR texto DE la página");
$mifila = mysql_fetch_array($resultado);
Para extraer no todos los campos, sino solo algunos, debe enumerar los campos obligatorios después de SELECCIONAR, separados por comas.
- Necesitamos extraer campos no de toda la tabla, sino solo de una línea.
¿Cómo extraer todos los campos de la primera línea? Sabemos que la primera línea tiene una identificación. igual a uno, usemos este conocimiento:
Después de SELECCIONAR, expliqué, separados por comas, qué campos debían extraerse y luego agregué nueva linea DONDE (que significa "dónde") la identificación es igual a 1. Por lo tanto, saco los campos que necesito de la línea donde la identificación es igual a uno
Bueno, ¿comencemos a crear el resultado de nuestros artículos? Mostraremos solo los encabezados, comencemos:
$mifila = mysql_fetch_array($resultado);
hacer
{
echo "".$mifila."
";
}
¿Qué hemos hecho? Sacamos dos campos de la tabla, id y título. A continuación, lanzamos un bucle do while (Aprendizaje PHP - Ciclos) y creamos enlaces utilizando los datos que se extrajeron de la base de datos. Los datos se almacenan en la variable $myrow, esta variable es una matriz, las claves de la matriz son los nombres de nuestros campos en la base de datos. Esto es lo que pasó:
Los encabezados están impresos, ahora organicemos el resultado. mensajes completos cuando haces clic en un enlace con un título. Para hacer esto en un archivo, agregue condiciones if()():
//CONECTARSE A LA BASE DE DATOS (DB)
$nameDB = "phptest";//Nombre de la base de datos
$nombreSERVER = "localhost";//Servidor
$nameUSER = "root";//Nombre de usuario de la base de datos
$passUSER = "";//Contraseña de usuario de base de datos
mysql_select_db($nameDB, mysql_connect($nameSERVER,$nameUSER,$passUSER));
//CONECTARSE A LA BASE DE DATOS (DB)
//ENCABEZADOS DE SALIDA
si(!isset($_GET["id"]))
{
$resultado = mysql_query("SELECCIONAR id,título DE la página");
$mifila = mysql_fetch_array($resultado);
hacer
{
echo "".$mifila."
";
}
mientras ($myrow = mysql_fetch_array($resultado));
}
//ENCABEZADOS DE SALIDA
//SALIR TEXTO COMPLETO
si(isset($_GET["id"]))
{
$mifila = mysql_fetch_array($resultado);
echo $mifila;
}
//SALIR TEXTO COMPLETO
?>
Agregué dos condiciones. Veremos una lista con encabezados solo si la variable global $_GET["id"] no existe. Veremos el texto completo sólo si esta variable existe. En este caso, mostraremos solo un registro que necesitamos de la base de datos. Esto es lo que tenemos:
Ahora creo que es hora de aprender a agregar nuevas filas a la tabla.
Agregar datos a la base de datos
Comencemos a agregar creando un formulario, aquí hay un fragmento de código que debe agregarse al final de nuestro archivo:
//FORMULARIO AGREGAR ENTRADAS
si(isset($_GET["agregar"]))
{
eco "
}
//FORMULARIO AGREGAR ENTRADAS
Este formulario aparecerá sólo si existe la variable global $_GET["add"], por lo que en algún lugar de la parte inferior deberá insertar un enlace para agregar nuevo articulo. Esto se hace mejor en el código de salida del encabezado; también puede editar la condición para generar nuestros encabezados de esta manera:
//ENCABEZADOS DE SALIDA
if(!isset($_GET["id"]) Y !isset($_GET["add"]))
{
$resultado = mysql_query("SELECCIONAR id,título DE la página");
$mifila = mysql_fetch_array($resultado);
hacer
{
echo "".$mifila."
";
}
mientras ($myrow = mysql_fetch_array($resultado));
eco "
Agregar publicación";
}
//ENCABEZADOS DE SALIDA
Edité la condición para que la lista de encabezados no apareciera cuando se muestre el formulario, esto es lo que sucedió:
$resultado = mysql_query("INSERT INTO nombre de la tabla en la base de datos (campo 1 de la base de datos, campo 2 de la base de datos) VALORES ("datos 1", "datos 2")");
Ahora escribamos un controlador para nuestro mini panel de administración y comprenderá todo. Aquí hay un fragmento de código que publiqué justo después de conectarme a la base de datos:
//AGREGAR ENTRADAS
{
encabezado("ubicación: prueba.php");
salida;
}
//AGREGAR ENTRADAS
La condición es la variable global $_POST, es decir, si completamos el formulario y pulsamos en el botón “Agregar publicación”, nuestra condición funcionará. El campo de título contendrá datos de la variable global $_POST y el campo de texto contendrá $_POST. A continuación, funcionará el encabezado de línea ("ubicación: test.php"). Le permite redirigir al usuario a otra página, en este caso esta página será test.php. Y la línea de salida; interrumpe la ejecución de otros scripts. Esto es lo que pasó:
Editar datos en la base de datos.
Para poder editar entrada especifica en nuestra base de datos, naturalmente necesitamos determinar qué registro necesita ser editado... Sugiero mostrar el botón editar en el código de salida texto completo, editémoslo:
//SALIR TEXTO COMPLETO
si(isset($_GET["id"]))
{
$resultado = mysql_query("SELECCIONE el texto DE la página DONDE id="$_GET"");
$mifila = mysql_fetch_array($resultado);
echo $mifila;
eco "
Editar publicación";
}
//SALIR TEXTO COMPLETO
si(isset($_GET["edd"]))
{
$mifila = mysql_fetch_array($resultado);
Eco"
}
// ENTRADAS DE EDICIÓN DE FORMULARIO
Agregué este fragmento de código después del formulario para agregar registros. Este formulario es casi similar al formulario para agregar publicaciones. Como habrás notado, lo rehice atributos de nombre y agregó el atributo de valor. En este atributo coloqué los datos que recuperé de la base de datos. También hay aquí un campo invisible. Es necesario enviar el identificador del registro al administrador del archivo.
Ahora, para asegurarnos de que no haya una lista de encabezados en la pantalla cuando se muestre este formulario, corrijamos la condición:
//ENCABEZADOS DE SALIDA
{
$resultado = mysql_query("SELECCIONAR id,título DE la página");
$mifila = mysql_fetch_array($resultado);
hacer
{
echo "".$mifila."
";
}
mientras ($myrow = mysql_fetch_array($resultado));
eco "
Agregar publicación";
}
//ENCABEZADOS DE SALIDA
Es hora de aprender cómo se editan los registros de la base de datos. Aquí está la sintaxis:
Ahora escribamos un controlador. Aquí hay un fragmento de código que agregué inmediatamente después del controlador para agregar registros:
//EDITAR ENTRADAS
{
encabezado("ubicación: prueba.php");
salida;
}
//EDITAR ENTRADAS
La condición muestra que el controlador solo se ejecutará si hacemos clic en el botón "editar publicación". Próximo actualización en progreso bases de datos. En el campo de título colocaremos el valor de la variable global $_POST y en el campo de texto - $_POST. Editaremos la línea cuyo id sea igual a la variable global $_POST. Luego redirigimos al usuario a la lista de encabezados:
Eliminar registros de la base de datos
Bueno, lo último que nos queda por estudiar es el borrado. Es más sencillo que todos los demás, así que presta atención a la sintaxis:
Para eliminar algunas publicaciones, necesita colocar un enlace en algún lugar con el cual el usuario pueda eliminar alguna publicación... coloquemos este enlace en la salida del texto completo de la publicación:
//SALIR TEXTO COMPLETO
si(isset($_GET["id"]))
{
$resultado = mysql_query("SELECCIONE el texto DE la página DONDE id="$_GET"");
$mifila = mysql_fetch_array($resultado);
echo $mifila;
eco "
Editar publicación";
eco "
Eliminar publicación";
}
//SALIR TEXTO COMPLETO
resultado del trabajo
Aquí código completo la publicación de hoy:
//CONECTARSE A LA BASE DE DATOS (DB)
$nameDB = "phptest";//Nombre de la base de datos
$nombreSERVER = "localhost";//Servidor
$nameUSER = "root";//Nombre de usuario de la base de datos
$passUSER = "";//Contraseña de usuario de base de datos
mysql_select_db($nameDB, mysql_connect($nameSERVER,$nameUSER,$passUSER));
//CONECTARSE A LA BASE DE DATOS (DB)
//AGREGAR ENTRADAS
if(isset($_POST["title_post"]) AND isset($_POST["text_post"]))
{
$resultado = mysql_query("INSERT INTO page (title,text) VALUES ("$_POST","$_POST")");
encabezado("ubicación: prueba.php");
salida;
}
//AGREGAR ENTRADAS
//EDITAR ENTRADAS
if(isset($_POST["title_post_edd"]) AND isset($_POST["text_post_edd"]))
{
$resultado = mysql_query("ACTUALIZAR página SET título="$_POST", text="$_POST" WHERE id="$_POST"");!}
encabezado("ubicación: prueba.php");
salida;
}
//EDITAR ENTRADAS
//BORRAR ENTRADAS
si(isset($_GET["del"]))
{
$resultado = mysql_query("BORRAR DE la página DONDE id="$_GET"");
encabezado("ubicación: prueba.php");
salida;
}
//BORRAR ENTRADAS
//ENCABEZADOS DE SALIDA
if(!isset($_GET["id"]) AND !isset($_GET["add"]) AND !isset($_GET["edd"]))
{
$resultado = mysql_query("SELECCIONAR id,título DE la página");
$mifila = mysql_fetch_array($resultado);
hacer
{
echo "".$mifila."
";
}
mientras ($myrow = mysql_fetch_array($resultado));
eco "
Agregar publicación";
}
//ENCABEZADOS DE SALIDA
//SALIR TEXTO COMPLETO
si(isset($_GET["id"]))
{
$resultado = mysql_query("SELECCIONE el texto DE la página DONDE id="$_GET"");
$mifila = mysql_fetch_array($resultado);
echo $mifila;
eco "
Editar publicación";
eco "
Eliminar publicación";
}
//SALIR TEXTO COMPLETO
//FORMULARIO AGREGAR ENTRADAS
si(isset($_GET["agregar"]))
{
eco "
}
//FORMULARIO AGREGAR ENTRADAS
// ENTRADAS DE EDICIÓN DE FORMULARIO
si(isset($_GET["edd"]))
{
$resultado = mysql_query("SELECCIONAR * DE la página DONDE id="$_GET"");
$mifila = mysql_fetch_array($resultado);
Eco"
}
// ENTRADAS DE EDICIÓN DE FORMULARIO
?>
Conclusión
El material resultó bastante complejo. ¡Pero! Quizás hayas notado que solo utilicé la información que proporcioné anteriormente. ¡Esto significa que con este conocimiento, puedes crear proyectos simples en PHP! Si dominas todo esto, ¡puedes decir con orgullo que eres un programador novato! Bueno, ahora puedes empezar a crear tus primeros cms. Si tienes alguna pregunta, y lo más probable es que la tengas, pregunta, ¡te ayudaré en todo lo que pueda! ¡Buena suerte, eso es todo por hoy!
P.D.: ¿Qué es un archivo mdf? ¿Cómo abrirlo? ¿Cómo abrirlo? Estas y muchas preguntas pueden responderse en voprosi4ek.ru
En este artículo veremos formas de acceder a las tablas de la base de datos MySQL utilizando el lenguaje de consulta SQL. SQL es un acrónimo que se denomina "lenguaje de consulta estructurado".
En el lenguaje PHP existen una serie de funciones con el prefijo "mysql" para este fin. No necesitaremos muchos de ellos para procesar solicitudes. Una función sin la cual el lenguaje Ejecución PHP Las consultas SQL serían simplemente imposibles:
Recurso mysql_query(consulta)
Esta función envía una solicitud a la base de datos y devuelve el identificador del recurso si la solicitud tiene éxito.
Para conectarse a la base de datos datos mysql se debe realizar la siguiente secuencia:
$host="localhost"; // nombre de host (a confirmar con el proveedor) $database="db_name"; // nombre de la base de datos que debes crear $user="user_name"; // nombre de usuario especificado por usted o definido por el proveedor $pswd="your_pass"; // la contraseña que especificaste $dbh = mysql_connect($host, $user, $pswd) o die("No se puede conectar a MySQL."); mysql_select_db($database) o die("No puedo conectarme a la base de datos.");
Entonces mysql_conectar()- una función para conectarse a un servidor MySQL en su hosting.
A mysql_select_db() selecciona una base de datos en el servidor para conectarse.
Es decir, nos conectamos al servidor, seleccionamos una base de datos y comenzamos a trabajar.
La función die() se llama cuando ocurre un error y muestra el mensaje que especificó en la ventana del navegador.
Para terminar de trabajar con bases de datos, use la función:
Mysql_close($dbh);
Aquí $dbh- descriptor que fue devuelto por la función al conectarse conexión_mysql.
Habiendo terminado la revisión inicial, comencemos a observar las consultas SQL reales.
Para hacer esto, primero necesita crear una base de datos con un nombre específico. Y crea una tabla en ella, también con un nombre específico. En nuestros ejemplos nos referiremos a la tabla. mi_sql_table. Para crear esta tabla, ejecutemos la siguiente consulta en phpmyadmin de nuestro localhost:
CREAR TABLA `my_sql_table` (`id` INT NOT NULL , // identificador de futuros registros de la tabla `firstname` VARCHAR(50) NOT NULL , // campo de texto VARCHAR `apellido` VARCHAR(50) NOT NULL , // longitud máxima 50 caracteres CLAVE PRIMARIA (`id`) // clave primaria- identificador de identificación);
Entonces se ha creado la tabla. Ejecutemos la primera solicitud, que inmediatamente formatearemos en forma de código PHP:
\n"; echo "Nombre: ".$fila["nombre"]."
\n"; echo "Apellido: ".$fila["apellido"]."
\n"; )?>
Analicemos el código PHP del archivo. primersql.php. Comencemos con la consulta real a las tablas de la base de datos.
$consulta = "SELECCIONAR * DESDE `my_sql_table`";
Esta consulta se puede descifrar de la siguiente manera: seleccionar de la tabla mi_sql_table DB todos los registros de todos los campos. esta manera firmar * después de la palabra SELECT significa “seleccionar absolutamente todo”. Entonces, la solicitud ha sido creada. Ahora necesitas ejecutarlo:
$res = mysql_query($consulta);
Si la solicitud tiene éxito, la función consulta_mysql() nos devolverá el ID del recurso $ res.
Debemos pasarlo como parámetro a la función. mysql_fetch_array(). El nombre de esta función habla por sí solo. Aquellos. forma y genera una matriz basada en una muestra de la tabla de la base de datos. En el caso de nuestra tabla, la matriz constará de una cantidad de elementos igual a la cantidad de registros (filas) de la tabla y contendrá valores. identificación, nombre, apellido para cada fila de la tabla. De ahí el siguiente código:
Mientras($fila = mysql_fetch_array($res)) ( echo "Número: ".$fila["id"]."
\n"; echo "Nombre:".$fila["nombre"]."
\n"; echo "Apellido:".$fila["apellido"]."
\n"; )
se puede comentar así: mientras la variable que introdujimos $row no recibe cero resultados operación de función mysql_fetch_row debes enviar los valores de los campos al navegador $fila["id"], $fila["nombre"], $fila["apellido"] usando eco.
Si la solicitud se ejecuta así:
$consulta = "SELECCIONAR nombre DE `my_sql_table`";
entonces esto significará que de todas las filas solo se seleccionan los valores del campo nombre.
Por lo tanto, el código anterior debería reescribirse como:
$res = mysql_query($consulta); while($fila = mysql_fetch_array($res)) ( echo "Nombre:".$fila["nombre"]."
\n"; )
Si desea seleccionar filas de la tabla con un valor específico identificación donde estará el apellido petrov, entonces la solicitud se reescribirá de la siguiente manera:
$consulta = "SELECCIONAR ID DE `my_sql_table` donde apellido="Petrov"";
Pero si necesita averiguar el apellido de la persona que tiene el número, por ejemplo 5, la solicitud será la siguiente:
$consulta = "SELECCIONE apellido DE `my_sql_table` donde id=5";
En este caso, sabe que el resultado de la consulta estará solo en una fila de la tabla. Aquellos. no tiene sentido organizar un bucle usando mientras. Y el procesamiento de la solicitud será el siguiente
$res = mysql_query($consulta); $fila = mysql_fetch_row($res); echo "El apellido de la quinta persona de la lista es ".$row."\n";
Aquí, en lugar de mysql_fetch_array() usamos mysql_fetch_row(). Aquellos. obtener el valor de un campo (o campos) línea específica. Como teníamos un campo, apellido, podemos referirnos al único elemento de la matriz $row como $fila;.
Entonces, veamos los ejemplos más típicos de consultas MySQL. Realizaremos la revisión basándonos en la tabla. mi_sql_table:
1. Agregue un campo middle_name (segundo nombre) a la tabla my_sql_table después apellido:
$consulta = "ALTERAR TABLA `my_sql_table` AGREGAR `segundo_nombre`
VARCHAR(50) NOT NULL DESPUÉS de `apellido`";
2. Ahora eliminemos el campo apellido de la tabla my_sql_table:
$consulta = "ALTER TABLE `my_sql_table` DROP `apellido`";
3. Elimine los registros de la tabla my_sql_table con el apellido Sidorov:
$consulta = "BORRAR DE `my_sql_table` donde apellido="Sidorov"";
4. Además de los signos iguales, también “más que” o “menor que”, en lenguaje MySQL consultas hay un concepto " parece". Seleccionemos registros de la tabla my_sql_table donde contiene el apellido " insecto" :
$query = "SELECT * FROM `my_sql_table` donde el apellido es como "%dor%"";
Aquí la presencia " %
" al principio y al final de "dor" y significa que la consulta buscará exactamente "dor", y no importa si está al principio, al final o en la mitad del apellido. Considere el siguiente ejemplo
5. Seleccione registros de la tabla my_sql_table con un apellido que comience con PAG. Tenga en cuenta la ubicación " %
":
$query = "SELECT * FROM `my_sql_table` donde el apellido es como "P%"";
6. Calculemos valor máximo identificación:
$consulta = "SELECCIONAR MAX(id) DE `my_sql_table`";
7. Calcule la cantidad de campos en my_sql_table con un apellido que comienza con PAG.
$query = "SELECT COUNT(*) FROM `my_sql_table` donde el apellido es como "P%"";
8. Eliminando la tabla my_sql_table:
$consulta = "DROP TABLE `my_sql_table`";
Para las consultas 1 a 3 en PHP, simplemente ejecute la consulta:
Mysql_query($consulta);
Analizamos los ejemplos más típicos de solicitudes. Creo que con su ayuda, siguiendo la lógica elemental, podrás realizar más consultas complejas a las tablas de la base de datos MySQL que creó.
| Si tiene alguna otra pregunta o algo no está claro, bienvenido a nuestro | |
|
|
Medio almacenamiento eficiente y la recuperación de grandes cantidades de información han contribuido enormemente al exitoso desarrollo de Internet. Normalmente las bases de datos se utilizan para almacenar información. El funcionamiento de sitios conocidos como Yahoo, Amazon y Ebay depende en gran medida de la confiabilidad de las bases de datos que almacenan enormes cantidades de información. Por supuesto, el soporte de bases de datos no es sólo para beneficio de las corporaciones gigantes: los programadores web tienen varias implementaciones de bases de datos poderosas a su disposición, distribuidas a un costo relativamente bajo (o incluso gratis).
La organización adecuada de la base de datos proporciona capacidades de recuperación de datos más rápidas y flexibles. Simplifica enormemente la implementación de herramientas de búsqueda y clasificación, y los problemas de derechos de acceso a la información se resuelven utilizando controles de privilegios que se encuentran en muchos sistemas de gestión de bases de datos (DBMS). Además, se simplifican los procesos de replicación y archivo de datos.
El capítulo comienza con descripción detallada buscar y actualizar datos en MySQL, probablemente el DBMS más popular utilizado en PHP (http://www.mysql.com). En Ejemplo de MySQL se mostrará cómo se cargan y actualizan los datos de la base de datos en PHP; Veremos las herramientas básicas de búsqueda y clasificación utilizadas en muchas aplicaciones web. Luego pasaremos al soporte de PHP para ODBC (Conectividad de base de datos abierta), una interfaz genérica que se puede utilizar para conexión simultánea con diferentes DBMS. Se demostrará la compatibilidad con ODBC en PHP utilizando el ejemplo de conexión y recuperación de datos de una base de datos. datos de microsoft Acceso. El capítulo concluye con un proyecto que utiliza PHP y MySQL para crear un directorio jerárquico que contiene información sobre sitios favoritos. Al agregar nuevos sitios al catálogo, el usuario los asigna a una de las categorías estándar definidas por el administrador del sitio.
Antes de hablar de MySQL, quiero decir algunas palabras sobre SQL, el lenguaje más común para trabajar con bases de datos. lenguaje SQL es la base de casi todos SGBD existentes. Para pasar a ver ejemplos de cómo trabajar con bases de datos, debe tener al menos una comprensión general de cómo funciona SQL.
¿Qué es SQL?
SQL generalmente se describe como el lenguaje estándar utilizado para interactuar con bases de datos relacionales (ver más abajo). Sin embargo, SQL no es un lenguaje de programación como C, C++ o PHP. Más bien, es una herramienta de interfaz para realizar diversas operaciones de bases de datos, proporcionando al usuario conjunto estándar comandos Las capacidades de SQL no se limitan a recuperar datos de una base de datos. SQL admite una variedad de opciones para interactuar con una base de datos, que incluyen:
- definición de estructura de datos
Tenga en cuenta: en definición SQL se dijo que este lenguaje está diseñado para trabajar con relacional bases de datos. En los DBMS relacionales, los datos se organizan como un conjunto de tablas interconectadas. Las relaciones entre tablas se implementan en forma de enlaces a datos de otras tablas. Mesa Puede considerarse como una matriz bidimensional en la que la ubicación de cada elemento se caracteriza por valores específicos de fila y columna. Ejemplo base relacional los datos se muestran en la Fig. 11.1.
Arroz. 11.1. Ejemplo de base de datos relacional
Como se puede ver en la Fig. 11.1, cada tabla consta de filas (registros) y columnas (campos). A cada campo se le asigna un nombre único (dentro de la tabla). Observe la relación entre las tablas de clientes y pedidos, indicada por una flecha. Se incluye un breve identificador de cliente en la información del pedido, lo que evita el almacenamiento redundante del nombre del cliente y otros detalles. Hay una relación más en la base de datos que se muestra: entre las tablas de pedidos y productos. Esta conexión se establece mediante el campo prod_id, que almacena el identificador del producto solicitado por este cliente (definido por el campo custjd). Tener estas conexiones facilita la referencia a datos completos de clientes y productos mediante identificadores simples. Bien base organizada los datos se convierten en poderosa herramienta organización y almacenamiento eficiente de datos con redundancia mínima. Recuerde esta base de datos, me referiré a ella con frecuencia en más ejemplos.
Entonces, ¿cómo se realizan las operaciones de bases de datos relacionales? Para hacer esto, SQL tiene un conjunto especial de comandos generales, como SELECCIONAR, INSERTAR, ACTUALIZAR y ELIMINAR. Por ejemplo, si necesita obtener la dirección de correo electrónico de un cliente con ID 2001cu (consulte la Figura 11.1), solo necesita ejecutar el siguiente comando SQL:
SELECCIONE cust_email DE los clientes DONDE custjd = "2001cu"
Todo es bastante lógico, ¿no? En resumen, el comando se ve así:
SELECCIONE nombre_campo DESDE nombre_tabla [DONDE condición]
Los corchetes indican que la parte final del comando es opcional. Por ejemplo, para obtener las direcciones de correo electrónico de todos los clientes de la tabla de clientes, simplemente ejecute la siguiente consulta:
SELECCIONE cust_email DE clientes
Supongamos que desea agregar una nueva entrada a la tabla de productos. El comando más simple insertar se ve así:
INSERTAR en productos VALORES ("1009pr", "Tomates Rojos", "1.43");
Si luego necesita eliminar estos datos, use el siguiente comando:
ELIMINAR DE productos DONDE prod_id = 1009r";
Hay muchos tipos de comandos SQL y una descripción completa de ellos está fuera del alcance de este libro. ¡Se podría escribir fácilmente un libro aparte sobre este tema! Intenté mantener los comandos SQL utilizados en los ejemplos relativamente simples pero lo suficientemente realistas. Hay muchos en la web. informacion educativa y recursos SQL. Algunos enlaces se proporcionan al final de esta sección.
No es necesario escribir comandos SQL en caracteres mayúsculos. Sin embargo, prefiero esta notación porque ayuda a distinguir los componentes de la solicitud.
Dado que está leyendo este libro, probablemente le interese la pregunta de cómo se organiza el trabajo con bases de datos en entorno web? Como regla general, primero, usando algunos
o un lenguaje de interfaz (PHP, Java o Perl), se crea una conexión a la base de datos, después de lo cual el programa accede a la base de datos con consultas utilizando un conjunto estándar de herramientas. Se puede considerar un lenguaje de interfaz como una especie de “pegamento” que une la base de datos a la Web. Recurro a mi lenguaje de interfaz de usuario favorito: PHP.
Recursos adicionales
A continuación se enumeran algunos recursos en línea relacionados con SQL. Serán útiles tanto para principiantes como para programadores experimentados.
- Tutoriales de SQL: http://perl.about.com/compute/perl/cs/beginningsql/index.htm.
- SQLCourse.com (con base de datos de muestra): http://www.sqlcourse.com.
- Web de SQL para geeks: http://www.arsdigita.com/books/sql.
- Introducción a SQL (aplicado a MySQL): http://www.devshed.com/Server_side/MySQL/Intro.
Soporte de base de datos en PHP
Si me pidieran que nombrara la mayoría aspecto importante PHP, probablemente me quedaría con el soporte de bases de datos. PHP proporciona un amplio soporte para prácticamente todos los servidores de bases de datos que existen, incluidos:
| PostgreSQL | ||
| Sólido | ||
| Sybase | ||
| base de datos UNIX | ||
|
File-Pro (solo lectura) |
Velods | |
|
Oráculo (OCI7 y OC18) |
Como muestra esta lista, el soporte de bases de datos de PHP varía desde la compatibilidad con bases de datos que todos conocen (como Oracle) hasta aquellas de las que mucha gente ni siquiera ha oído hablar. Moraleja de la historia: si va a utilizar un DBMS serio para almacenar información distribuida en la Web, lo más probable es que esta base de datos sea compatible con PHP. El soporte de bases de datos en PHP está representado por un conjunto de funciones estándar para conectarse a la base de datos, procesar solicitudes y desconectar la conexión.
Una descripción detallada de todas las bases de datos compatibles está claramente fuera del alcance de este libro. Sin embargo, el servidor MySQL da una buena idea de las capacidades generales de soporte de bases de datos en PHP. Por esta razón, los ejemplos del resto de este y de todos los demás capítulos del libro utilizarán sintaxis MySQL. Independientemente del servidor de base de datos con el que trabaje, adaptar los ejemplos no le supondrá mucha dificultad.
Instalación
Una de las razones por las que MySQL es tan popular entre los usuarios de PHP es que el soporte para el servidor se incluye automáticamente con PHP. Por lo tanto, sólo debe asegurarse de que el paquete MySQL esté instalado correctamente. El DBMS MySQL es compatible con casi cualquier sistema operativo importante, incluidos FreeBSD, Solaris, UNIX, Linux y varias versiones de Windows. Aunque la política de licencias de MySQL es más flexible que la de otros servidores de bases de datos, le recomiendo encarecidamente que revise la información de licencias publicada en el sitio web de MySQL (http://www.mysql.com).
Se puede aceptar la última versión de MySQL desde cualquier sitio espejo. Una lista completa de sitios espejo está disponible en http://www.mysql.com/downloads/mirrors.html. En el momento de escribir este artículo, la última versión estable de MySQL era la 3.22.32 y la versión 3.32 estaba en versión beta. Por supuesto siempre debes instalar la última versión. versión estable, es lo mejor para usted. Visite su sitio espejo más cercano y descargue la versión que se adapte a sus necesidades. Sistema operativo. En la parte superior de la página hay enlaces a nuevas versiones para varias plataformas. Asegúrese de leer la página completa, ya que termina con algunos enlaces específicos del sistema operativo.
El equipo de desarrollo de MySQL ha preparado documentación detallada que describe el proceso de instalación. Recomiendo revisar detenidamente todos los aspectos generales de la instalación, sin limitarse a información específica de su sistema operativo.
Configurando MySQL
Después de una instalación exitosa, es necesario configurar el servidor MySQL. El proceso de configuración consiste principalmente en crear nuevas bases de datos y editar mesas privilegios MySQL. Las tablas de privilegios controlan el acceso a las bases de datos MySQL. Configurar las mesas correctamente hace una gran diferencia papel importante en la seguridad de sus bases de datos, por lo que antes de iniciar el sitio en modo de producción, debe dominar completamente el sistema de privilegios.
A primera vista, las tablas Privilegios de MySQL Parecen intimidantes, pero si los comprende correctamente, obtener más apoyo se convierte en una tarea muy sencilla. Una descripción completa de las tablas de privilegios está más allá del alcance de este libro. Sin embargo, existen muchos recursos en la Web diseñados para ayudar a los principiantes. Usuarios de MySQL. Para obtener más información, visite el sitio web de MySQL (http://www.mysql.com).
Después de instalar y configurar exitosamente el paquete MySQL, ¡puede comenzar a experimentar con bases de datos en la Web! La siguiente sección está dedicada a este tema. empecemos estudiando Soporte MySQL en PHP.
Funciones PHP estándar para trabajar con MySQL
Entonces, ha creado y probado con éxito todos los permisos necesarios; todo está listo para trabajar servidor mysql. En esta sección, presentaré funciones PHP estándar que puede utilizar para comunicarse fácilmente entre scripts PHP y el servidor MySQL. La secuencia general de acciones al interactuar con el servidor MySQL se ve así:
- Establezca una conexión con el servidor MySQL. Si el intento falla, muestra el mensaje correspondiente y finaliza el proceso.
- Seleccione la base de datos del servidor MySQL. Si el intento de selección falla, muestra el mensaje correspondiente y finaliza el proceso. Es posible abrir varias bases de datos simultáneamente para procesar consultas.
- Procesar solicitudes a la base de datos (o bases de datos) seleccionada.
- Una vez completado el procesamiento de la consulta, cierre la conexión al servidor de la base de datos.
Los ejemplos de esta sección utilizan las tablas de productos, clientes y pedidos (consulte la Figura 11.1). Si desea probar todos los ejemplos usted mismo, cree estas tablas o copie la página de estructura para no tener que seguir hojeando el libro.
Entonces, comencemos desde el principio, es decir, conectándonos al servidor MySQL.
La función mysql_connect() establece una conexión con el servidor MySQL. Después de conectarse exitosamente a MySQL, puede proceder a seleccionar las bases de datos servidas por este servidor. Sintaxis de la función Mysql_connect():
int mysql_connect ( [:/ruta//a/socket] [, nombre de usuario de cadena] [, contraseña de cadena])
El parámetro de host contiene el nombre de la computadora host especificada en las tablas de privilegios del servidor MySQL. Por supuesto, también se utiliza para redirigir solicitudes al servidor web que ejecuta MySQL, ya que el servidor MySQL se puede conectar al servidor MySQL de forma remota. Junto con el nombre del host, se pueden especificar parámetros opcionales: el número de puerto y la ruta al socket (para el host local). Los parámetros de nombre de usuario y contraseña deben coincidir con el nombre de usuario y la contraseña especificados en las tablas de privilegios de MySQL. Tenga en cuenta que todos los parámetros son opcionales porque las tablas de privilegios se pueden configurar para permitir conexiones sin verificación. Si no se especifica el host, mysql_connect() intenta conectarse al host local.
Ejemplo de apertura de una conexión a MySQL:
@mysql_connect("host local", "web", "4tf9zzzf")
En este ejemplo, localhost es el nombre de la computadora, web es el nombre de usuario y 4tf9zzzf es la contraseña. El signo @ antes de llamar a mysql_connect() suprime cualquier mensaje de error producido cuando falla el intento de conexión; se reemplaza por el mensaje especificado al llamar a die(). Tenga en cuenta que el valor devuelto por rnysql_connect() no se utiliza en este ejemplo. Si el programa utiliza sólo una conexión al servidor MySQL, esto es bastante normal. Pero si un programa establece conexiones a múltiples servidores MySQL en diferentes hosts, debe almacenar el ID de conexión devuelto llamando a mysql_connect() para apuntar a comandos posteriores. al servidor requerido MySQL. Ejemplo:
$link1 = @mysql_connect("www.somehost.com", "web", "abcde") o die("No se pudo conectar a
¡Servidor MySQL!");
$linkl = @mysql_connect("www.someotherhost.com", "usr", "secret") o die("No se pudo conectar
al servidor MySQL!");
Los identificadores $link1 y $link2 se pasan en consultas posteriores a las bases de datos. Pronto aprenderá exactamente cómo dirigir la solicitud al servidor correcto utilizando el ID de conexión.
La función mysql_pconnect() proporciona soporte para conexiones persistentes. En entornos multiusuario, se recomienda utilizar mysql_pconnect() en lugar de mysql_connect() para ahorrar recursos del sistema. Los tipos de parámetros y el valor de retorno de la función mysql_pconnect() son exactamente los mismos cmysql_connect().
mysql_select_db()
Después de conectarse exitosamente a MySQL, debe seleccionar una base de datos ubicada en el servidor. Para esto se utiliza la función mysql_select_db(). Sintaxis de la función Mysql_select_db():
entero mysql_select_db (cadena nombre_base_datos [, entero identificador_conexión])
El parámetro nombre_base de datos define la base de datos seleccionada, identificador
que es devuelto por la función mysql_select_db(). Tenga en cuenta: parámetro
Connection_identifier es opcional solo cuando hay una conexión abierta a
Servidor MySQL. Si hay varias conexiones abiertas, esta opción
debe indicarse. Un ejemplo de selección de una base de datos usando la función mysql_select_db():
or die("¡No se pudo conectar al servidor MySQL!");
Si solo se selecciona una base de datos en el programa, no es necesario guardar su identificador. Sin embargo, si selecciona varias bases de datos, los ID devueltos se conservan para que pueda hacer referencia a la base de datos correcta al procesar la solicitud. Si no se especifica ningún ID, se utiliza la última base de datos seleccionada.
Después de terminar de trabajar con el servidor MySQL, se debe cerrar la conexión. La función mysql_close() cierra la conexión especificada por el parámetro opcional. Si no se especifica el parámetro, la función mysql_close() cierra el último conexión abierta. Sintaxis de la función Mysql_close():
intmysql_close()
Ejemplo de uso de mysql_close():
@mysql_connect("localhost", "web", "4tf9zzzf")
or die("¡No se pudo conectar al servidor MySQL!");
@mysql_select_db("empresa") o die("¡No se pudo seleccionar la base de datos de la empresa!"); print "¡Estás conectado a una base de datos MySQL!";
En este ejemplo, no es necesario especificar una ID de conexión porque solo hay una conexión abierta al servidor en el momento en que se llama a mysql_close().
No es necesario cerrar las conexiones abiertas por mysql_pconnect().
La función mysql_query() proporciona una interfaz para consultar bases de datos
datos. Sintaxis de la función Mysql_query():
int mysql_query (consulta de cadena [, int identificador_conexión])
El parámetro de consulta contiene el texto de la consulta en SQL. La solicitud se envía a la conexión identificada por el parámetro connect_identifier opcional o, si no hay ningún parámetro, a la última conexión abierta.
Los programadores sin experiencia a menudo piensan erróneamente que la función mysql_query() devuelve los resultados del procesamiento de consultas. Esto no es cierto: dependiendo del tipo de consulta, llamar a mysql_query() puede tener diferentes consecuencias. Cuando un comando SQL SELECT se ejecuta correctamente, se devuelve un identificador de resultado, que posteriormente se pasa a la función mysql_result() para su posterior formateo y visualización de los resultados de la consulta. Si falla el procesamiento de la solicitud, la función devuelve FALSO. La función mysql_result() se describe en una de las siguientes secciones. La cantidad de registros que participan en una consulta se determina utilizando la función mysql_num_rows(). Esta función también se describe a continuación.
Dicho esto, daré ejemplos del uso de mysql_query() sólo después de describir las funciones mysql_result() y mysql_affected_rows().
Si le preocupa que el procesamiento de solicitudes esté consumiendo demasiada memoria, llame función estándar PHP mysql_free_result. Cuando se llama, se le pasa el ID del resultado devuelto por mysql_query(). La función mysql_free_result() libera toda la memoria asociada con la consulta dada.
mysqLaff ected_rows()
En muchas situaciones, necesita saber el número de registros que participan en consulta SQL con comandos INSERTAR, ACTUALIZAR, REEMPLAZAR o ELIMINAR. El problema se resuelve mediante la función mysql_affected_rows(). Sintaxis de la función:
int mysql_affected_rows()
Tenga en cuenta que el parámetro connect_id es opcional. Si no se especifica, mysql_affected_rqws() intenta utilizar la última conexión abierta. Ejemplo:
// Conéctese al servidor y seleccione una base de datos
@mysql_connect("localhost", "web". "4tf9zzzf")
or die("¡No se pudo conectar al servidor MySQL!");
@mysql_select_db("empresa") o die("¡No se pudo seleccionar la base de datos de la empresa!");
// Crea una solicitud
$query = "ACTUALIZAR productos SET prod_name = \"melón\"
DONDE prod_id = \"10001pr\";
// Ejecutar la solicitud
// Determinar el número de registros actualizados
imprimir "Fila total actualizada; ".mysql_affected_rows();
La ejecución de este fragmento producirá el siguiente resultado:
Fila total actualizada: 1
La función mysql_affected_rows() no funciona con consultas basadas en el comando SELECT. Para determinar la cantidad de registros devueltos por una llamada SELECT, use la función mysql_num_rows(), que se describe en la siguiente sección.
En una situación específica, la función mysql_affected_rows() falla. Al ejecutar un comando DELETE sin una cláusula WHERE, mysql_affected_rows() siempre devuelve 0.
mysql_num_rows()
La función mysql_num_rows() determina el número de filas devueltas por un comando SELECT. Sintaxis de la función Mysql_num_rows():
int mysql_num_rows(resultado int)
Ejemplo de uso de mysql_num_rows():
// Conéctate al servidor y selecciona una base de datos @mysql_connect("localhost", "web", "4tf9zzzf")
or die("¡No se pudo conectar al servidor MySQL!");
@mysql_select_db("empresa") o die("¡No se pudo seleccionar la base de datos de la empresa!");
//Selecciona todos los productos cuyos nombres comiencen con "p"
$query = "SELECCIONE prod_name DE productos DONDE prod_name COMO \"p*\"";
imprimir "Total de filas seleccionadas: ".mysql_num_rows($resultado);
Dado que la tabla contiene sólo un producto cuyo nombre comienza con la letra p (peras), sólo se devuelve un registro. Resultado:
Total de filas seleccionadas: 1
La función mysql_result() se usa junto con mysql_query() (cuando se ejecuta una consulta con un comando SELECT) para recuperar un conjunto de datos. Sintaxis de la función Mysql_resu1t():
int mysql_result (int result_identifier, int record [. campo mixto"]")
El parámetro result_identifier pasa el valor devuelto por la función mysql_query(). El parámetro de registro se refiere a un registro específico en el conjunto de datos identificado por el parámetro result_id. Finalmente, en un parámetro opcional se puede pasar el campo:
- desplazamiento del campo de la tabla;
- nombre del campo;
- nombre del campo en formato nombre_campo_nombre_tdblitz.
El Listado 11.1 utiliza la base de datos que se muestra en la Figura. 11.1.
Listado 11.1. Recuperar y formatear datos en una base de datos MySQL
@mysql_connect("localhost", "web", "ffttss")
or die("¡No se pudo conectar al servidor MySQL!");
@mysql_select_db("empresa")
//Selecciona todos los registros de la tabla de productos.
$consulta = "SELECCIONAR * DE productos"; $resultado = mysql_query($consulta);
imprimir "
| ID del producto | Nombre del producto | Precio del producto | \norte
|---|---|---|
| $identificación | \norte$nombre | \norte$precio | \norte";
Como resultado de ejecutar este ejemplo con los datos que se muestran en la Fig. 11.1, se obtendrá el siguiente resultado:
Listado 11.2. Resultado del Listado 11.1
La función mysql_result() es útil para trabajar con conjuntos de datos relativamente pequeños, pero hay otras funciones que funcionan mucho más eficientemente, a saber, las funciones mysql_fetch_row() y mysql_fetch_array(). Estas características se describen en las siguientes secciones.
mysql_fetch_row()
Generalmente es mucho más conveniente asignar los valores de todos los campos de un registro a los elementos de la matriz indexada a la vez (comenzando en el índice 0), en lugar de llamar repetidamente a mysql_result() para obtener campos individuales. El problema se resuelve mediante la función mysql_fetch_row(), que tiene la siguiente sintaxis:
matriz mysql_fetch_row (resultado int)
El uso de la función list() en combinación con mysql_fetch_row() guarda varios comandos necesarios al usar mysql_result(). El Listado 11.3 muestra el código del Listado 11.1 reescrito usando list() y mysql_fetch_row().
Listado 11.3. Obteniendo datos usando la función mysql_fetch_row()
@mysql_connect("localhost", "web", "ffttss") o die("¡No se pudo conectar al servidor MySQL!");
@mysql_select_db("empresa") o die("¡No se pudo seleccionar la base de datos de productos!");
$consulta = "SELECCIONAR * DE productos";
$resultado = mysql_query($consulta);
imprimir "
| ID del producto | Nombre del producto |
Precio del producto | \norte
|---|---|---|
| ".$fila["prod_id"]." | \norte".$fila["prod_name"]." | \norte" .$fila["prod_price"]. " | \norte";
El Listado 11.3 produce el mismo resultado que el Listado 11.1, pero usa menos comandos.
mi sq l_f etch_array()
La función mysql_fetch_array() es similar a mysql_fetch_row(), sin embargo, de forma predeterminada los valores de los campos de registro se almacenan en de asociación formación. Sin embargo, puedes elegir el tipo de indexación (asociativa, numérica o combinada). Sintaxis de la función Mysql_fetch_array():
matriz mysql_fetch_array (identificador de resultado int [, tipo_indexación])
El parámetro result_identifier pasa el valor devuelto por la función mysql_query(). El parámetro indexing_type opcional toma uno de los siguientes valores:
- MYSQL_ASSOC: la función mysql_fetch_array() devuelve una matriz asociativa. Si no se especifica, este valor se utiliza como valor predeterminado;
- MYSQL_NUM: la función mysql_fetch_array() devuelve una matriz indexada numéricamente;
- MYSQL_BOTH: se puede acceder a los campos del registro devuelto mediante índices numéricos o asociativos.
El Listado 11.4 contiene otra versión del código de los Listados 11.1 y 11.3. Esta vez se utiliza la función mysql_fetch_array(), que devuelve una matriz asociativa de campos.
Listado 11.4. Obteniendo datos usando la función mysql_fetch_array()
@mysql_connect("host local", "web", "ffttss")
or die("¡No se pudo conectar al servidor MySQL!");
@mysql_select_db("empresa")
or die("¡No se pudo seleccionar la base de datos de productos!");
$consulta = "SELECCIONAR * DE productos";
$resultado = mysql_query($consulta);
"
| ID del producto | Nombre del producto | Precio del producto | \norte
|---|---|---|
| ".$fila["prod_id"]." | \norte".$fila["prod_name"]." | \norte" . $fila["prod_price"] . " | \n" ;
El Listado 11.4 produce el mismo resultado que los Listados 11.1 y 11.3.
Lo que ahora sabes sobre la funcionalidad de MySQL en PHP es suficiente para empezar a crear algunas aplicaciones bastante interesantes. La primera aplicación que veremos es un motor de búsqueda sencillo. Este ejemplo demuestra el uso de formularios HTML (consulte el capítulo anterior) para obtener datos que luego se utilizan para recuperar información de la base de datos.
Un ejemplo de un motor de búsqueda simple en PHP.
Todos hemos tenido que utilizar motores de búsqueda web más de una vez, pero ¿cómo funcionan esos sistemas? El motor de búsqueda más sencillo acepta al menos una palabra clave. Esta palabra se incluye en la consulta SQL, que luego se utiliza para recuperar información de la base de datos. El motor de búsqueda formatea el resultado de la búsqueda según uno u otro criterio (por ejemplo, por categoría o grado de coincidencia).
El motor de búsqueda que se muestra en el Listado 11.5 está diseñado para buscar información de clientes. En el formulario, el usuario ingresa una palabra clave y selecciona una categoría (nombre de cliente, ID o dirección de correo electrónico) en la que buscar. Si el nombre, ID o dirección ingresada por el usuario existe, el motor de búsqueda recupera los atributos restantes de la base de datos. Luego, utilizando el ID del cliente de la tabla de pedidos, seleccione
historial de pedidos. Todos los pedidos realizados por este cliente se muestran en orden descendente de volumen. Si la palabra clave especificada no aparece en la categoría especificada por el usuario, la búsqueda se detiene, el programa muestra el mensaje correspondiente y muestra el formulario nuevamente.
Listado 11.5. El motor de búsqueda más simple (searchengine.php)
"
Los resultados de completar este formulario se envían a insert_book.php.
Ejemplo 2.2
En el ejemplo 2.2, los datos de cadena ingresados son procesados por la función agrega pestañas(). Esta función agrega barras invertidas antes de comillas simples ("), comillas dobles ("), barra invertida (\) y bytes nulos. El hecho es que, de acuerdo con los requisitos del sistema de consulta de la base de datos, dichos símbolos deben estar entre comillas.
Para determinar el número de registros como resultado de una consulta, utilice la función mysql_num_rows().
Todos los registros de resultados de la consulta se pueden ver en un bucle. Antes de hacer esto, usando la función mysql_fetch_ Para cada registro se obtiene una matriz asociativa.
El ejemplo 3.1 muestra un formulario HTML para buscar libros específicos en una base de datos.
Ejemplo 3.1
Los resultados de completar este formulario se envían a search_book.php.
Ejemplo 3.2
".($i+1). $fila["título"]. "
Opción alternativa
".($i++). $fila["título"]."
"; echo "Autor: ".$fila["autor"]."
"; echo "ISBN: ".$fila["ISBN"]."
"; echo "Precio: ".$fila["precio"]."
"; echo "Cantidad: ".$fila["cantidad"]."
Entonces, ¿cómo funciona la arquitectura de la base de datos web?
- El navegador web del usuario emite una solicitud HTTP para una página web específica.
- Por ejemplo, un usuario que utiliza un formulario HTML busca todos los libros sobre PHP. La página de procesamiento del formulario se llama search_book.php.
- El servidor web recibe una solicitud de search_book.php, recupera este archivo y lo pasa al motor PHP para su procesamiento.
- PHP se conecta al servidor MySQL y envía la solicitud.
- El servidor acepta una solicitud de base de datos, la procesa y envía el resultado (una lista de libros) al motor PHP.
- El motor PHP termina de ejecutar el script y formatea el resultado de la solicitud en HTML. Después de esto, el resultado en formato HTML se devuelve al servidor web.
El servidor web reenvía el HTML al navegador y el usuario puede ver la lista de libros solicitada.
Usando el mecanismo de transacción
Usar el mecanismo de transacción como ejemplo de cómo transferir dinero de una persona a otra
If(mysql_query ("COMENZAR") && mysql_query ("ACTUALIZAR dinero SET amt = amt - 6 DONDE nombre = "Eva"") && mysql_query ("ACTUALIZAR dinero SET amt = amt + 6 DONDE nombre = "Ida"") && mysql_query ("COMMIT"))( echo "Exitoso"; )else( mysql_query ("ROLLBACK"); echo "No exitoso"; )
Si ejecuta varios procesos que realizan consultas de selección en la misma tabla, es posible que seleccionen el mismo registro al mismo tiempo.
Para evitar la situación anterior, es necesario ejecutar no solo una consulta SELECT, sino su versión extendida, que muchos ni siquiera conocen: SELECT... FOR UPDATE.
Así, al ejecutar esta consulta, todos los registros afectados en la base de datos quedarán bloqueados hasta que se complete la sesión con la base de datos o hasta que se actualicen los datos del registro.
Otro script no podrá seleccionar registros bloqueados hasta que ocurra una de las condiciones mencionadas.
