Actualizar y eliminar datos con JDBC

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'");

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!

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

```js import java.sql.PreparedStatement; public class Actualizar { //Variables static String sql = ("UPDATE Docentes " + "SET apellido = 'MARULANDA FERIA' " + "WHERE id_docente = 52939392"); static PreparedStatement preparedStatement; //Método para actualizar public static void actualizar() { try { preparedStatement = Conectar.connection.prepareStatement(sql); preparedStatement.executeUpdate(); System.out.println("Datos actualizados correctamente"); } catch (Exception e) { System.out.println("Error al actualizar: " + e.getMessage()); } } } ```

Yo opté por separar mi código de una manera más ordenada, quedando así  Y en el main solo mando a llamar lo que ocupo, así 

```java myStmt = myConn.createStatement(); myRes = myStmt.executeQuery("SELECT * FROM usuarios"); while (myRes.next()){ System.out.println(myRes.getString("name")); } int rowsAffected = myStmt.executeUpdate("DELETE FROM usuarios WHERE name='Ernesto'"); if(rowsAffected > 0){ System.out.println("Se ha eliminado correctamente 👍👍"); } myRes = myStmt.executeQuery("SELECT * FROM usuarios"); while (myRes.next()){ System.out.println(myRes.getString("name")); } ``` Mi humilde aporte.

Como sugerencia sería bueno que los ejercicios se fueran versionando en diferentes archivo por clase 😎

```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

# 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'"` `);`

// 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.”);
}

```js import java.sql.PreparedStatement; import java.sql.SQLException; import java.sql.SQLOutput; public class Eliminar { //Variables static String sql = ("DELETE FROM Docentes WHERE id_docente = ?"); static PreparedStatement preparedStatement; //Método para eliminar public static void eliminar(String id_docente) { try { preparedStatement = Conectar.connection.prepareStatement(sql); preparedStatement.setString(1, id_docente); preparedStatement.executeUpdate(); System.out.println("Datos eliminados correctamente"); } catch (SQLException e) { System.out.println("Error al eliminar: " + e.getMessage()); } } } ```

```js import java.sql.PreparedStatement; import java.sql.SQLException; public class Actualizar { //Variables static String sql = ("UPDATE Docentes " + "SET apellido = ?, nombre = ? " + "WHERE id_docente = ? "); static PreparedStatement preparedStatement; //Método para actualizar public static void actualizar(String apellido, String nombre, String id_docente) { try (PreparedStatement preparedStatement = Conectar.connection.prepareStatement(sql)) { preparedStatement.setString(1, apellido); preparedStatement.setString(2, nombre); preparedStatement.setString(3, id_docente); preparedStatement.executeUpdate(); System.out.println("Datos actualizados correctamente"); } catch (SQLException e) { System.out.println("Error al actualizar: " + e.getMessage()); } } } ```

```js import java.sql.PreparedStatement; public class Agregar { //Variables static String sql = "INSERT INTO Docentes (id_docente, apellido, nombre) VALUES (?,?,?)"; static PreparedStatement preparedStatement; //Método para agregar public static void agregar(String id_docente, String apellido, String nombre) { try { preparedStatement = Conectar.connection.prepareStatement(sql); preparedStatement.setString(1, id_docente); preparedStatement.setString(2, apellido); preparedStatement.setString(3, nombre); preparedStatement.executeUpdate(); System.out.println("Datos agregados correctamente"); } catch (Exception e) { System.out.println("Error al agregar: " + e.getMessage()); } } } ```

```js import java.sql.Connection; import java.sql.DriverManager; public class Conectar { //Variables static Connection connection = null; static String url = "jdbc:mysql://localhost:3306/prueba"; static String user = "root"; static String password = "3179Musica"; //Método para conectar public static void conectar() { try { connection = DriverManager.getConnection(url, user, password); System.out.println("Conectado a la base de datos"); } catch (Exception e) { System.out.println("Error al conectar con la base de datos: " + e.getMessage()); } } } ```

```js import java.sql.Connection; import java.sql.DriverManager; public class Conectar { //Variables static Connection connection = null; static String url = "jdbc:mysql://localhost:3306/prueba"; static String user = "root"; static String password = "3179Musica"; //Método para conectar public static void conectar() { try { connection = DriverManager.getConnection(url, user, password); System.out.println("Conectado a la base de datos"); } catch (Exception e) { System.out.println("Error al conectar con la base de datos: " + e.getMessage()); } } } ```