Estuvo bueno el ejercicio de borrar un usuario!
JDBC
Arquitectura de la API JDBC
¿Qué es Java Database Connection (JDBC)?
Métodos y componentes de JDBC
Conectando Java con bases de datos
Leer y crear datos con JDBC
Actualizar y eliminar datos con JDBC
CRUD
Clases y estructura del proyecto con IntelliJ y Maven
Optimización de recursos
Patrón DAO y Repository
Implementando el Patrón Repository
Leer Datos desde Java
Insertar Datos en Java
Eliminar Datos en Java
Visualizando bases de datos con Java Swing
Transacciones
¿Qué es una transacción?
Implementando transacciones con JDBC
Conexiones Pool
¿Qué es una conexión pool?
Implementando conexiones pool
JPA y ORM
¿Qué es JPA y ORM?
Instalación y configuración de Hibernate
Implementando JPA con Hibernete
Próximos pasos
Reto: crea un clon de Netflix con Java
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Actualizar y eliminar datos con JDBC
6/22Recursos
Aportes 19
Preguntas 2
Ordenar por:
Logrado! 😊
Connection myConn = null;
Statement myStamt = null;
PreparedStatement myPrepStamt = null;
ResultSet myRes = null;
try {
myConn = DriverManager.getConnection(connString, user, password);
String sql = "DELETE FROM Users WHERE _last_Name = 'Ochoa'";
myPrepStamt = myConn.prepareStatement(sql);
int rowsAff = myPrepStamt.executeUpdate();
if(rowsAff > 0){
System.out.println("User deleted succesfully. Affected rows: " + rowsAff);
myStamt = myConn.createStatement();
sql = "SELECT * FROM Users";
myRes = myStamt.executeQuery(sql);
while (myRes.next()){
System.out.println(myRes.getString("_first_name") + ", " + myRes.getString("_last_name"));
}
}
} catch (Exception e){
System.err.printIn("An error has occurred: " + e.getMessage());
} finally {
myConn.close();
}
Me presento problema al actualizar el executeupdate, me toco quitar donde lo concatenaba con el + .
Lo coloque así y me permitió ya realizar el proceso, dejo comentada la línea que tenía antes siguiendo el ejemplo de la clase.
// int rowsAffected = myStamt.executeUpdate("UPDATE pb"+"set correo='micorreo.com'"+"WHERE id = '01'");
int rowsAffected = myStamt.executeUpdate("UPDATE pb SET correo='micorreo.com' WHERE id = '01'");
quien mas elimino a Jane xd
String queriUpdate = "update titan.empleados set name=?, lastName=?, salary=? where (id=?)";
stmt = conn.prepareStatement(queriUpdate);
stmt.setString(1,"Jose Alexis");
stmt.setString(2,"Nunez Torres");
stmt.setDouble(3,30000);
stmt.setInt(4,1);
stmt.executeUpdate();
rs = stmt.executeQuery("select \* from empleados
según tengo entendido es mejor preparar primero la consulta para evitar inyeccion de codigo en la misma peticion
❤️
int rowsAffected = myStament.executeUpdate("INSERT INTO countries (name) VALUES ('Chile')"); // Create
int rowsAffected = myStament.executeUpdate("UPDATE countries SET name = 'Mexico' WHERE (id = 9)"); // Update
int rowsAffected = myStament.executeUpdate("DELETE FROM countries WHERE (id = 9)"); // Delete
myRest = myStament.executeQuery("SELECT * FROM countries order by id asc"); // Read
```java
Connection myConn = null;
Statement myStamt = null;
ResultSet myRes = null;
try {
myConn = DriverManager.getConnection("jdbc:mysql://localhost:3306/java","root","");
System.out.println("Conexion exitosa");
myStamt = myConn.createStatement();
int rowsAffected = myStamt.executeUpdate("DELETE FROM employees WHERE first_name = 'John'");
if (rowsAffected > 0) {
System.out.println("Empleado eliminado");
} else {
System.out.println("No se encontro al empelado");
}
} catch (SQLException e) {
e.printStackTrace();
System.out.println(e.getMessage());
}
```Connection myConn = null;
Statement myStamt = null;
ResultSet myRes = null;
try {
myConn = DriverManager.*getConnection*("jdbc:mysql://localhost:3306/java","root","");
System.*out*.println("Conexion exitosa");
myStamt = myConn.createStatement();
int rowsAffected = myStamt.executeUpdate("DELETE FROM employees WHERE first\_name = 'John'");
if (rowsAffected > 0) {
System.*out*.println("Empleado eliminado");
} else {
System.*out*.println("No se encontro al empelado");
}
} catch (SQLException e) {
e.printStackTrace();
System.*out*.println(e.getMessage());
}
Código con todas las funciones:package org.example;
import io.github.cdimascio.dotenv.Dotenv;
import java.sql.\*;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
public class JDBCExample {
private static final Logger *logger* = Logger.*getLogger*(JDBCExample.class.getName());
private static Connection *connection*;
public static void main(String\[] args) {
Dotenv dotenv = Dotenv.*load*();
String jdbcUrl = "jdbc:mysql://localhost:" + dotenv.get("MYSQL\_PORT") + "/" + dotenv.get("MYSQL\_DATABASE");
String username = dotenv.get("MYSQL\_USER");
String password = dotenv.get("MYSQL\_ROOT\_PASSWORD");
try {
*connection* = DriverManager.*getConnection*(jdbcUrl, username, password);
System.*out*.println("Conexión exitosa a la base de datos!");
// Crear un HashMap con los datos del empleado
Map\<String, Object> empleado = new HashMap<>();
empleado.put("first\_name", "Richard");
empleado.put("pa\_surname", "Vivas");
empleado.put("ma\_surname", "Ordonez");
empleado.put("email", "[email protected]");
empleado.put("salary", 53000);
// Agregar un nuevo empleado y obtener su ID
int lastInsertedId = *agregarEmpleado*(empleado);
// Consultar todos los empleados
System.*out*.println("-".repeat(20));
*consultarEmpleados*();
System.*out*.println("-".repeat(20));
// Actualizar los datos del empleado
empleado.put("email", "rvo\[email protected]");
empleado.put("salary", 75000);
*actualizarEmpleado*(lastInsertedId, empleado);
// Consultar todos los empleados
System.*out*.println("-".repeat(20));
*consultarEmpleados*();
System.*out*.println("-".repeat(20));
// Borrar el último empleado insertado
*borrarEmpleado*(lastInsertedId);
// Consultar todos los empleados
System.*out*.println("-".repeat(20));
*consultarEmpleados*();
System.*out*.println("-".repeat(20));
*connection*.close();
} catch (Exception e) {
*logger*.log(Level.*SEVERE*, "Error al conectarse a la base de datos", e);
System.*out*.println("Algo salió mal");
}
}
public static int agregarEmpleado(Map\<String, Object> empleado) {
String sql = "INSERT INTO employees (first\_name, pa\_surname, ma\_surname, email, salary) VALUES (?, ?, ?, ?, ?)";
int generatedId = -1;
try (PreparedStatement statement = *connection*.prepareStatement(sql, Statement.*RETURN\_GENERATED\_KEYS*)) {
statement.setString(1, (String) empleado.get("first\_name"));
statement.setString(2, (String) empleado.get("pa\_surname"));
statement.setString(3, (String) empleado.get("ma\_surname"));
statement.setString(4, (String) empleado.get("email"));
statement.setInt(5, (int) empleado.get("salary"));
int rowsInserted = statement.executeUpdate();
if (rowsInserted > 0) {
System.*out*.println("Se ha creado un nuevo empleado");
// Obtener el ID del registro insertado
try (ResultSet generatedKeys = statement.getGeneratedKeys()) {
if (generatedKeys.next()) {
generatedId = generatedKeys.getInt(1);
}
}
}
} catch (SQLException e) {
*logger*.log(Level.*SEVERE*, "Error al agregar empleado", e);
}
return generatedId;
}
public static void actualizarEmpleado(int id, Map\<String, Object> empleado) {
String sql = "UPDATE employees SET first\_name = ?, pa\_surname = ?, ma\_surname = ?, email = ?, salary = ? WHERE id = ?";
try (PreparedStatement statement = *connection*.prepareStatement(sql)) {
statement.setString(1, (String) empleado.get("first\_name"));
statement.setString(2, (String) empleado.get("pa\_surname"));
statement.setString(3, (String) empleado.get("ma\_surname"));
statement.setString(4, (String) empleado.get("email"));
statement.setInt(5, (int) empleado.get("salary"));
statement.setInt(6, id);
int rowsUpdated = statement.executeUpdate();
if (rowsUpdated > 0) {
System.*out*.println("Se ha actualizado el empleado");
}
} catch (SQLException e) {
*logger*.log(Level.*SEVERE*, "Error al actualizar el empleado", e);
}
}
public static void borrarEmpleado(int id) {
String sql = "DELETE FROM employees WHERE id = ?";
try (PreparedStatement statement = *connection*.prepareStatement(sql)) {
statement.setInt(1, id);
int rowsDeleted = statement.executeUpdate();
if (rowsDeleted > 0) {
System.*out*.println("Se ha eliminado el empleado");
}
} catch (SQLException e) {
*logger*.log(Level.*SEVERE*, "Error al borrar el empleado", e);
}
}
public static void consultarEmpleados() {
String sql = "SELECT \* FROM employees";
try (PreparedStatement statement = *connection*.prepareStatement(sql);
ResultSet resultSet = statement.executeQuery()) {
// Obtener los metadatos del ResultSet para obtener información sobre las columnas
ResultSetMetaData metaData = resultSet.getMetaData();
int columnCount = metaData.getColumnCount();
// Recorre especificando el nombre de la columna
// while (resultSet.next()) {
// System.out.println(resultSet.getString("first\_name") + " " + resultSet.getString("pa\_surname"));
// }
// Recorrer las filas del ResultSet
while (resultSet.next()) {
// Recorrer las columnas de la fila actual
for (int i = 1; i <= columnCount; i++) {
String columnName = metaData.getColumnName(i);
String columnValue = resultSet.getString(i);
System.*out*.print(columnName + ": " + columnValue + " | ");
}
System.*out*.println(); // Nueva línea al final de cada fila
}
} catch (SQLException e) {
*logger*.log(Level.*SEVERE*, "Error al consultar empleados", e);
}
}
}
```js
package org.example;
import io.github.cdimascio.dotenv.Dotenv;
import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
public class JDBCExample {
private static final Logger logger = Logger.getLogger(JDBCExample.class.getName());
private static Connection connection;
public static void main(String[] args) {
Dotenv dotenv = Dotenv.load();
String jdbcUrl = "jdbc:mysql://localhost:" + dotenv.get("MYSQL_PORT") + "/" + dotenv.get("MYSQL_DATABASE");
String username = dotenv.get("MYSQL_USER");
String password = dotenv.get("MYSQL_ROOT_PASSWORD");
try {
connection = DriverManager.getConnection(jdbcUrl, username, password);
System.out.println("Conexión exitosa a la base de datos!");
// Crear un HashMap con los datos del empleado
Map<String, Object> empleado = new HashMap<>();
empleado.put("first_name", "Richard");
empleado.put("pa_surname", "Vivas");
empleado.put("ma_surname", "Ordonez");
empleado.put("email", "[email protected]");
empleado.put("salary", 53000);
// Agregar un nuevo empleado y obtener su ID
int lastInsertedId = agregarEmpleado(empleado);
// Consultar todos los empleados
System.out.println("-".repeat(20));
consultarEmpleados();
System.out.println("-".repeat(20));
// Actualizar los datos del empleado
empleado.put("email", "[email protected]");
empleado.put("salary", 75000);
actualizarEmpleado(lastInsertedId, empleado);
// Consultar todos los empleados
System.out.println("-".repeat(20));
consultarEmpleados();
System.out.println("-".repeat(20));
// Borrar el último empleado insertado
borrarEmpleado(lastInsertedId);
// Consultar todos los empleados
System.out.println("-".repeat(20));
consultarEmpleados();
System.out.println("-".repeat(20));
connection.close();
} catch (Exception e) {
logger.log(Level.SEVERE, "Error al conectarse a la base de datos", e);
System.out.println("Algo salió mal");
}
}
public static int agregarEmpleado(Map<String, Object> empleado) {
String sql = "INSERT INTO employees (first_name, pa_surname, ma_surname, email, salary) VALUES (?, ?, ?, ?, ?)";
int generatedId = -1;
try (PreparedStatement statement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
statement.setString(1, (String) empleado.get("first_name"));
statement.setString(2, (String) empleado.get("pa_surname"));
statement.setString(3, (String) empleado.get("ma_surname"));
statement.setString(4, (String) empleado.get("email"));
statement.setInt(5, (int) empleado.get("salary"));
int rowsInserted = statement.executeUpdate();
if (rowsInserted > 0) {
System.out.println("Se ha creado un nuevo empleado");
// Obtener el ID del registro insertado
try (ResultSet generatedKeys = statement.getGeneratedKeys()) {
if (generatedKeys.next()) {
generatedId = generatedKeys.getInt(1);
}
}
}
} catch (SQLException e) {
logger.log(Level.SEVERE, "Error al agregar empleado", e);
}
return generatedId;
}
public static void actualizarEmpleado(int id, Map<String, Object> empleado) {
String sql = "UPDATE employees SET first_name = ?, pa_surname = ?, ma_surname = ?, email = ?, salary = ? WHERE id = ?";
try (PreparedStatement statement = connection.prepareStatement(sql)) {
statement.setString(1, (String) empleado.get("first_name"));
statement.setString(2, (String) empleado.get("pa_surname"));
statement.setString(3, (String) empleado.get("ma_surname"));
statement.setString(4, (String) empleado.get("email"));
statement.setInt(5, (int) empleado.get("salary"));
statement.setInt(6, id);
int rowsUpdated = statement.executeUpdate();
if (rowsUpdated > 0) {
System.out.println("Se ha actualizado el empleado");
}
} catch (SQLException e) {
logger.log(Level.SEVERE, "Error al actualizar el empleado", e);
}
}
public static void borrarEmpleado(int id) {
String sql = "DELETE FROM employees WHERE id = ?";
try (PreparedStatement statement = connection.prepareStatement(sql)) {
statement.setInt(1, id);
int rowsDeleted = statement.executeUpdate();
if (rowsDeleted > 0) {
System.out.println("Se ha eliminado el empleado");
}
} catch (SQLException e) {
logger.log(Level.SEVERE, "Error al borrar el empleado", e);
}
}
public static void consultarEmpleados() {
String sql = "SELECT * FROM employees";
try (PreparedStatement statement = connection.prepareStatement(sql);
ResultSet resultSet = statement.executeQuery()) {
// Obtener los metadatos del ResultSet para obtener información sobre las columnas
ResultSetMetaData metaData = resultSet.getMetaData();
int columnCount = metaData.getColumnCount();
// Recorre especificando el nombre de la columna
// while (resultSet.next()) {
// System.out.println(resultSet.getString("first_name") + " " + resultSet.getString("pa_surname"));
// }
// Recorrer las filas del ResultSet
while (resultSet.next()) {
// Recorrer las columnas de la fila actual
for (int i = 1; i <= columnCount; i++) {
String columnName = metaData.getColumnName(i);
String columnValue = resultSet.getString(i);
System.out.print(columnName + ": " + columnValue + " | ");
}
System.out.println(); // Nueva línea al final de cada fila
}
} catch (SQLException e) {
logger.log(Level.SEVERE, "Error al consultar empleados", e);
}
}
}
```
En la linea 17 está concatenando 3 strings hardcodeadas.. no haría falta concatenarlas, a mi ver queda mas legible un solo string (salvo que haya que contatenar alguna variable)
```js
if (example == Example.CASE_4) {
int employeeId = 1;
myPreparedStatement = myConnection.prepareStatement("DELETE FROM employees WHERE id=?");
myPreparedStatement.setInt(1, employeeId);
int rowsAffected = myPreparedStatement.executeUpdate();
if (rowsAffected > 0) {
System.out.println("Employee " + employeeId + " has been deleted");
}
myStatement = myConnection.createStatement();
myResultSet = myStatement.executeQuery("SELECT * FROM employees ORDER BY id ASC");
while (myResultSet.next()) {
System.out.println(
myResultSet.getString("id") + ") " +
myResultSet.getString("first_name") + " " +
myResultSet.getString("last_name")
);
}
}
```
`if (example == Example.``CASE_4``) {`
` int employeeId = 1;`
` myPreparedStatement = myConnection.prepareStatement("DELETE FROM employees WHERE id=?");`
` myPreparedStatement.setInt(1, employeeId);`
` int rowsAffected = myPreparedStatement.executeUpdate();`
` if (rowsAffected > 0) {`
` System.``out``.println("Employee " + employeeId + " has been deleted");`
` }`
` myStatement = myConnection.createStatement();`
` myResultSet = myStatement.executeQuery("SELECT * FROM employees ORDER BY id ASC");`
` while (myResultSet.next()) {`
` System.``out``.println(`
` myResultSet.getString("id") + ") " +`
` myResultSet.getString("first_name") + " " +`
` myResultSet.getString("last_name")`
` );`
` }`
`}`
Tanto `Statement` como `PreparedStatement` son interfaces en Java que se utilizan para ejecutar sentencias SQL en una base de datos. Sin embargo, existen algunas diferencias clave entre las dos que hacen que una sea más adecuada para ciertos casos que la otra.
**¿Cuándo usar Statement?**
* **Consultas simples:** Si está ejecutando una consulta SQL simple que no requiere parámetros, como seleccionar datos de una tabla o ejecutar una instrucción DDL, `Statement` es una opción perfectamente válida. Es más simple y liviano que `PreparedStatement`.
* **Consultas ad hoc:** Si está ejecutando consultas que se generan dinámicamente en tiempo de ejecución, `Statement` puede ser más conveniente.
**¿Cuándo usar PreparedStatement?**
* **Consultas con parámetros:** Si está ejecutando consultas que contienen parámetros, como insertar, actualizar o eliminar datos, siempre debe usar `PreparedStatement`.
* **Seguridad:** `PreparedStatement` ofrece un mayor nivel de seguridad que `Statement` al prevenir ataques de inyección SQL. Los parámetros se pasan por separado de la consulta, lo que evita que el código malicioso se interprete como código SQL.
* **Rendimiento:** Para consultas que se ejecutan repetidamente con diferentes valores de parámetro, `PreparedStatement` puede ofrecer un mejor rendimiento que `Statement`. Esto se debe a que la base de datos puede preparar y compilar la consulta una vez y luego reutilizarla para diferentes conjuntos de parámetros.
**En resumen, use** `PreparedStatement` **siempre que sea posible, especialmente cuando se trabaje con consultas que contienen parámetros. Solo use** `Statement` **para consultas simples que no requieren parámetros y cuando no le preocupe la seguridad o el rendimiento.**
Genere la consulta con un prepateStatement, por que me parece que ese tipo de consultas donde la defines y luego pasas los parámetros ayuda mas con la inyección de código, quedando dela siguiente manera![]()
similar a la busqueda solo cambia la sentencia sql
He avanzado muy poco en este curso hasta este punto debido a que no comprendía cuando usar statement o preparedStatement y segun mi concepto considero que esta diferencia a este punto del curso no es tan explicita.
He visto leído bastante al respecto y creo tener la diferencia; principalmente Statement no permite el dinamismo que si ofrece preparedStatement, por ejemplo cuando veíamos que con el uso de marcadores de posición (simbolo ? dentro de las sentencias) podiamos inyectar valores dinámicos a las sentencias con los metodos set\_\_\_ (Hasta aqui todo bien), el problema radica en que esta explicación va mas allá que solo esto, Statement da paso a vulnerabilidades como SQL injection debido a que al ser String estaticos suele ser mas vulnerable a estas practicas, evento que no sucede con preparedStatement y sus marcadores de posicion.
Por otro lado, preparedStatement ofrece mejor performance en tiempo de ejecución que Statement, Ahora, si se preguntan "¿Como usamos un SELECT \* FROM X?" preparedStatement tambien permite el uso de ResultSet y el tipo de consultas que se hacen con Statement tambien pueden ser hechas por preparedStatement y viceversa en eso no se diferencian.
Espero que esto pueda ayudar a alguien que también se sienta como yo.
(Esto sin intención de atacar a la docente, pues simplemente abarco un problema puntual en una persona particular) ¡Sigan disfrutando del curso!
# RESUMEN :
* Ejecutar una consulta:
`myStamt = statement.executeQuery("SELECT * FROM usuarios");`
* Crear un registro:
`String sql = ("INSERT INTO usuarios (login, password, nickname, email) VALUES (?, ?, ?, ?)");`
`myStamt = myConn.prepareStatement(sql);`
`myStamt.setString(1,"lucas");`
`myStamt.setString(2,"15ds#$%");`
`myStamt.setString(3,"lukitas");`
`myStamt.setString(4,"[email protected]");`
* Actualizar un registro:
`int rowsAffected = myStamt.executeUpdate(`
` "UPDATE usuarios " +`
` "set email='[email protected]' " +`
` "WHERE login='lucas'"`
`);`
* Borrar un registro:
`int rowsAffected = myStamt.executeUpdate(`
` "DELETE FROM usuarios " +`
` "WHERE login='lucas'"`
`);`
# Borrar un Registro de la Base de datos
SQL:
`DELETE FROM table_name WHERE condition;`
JAVA + JDBC:
`int rowsAffected = myStamt.executeUpdate(`
` "DELETE FROM usuarios " +`
` "WHERE login='lucas'"`
`);`
Exitoso
// Actualizar
int rowsAffected = myStamt.executeUpdate(“UPDATE employees SET name = ‘Victoria Soto’ WHERE nombre = ‘Luis’”);
if (rowsAffected > 0) {
System.out.println(“Empleado(s) actualizado(s) correctamente.”);
}
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?