Inserta datos en MySQL con PHP)

Inserta datos en MySQL con PHP

Ene 06, 2021 NGuerrero php 0

¿Te gustaría aprender a PHP desde cero?

Tenemos los cursos que necesitas.¡Haz clic aquí!

Introducción

En este tutorial aprenderás cómo empezar a administrar una base de datos desde tus scripts PHP. Aprenderás a usar PHP para INSERTAR datos en MySQL. Antes de continuar, deberías consultar nuestro otro tutorial que cubre el paso más importante al trabajar con PHP y bases de datos, conectar PHP a una base de datos.

Lo que necesitarás

Antes de comenzar con esta guía necesitarás lo siguiente:

Acceso a tu panel de control de hosting

Paso 1 – Crear una tabla

En primer lugar, debemos crear una tabla para tus datos. Es un procedimiento muy simple que puedes hacer con phpMyAdmin, que se encuentra en tu panel de control de hosting. Ya hemos hablado sobre el proceso de creación de la base de datos MySQL en el tutorial anterior, así que omitiremos esa parte aquí.

Después de ingresar a tu página de phpMyAdmin, deberías ver algo similar a esto:

Crearemos una tabla llamada Students para nuestra base de datos u266072517_name. Puedes crear una nueva tabla haciendo clic en el botón Create table. Después de eso, verás esta nueva página donde puedes ingresar toda la información necesaria para tu tabla:

Esta es la configuración más simple que puedes usar para una tabla, para obtener más información sobre la estructura de la tabla/base de datos y qué tipo de configuración puedes usar con esas columnas, consulta la documentación oficial de phpMyAdmin.

Por ahora, aquí hay algunas explicaciones sencillas de las columnas que usamos:

Name: Este es el nombre de tu columna. Se mostrará en la parte superior de tu tabla.
Type: Puedes establecer un tipo de columna aquí. Por ejemplo, seleccionamos varcharporque necesitamos ingresar un tipo de cadena caracteres de nombre aquí (que tenga letras, no números).
Length/Values: Se usa para especificar la longitud máxima que tu entrada en esta columna puede tener.
Index: Usamos el índice “principal” para nuestro campo “ID”. Al crear una tabla, se recomienda tener una columna de ID. Se utiliza para enumerar las entradas de la tabla y se requiere para configurar las relaciones de la tabla. También marqué “A_I“, lo que significa Auto Incremento. Esto servirá para enumerar automáticamente las entradas (1,2,3,4 …).

Haz clic en Save para guardar y se creará tu tabla.

Paso 2 – Escribir código PHP para INSERTAR datos en MySQL

Opción 1 – Método MySQLi

En primer lugar, debes establecer una conexión con una base de datos tomando como referencia nuestro tutorial anterior. Una vez hecho esto, podemos proceder con la consulta SQL INSERT. Aquí hay un código de ejemplo completo con la conexión básica y los métodos de inserción:

<?php
$servername = “mysql.hostinger.co.uk”;
$database = “u266072517_name”;
$username = “u266072517_user”;
$password = “buystuffpwd”;
// Create connection
$conn = mysqli_connect($servername, $username, $password, $database);
// Check connection
if (!$conn) {
die(“Connection failed: “ . mysqli_connect_error());
}
echo “Connected successfully”;
$sql = “INSERT INTO Students (name, lastname, email) VALUES (‘Thom’, ‘Vial’, ‘thom.v@some.com’)”;
if (mysqli_query($conn, $sql)) {
echo “New record created successfully”;
} else {
echo “Error: “ . $sql . “<br>” . mysqli_error($conn);
}
mysqli_close($conn);
?>

Entonces, la primera parte del código (líneas 3 – 18) tiene como objetivo la conexión a la base de datos. No vamos a analizar esta parte de nuevo, pero si quieres saber qué significa cada línea del código, mira nuestra guía anterior sobre cómo conectarse a una base de datos.

Comencemos con la línea número 19:

$sql = “INSERT INTO Students (name, lastname, email) VALUES (‘Thom’, ‘Vial’, ‘thom.v@some.com’)”;

Esta es la línea más importante de nuestro código, ya que hace lo que queremos aprender en este tutorial: inserta datos en MySQL. INSERT INTO es una declaración que agrega datos a la tabla de la base de datos especificada. En nuestro ejemplo, estamos agregando datos a la tabla Students.

Si continuamos, entre los corchetes, tenemos columnas de tabla específicas a las que queremos agregar los valores: (name, last name, email). Los datos se agregarán en el orden especificado. Si escribiéramos (email, last name, name), los valores serían agregados en un orden diferente.

Entonces la siguiente parte es la declaración de VALUES. Aquí especificamos nuestros valores para las columnas previamente especificadas. De esta forma, cada columna representa un valor específico. Por ejemplo, en nuestro caso sería así: name = Thom, lastname = Vial, email = thom.v@some.com.

Otra cosa que vale la pena mencionar es que acabamos de ejecutar una consulta SQL usando código PHP, las consultas SQL deben establecerse entre comillas. En nuestro ejemplo, todo lo que está entre comillas y después de $sql = es una consulta SQL.

La siguiente parte del código (líneas 20 – 22) verifica si nuestra consulta fue exitosa:

if (mysqli_query($conn, $sql)) {
echo “New record created successfully”;
}

Simplemente muestra un mensaje de éxito si la consulta que ejecutamos fue exitosa.

Y la parte final (líneas 22 – 24) muestra un mensaje diferente en caso de que nuestra consulta no fuera exitosa:

else {
echo “Error: “ . $sql . “<br>” . mysqli_error($conn);
}

Esto nos mostrará un mensaje de error en caso de que algo esté mal.

Opción 2 – Método PHP Data Object (PDO)

Al igual que en el ejemplo anterior, primero necesitamos una conexión a la base de datos lo cual se realiza creando un nuevo objeto PDO; el tutorial anterior te mostrará cómo hacerlo. Como la conexión a la base de datos MySQL es un objeto PDO, debes usar varios “métodos” PDO (cualquier función que sea parte de cualquier objeto) para preparar y ejecutar consultas. Los métodos de los objetos se llaman así:

$the_Object->the_Method();

PDO te permite “preparar” el código SQL antes de que se ejecute. La consulta SQL se evalúa y se “corrige” antes de ejecutarse. Un ataque de inyección SQL simplificado podría hacerse simplemente escribiendo código SQL en un campo de un formulario. Por ejemplo:

// User writes this in the username field of a login form
john”; DROP DATABASE user_table;
// The final query becomes this
“SELECT * FROM user_table WHERE username = john”; DROP DATABASE user_table;

Como hay un código SQL sintácticamente correcto, el punto y coma hace que DROP DATABASE user_table sea una nueva consulta SQL, y tu tabla de usuario se borra. Las declaraciones preparadas no permiten los caracteres “ y ; para finalizar la consulta original y la instrucción maliciosa DROP DATABASE nunca se ejecutará.

Siempre deberías usar declaraciones preparadas al enviar o recibir datos de la base de datos con PDO.

Para usar declaraciones preparadas, debes escribir una nueva variable que llame al método prepare() del objeto de la base de datos.

En el código correcto:

<?php
$servername = “mysql.hostinger.com”;
$database = “u266072517_name”;
$username = “u266072517_user”;
$password = “buystuffpwd”;
$sql = “mysql:host=$servername;dbname=$database;”;
$dsn_Options = [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION];
// Create a new connection to the MySQL database using PDO, $my_Db_Connection is an object
try {
$my_Db_Connection = new PDO($sql, $username, $password, $dsn_Options);
echo “Connected successfully”;
} catch (PDOException $error) {
echo ‘Connection error: ‘ . $error->getMessage();
}
// Set the variables for the person we want to add to the database
$first_Name = “Thom”;
$last_Name = “Vial”;
$email = “thom.v@some.com”;
// Here we create a variable that calls the prepare() method of the database object
// The SQL query you want to run is entered as the parameter, and placeholders are written like this :placeholder_name
$my_Insert_Statement = $my_Db_Connection->prepare(“INSERT INTO Students (name, lastname, email) VALUES (:first_name, :last_name, :email)”);
// Now we tell the script which variable each placeholder actually refers to using the bindParam() method
// First parameter is the placeholder in the statement above – the second parameter is a variable that it should refer to
$my_Insert_Statement->bindParam(:first_name, $first_Name);
$my_Insert_Statement->bindParam(:last_name, $last_Name);
$my_Insert_Statement->bindParam(:email, $email);
// Execute the query using the data we just defined
// The execute() method returns TRUE if it is successful and FALSE if it is not, allowing you to write your own messages here
if ($my_Insert_Statement->execute()) {
echo “New record created successfully”;
} else {
echo “Unable to create record”;
}
// At this point you can change the data of the variables and execute again to add more data to the database
$first_Name = “John”;
$last_Name = “Smith”;
$email = “john.smith@email.com”;
$my_Insert_Statement->execute();
// Execute again now that the variables have changed
if ($my_Insert_Statement->execute()) {
echo “New record created successfully”;
} else {
echo “Unable to create record”;
}

En las líneas 28, 29 y 30, usamos el método bindParam() del objeto de la base de datos. También está el método bindValue() que es muy diferente.

bindParam() – Este método evalúa los datos cuando se alcanza el método execute(). La primera vez que el script llega a un método execute(), ve que $first_Name corresponde a “Thom”, vincula ese valor y ejecuta la consulta. Cuando el script llega al segundo método execute(), ve que $first_Name ahora corresponde a “John”, vincula ese valor y ejecuta nuevamente la consulta con los nuevos valores. Lo que es importante recordar es que definimos la consulta una vez y la reutilizamos con diferentes datos en diferentes puntos del script.
bindValue() – Este método evalúa los datos tan pronto como se llega a bindValue(). Como el valor de $first_Name se definió como “Thom” cuando se llegó a bindValue(), este se usará cada vez que se llame a un método execute() para $my_Insert_Statement.

Observa que reutilizamos la variable $first_Name y le damos un nuevo valor la segunda vez. Si revisas tu base de datos después de ejecutar este script, tienes los dos nombres definidos, a pesar de que la variable $first_Name equivale a “John” al final del script. Recuerda que PHP evalúa un script completo antes de ejecutarlo.

Si actualizas el script para reemplazar bindParam con bindValue, insertarás en MySQL “Thom Vial” dos veces en la base de datos y John Smith será ignorado.

Paso 3 – Confirmar que todo funcione y resolver problemas comunes

Si la consulta que ejecutamos e insertamos en la base de datos MySQL fue exitosa, veremos el siguiente mensaje:

Solución de errores comunes

MySQLi

En cualquier otro caso, se mostrará un mensaje de error en su lugar. Por ejemplo, hagamos un error de sintaxis en nuestro código y obtenemos esto:

Como podemos ver, la primera parte del código es buena, la conexión se estableció con éxito, pero nuestra consulta SQL se encontró con un muro.

"Error: INSERT INTO Students {name, lastname, email} VALUES ('Thom', 'Vial', 'thom.v@some.com')
You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '{name, lastname, email} VALUES ('Thom', 'Vial', 'thom.v@some.com')' at line 1"

Hay un error de sintaxis que, lamentablemente, provocó el error en nuestro script. El error fue aquí:

$sql = “INSERT INTO Students {name, lastname, email} VALUES (‘Thom’, ‘Vial’, ‘thom.v@some.com’)”;

Como puedes ver, usamos corchetes en lugar de paréntesis simples. Esto no es correcto y provocó que nuestro script arrojara un error de sintaxis.

PDO

En la línea 7 de la conexión PDO, el modo de error está configurado para “mostrar todas las excepciones”. Si esto quedara fuera del script y la consulta fallara, no recibirías ningún mensaje de error. Con las excepciones habilitadas, se muestra el problema específico. Por lo general, esto solo debería utilizarse al desarrollar un script, ya que puede exponer la base de datos y los nombres de tablas, cosa que quizás prefieras ocultar de cualquiera que intente acceder maliciosamente a tus datos. En el caso anterior donde se usaron corchetes en lugar de paréntesis normales, el error es similar a este:

Fatal error: Uncaught exception 'PDOException' with message 'SQLSTATE[42000]: Syntax error or access violation: 1064 You have an error in your SQL syntax; <code>check the manual that corresponds to your MySQL server version for the right syntax to use near '{name, lastname, email} VALUES ('Thom', 'Vial', 'thom.v@some.com')' at line 1"</code>

Otros posibles problemas que puedes encontrar:

Columnas incorrectas especificadas (columnas inexistentes o un error de ortografía).
Un tipo de valor asignado a otro tipo de columna. Por ejemplo, si tratamos de asignar un número 47 a una columna de nombre (Name), obtendríamos un error porque se supone que es un valor de texto. Pero si asignamos un número entre comillas, por ejemplo, “47”, eso funcionaría porque nuestro número se asignaría como un texto a la columna.
Intentar ingresar datos en una tabla que no existe o cometer un error ortográfico en la tabla.

Todos esos errores se pueden solucionar fácilmente siguiendo las pautas del mensaje de error o verificando error_log.

Después de una entrada de datos exitosa, deberíamos verla agregada a nuestra base de datos. Aquí hay un ejemplo de la tabla a la que agregamos nuestros datos cuando los vemos desde phpMyAdmin.

Conclusión

En este tutorial, has aprendido a usar PHP para INSERTAR datos en MySQL utilizando MySQLiy PDO. También aprendiste a solucionar los errores de conexión más comunes. Saber cómo usar PHP para agregar datos a una base de datos MySQL es útil ya sea que estés aprendiendo a programar o construyendo tu sitio web.

Te esperamos en los siguientes artículos en donde hablaremos mas acerca de estos temas, los cuales hoy en día son de vital importancia en el mundo de la tecnología.

¿Te gustaría aprender a PHP desde cero?

Tenemos los cursos que necesitas.¡Haz clic aquí!