Contenido del curso
Daniel Carmona
Alan Torres
Kevin Ardila
Gever Rodriguez
Jose Alexis Nuñez Torres
DUVAN ALEXIS HENAO GOMEZ
Jhon Neira
Brayan Lopez
Paul Flores
Platzi
Edwin Garcia Quiterio
Patrick Jhonatan Hernandez Blanco
Jan Cobian
Xavier Armando Larios Alvarenga
Yhordi Choque Espinoza
Daniel Santiago Aguilera Juspian
Oscar Chavez
Milton Hernan Camacho Quitian
ANDRES ALFONSO MIRA MEJIA
Yhordi Choque Espinoza
Edwin Perez
Jesús Patricio Pereira Matus
Kevin Vega
David Esteban Giraldo Duque
Edwin Perez
Rigoberto Acosta González
Estuvo bueno el ejercicio de borrar un usuario!
xD
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!
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(); }
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
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'");
Te pasa porque el id es int y lo estas poniendo como string
Realmente te está pasando porque al concatenar no tienes en cuenta los espacios, entonces tu consulta termina siendo así:
UPDATE pbset correo='micorreo.com'WHERE id = '01'.
Una sola pregunta me surgió ¿Cúal sería la razón de concatenar el executeUpdate?
Muy buena clase y gran curso en lo que va! un gran saludo
La razón de concatenar el executeUpdate es para ejecutar una sentencia SQL que modifique los datos en la base de datos, como insertar, actualizar o eliminar registros.
Se utiliza para Crear, Actualizar y Eliminar registros, cuando se ejecuta una de estas acciones te retorna un entero que hace referencia al número de filas afectadas, cuantos registros insertaste, cuantos actualizaste o cuantos eliminaste.
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í
Asi es como la maestra debio haber hecho el curso
Para realizar un update, es preferible utilizar PreparedStatement en lugar de Statement. La razón principal es que PreparedStatement ofrece seguridad contra inyecciones SQL y mejora el rendimiento en situaciones donde se ejecutan múltiples consultas similares, ya que permite precompilar la consulta. Además, permite establecer parámetros de manera más sencilla y clara.
Aquí tienes un ejemplo de cómo se usaría PreparedStatement para un update:
String sql = "UPDATE employees SET email = ? WHERE firstName = ?"; PreparedStatement pstmt = myConn.prepareStatement(sql); pstmt.setString(1, "joanna2.com"); pstmt.setString(2, "Joana"); pstmt.executeUpdate();
Esto es más seguro y eficiente en comparación con el uso de Statement, especialmente al manejar variables.
quien mas elimino a Jane xd
<3
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
aca para limpiar un poco mas las queries dependiendo de la version de Java
Inicialmente se tenían estos datos en la BD:
Luego se hizo la eliminación del segundo registro:
✅
quien elimino su tabla por error?
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()); } } }
para la resolucion del problema pense, busque si habian en el Statement un executeDelete lo cual no habia y en temas de logica dije "Bueno si no hay un delete sera un update porque eliminar es una actualizacion de la tabla" y en efecto funciono con un execute Delete con el parametro sql de DELETE FROM employees WHERE first_name = 'Johana' por lo cual era pensar y revisar metodos y entender que statement es para consultas fijas xd
executeUpdate -> usar para insertar, actualizar y eliiminar
executeQuery -> para consultar :)
import java.sql.*; public class Main { public static void main(String[] args) { Connection myConn = null; PreparedStatement myStmt = null; ResultSet myRs = null; try { myConn = DriverManager.getConnection("jdbc:postgresql://localhost:5432/personal", "postgres", "12345678"); System.out.println(":: Connected to database"); String sql = "DELETE FROM employees WHERE email = ?"; myStmt = myConn.prepareStatement(sql); myStmt.setString(1, "john.doe@example.com"); int rowsAffected = myStmt.executeUpdate(); if (rowsAffected > 0) { System.out.println("Rows affected: " + rowsAffected); } else { System.out.println("No rows affected"); } myStmt = myConn.prepareStatement("SELECT * FROM employees"); myRs = myStmt.executeQuery(); while (myRs.next()) { System.out.println(myRs.getString("first_name") + " " + myRs.getString("pa_surname") + " - " + myRs.getString("email")); } myConn.close(); } catch (SQLException e) { e.printStackTrace(); System.out.println("Something went wrong"); } } } ```import java.sql.\*; public class Main {   public static void main(String\[] args) {   Connection myConn = null;   PreparedStatement myStmt = null;   ResultSet myRs = null;   try {   myConn = DriverManager.*getConnection*("jdbc:postgresql://localhost:5432/personal", "postgres", "12345678");   System.*out*.println(":: Connected to database");   String sql = "DELETE FROM employees WHERE email = ?";   myStmt = myConn.prepareStatement(sql);   myStmt.setString(1, "john.doe@example.com");   int rowsAffected = myStmt.executeUpdate();   if (rowsAffected > 0) {   System.*out*.println("Rows affected: " + rowsAffected);   } else {   System.*out*.println("No rows affected");   }   myStmt = myConn.prepareStatement("SELECT \* FROM employees");   myRs = myStmt.executeQuery();   while (myRs.next()) {   System.*out*.println(myRs.getString("first\_name") + " " + myRs.getString("pa\_surname") + " - " + myRs.getString("email"));   }   myConn.close();   } catch (SQLException e) {   e.printStackTrace();   System.*out*.println("Something went wrong");   }   } }
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()); } } }
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.
