Ejercicio. JDBC API

Acá dejo mi version del código que realiza la consulta con filtros a una Base MariaDB.

import java.sql.*;

public class GuitarJDBC {

    static final String driver = "com.mysql.cj.jdbc.Driver";
    static final String url = "jdbc:mysql://localhost:3306/GUITARS_SAMPLE";
    static final String user = "DB_ADMIN";
    static final String pass = "Mariadb";
    static final String query = "select Id, Name from guitar where IsPremium = (select IsPremium from client where Id=?)";

    public static void executeQuery(String IdUser) {
        try {
            Class.forName(driver);
            Connection connection = DriverManager.getConnection(url, user, pass);
            PreparedStatement preparedStatement = connection.prepareStatement(query);
            preparedStatement.setString(1, IdUser);
            ResultSet resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                int id = resultSet.getInt("Id");
                String name = resultSet.getString("Name");
                System.out.println("ID: " + id + " NAME: " + name);
            }
            resultSet.close();
            preparedStatement.close();
            connection.close();
        } catch (SQLException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

El elemento especificamente que utilicé para la consulta con filtros fué: preparedStatement.setString(1, IdUser); el que me permitió enviar el parametro que se reemplaza por el signo ? en el query: select Id, Name from guitar where IsPremium = (select IsPremium from client where Id=?)

La ejecución de la clase se realiza con la linea: GuitarJDBC.executeQuery(“44”); el numero 44 es el Id de un cliente premium, y el 11 es el de uno no premium.

Acá dejo también el script de la BD con la info de prueba: sqlFile

Los elementos JDBC que debemos usar en orden para ejecutar esta sentencia son:

DriverManager: Para manejar la base de datos.
Conecction: Para conectarnos a la base de datos.
PreparedStatement: Para crear una sentencia de tipo “Select * From” con filtros de tipo "Where"
ExecuteQuery: Para ejecutar sentencias de tipo select.
Resultset: Para capturar los datos devueltos por la BBDD debido al select ejecutado.

Para el reto se implementa una clase anidada con los atributos de la guitarra y se crea un método para realizar la consulta de las guitarras filtrando por el usuario y la suscripción:

private void conexionBaseDatos(){

try { 
	Connection  cn = DriverManager.getConnection ("jdbc:mysql://localhost/nombreBD", "usuario", 'passwors');
	PreparedStatement pst = cn.preparedStatement ("select * from  tabla where campo = ?");
	pst.setString(1 , parametroRecibido.getText().trim());
	
	resultSet = pst.executeQuery();
	catch{
		
		
	}
	
}

}

PreparedStatement
ExecuteQuery
Resultset

preparedStatement, executeQuery

PrepareStatement y Execute Query

Preparedstatement, executeQuery y ResultSet

PreparedStatement

Buen día comunidad. Se podria utilizar PreparedStatement para preprarar la consulta y el metodo executeQuery para ejecutar la consulta.

Los elementos JDBC que se deben usar para ejecutar la consulta
preparedStatement permite realiza la consulta que permite recibir parametros en el where
resultSet permite obtener los registros y tratarlo como objetos

String sqlString = “Select * FROM Guitarras WHERE usuarios LIKE ‘Premium’”;
Result rs = stmt.executeQuery(sqlString);

—> Prepared Statement
—> Execute Query
—>Result Set

Usaría executeQuery o execute depende y tuviera que hacer un JOIN o no en la consulta.Por supuesto el preparedStatement con la consulta adecuada, y el resultset de la guitarras. El filtro sería tener el tipo de usuario del usuario en sesión y ponerlo como filtro en la consulta a las guitarras en el where.

ConnectionJDBC.java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionJDBC {
    
	public static final String DRIVER = "com.mysql.cj.jdbc.Driver";
	public static final String URL = "jdbc:mysql://localhost:3306/clients";
	public static final String USER = "root";
	public static final String PASSWORD = "root";
	
	public static Connection getConnection() {
		Connection con = null;
		try{
			Class.forName(DRIVER);
			con = DriverManager.getConnection(URL, USER, PASSWORD);
		}catch(ClassNotFoundException e){
			System.out.println("Clase " + DRIVER + "no encontrada en el driver... " + e);
		}catch(SQLException e) {
			System.out.println("Error obteniendo conexión... " + e);
		}
		return con;
	}
}

Guitar.java

public class Guitar {
	
	private int id;
	private String name;
	private String modality;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getModality() {
		return modality;
	}
	public void setModality(String modality) {
		this.modality = modality;
	}
}

CRUD.java

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class CRUD {

	public static final String QUERY_USERS = "select modality from users where id = ?";
	public static final String QUERY_GUITARS = "select * from guitars where modality = ?";
	
	public static String getMembershipUser(int userId) {
		PreparedStatement st = null;
		ResultSet rs = null;
		String membership = null;
		
		try (Connection con = ConnectionJDBC.getConnection()){
			st = con.prepareStatement(QUERY_USERS);
			st.setInt(1, userId);
			rs = st.executeQuery();
			while (rs.next()) {
				membership = rs.getString("modality");
			}			
		} catch (SQLException e) {
			System.out.println("Ha ocurrido un error... " + e);
		}
		return membership;
	}
	
	public static List<Guitar> getGuitarsOfAnMembership(String membership) {
		PreparedStatement st = null;
		ResultSet rs = null;
		List<Guitar> guitars = new ArrayList<Guitar>();
		
		try (Connection con = ConnectionJDBC.getConnection()){
			st = con.prepareStatement(QUERY_GUITARS);
			st.setString(1, membership);
			rs = st.executeQuery();
			while (rs.next()) {
				Guitar guitar = new Guitar();
				guitar.setId(rs.getInt("id"));
				guitar.setName(rs.getString("name"));
				guitar.setModality(rs.getString("modality"));
				membership = rs.getString("modality");
				guitars.add(guitar);
			}			
		} catch (SQLException e) {
			System.out.println("Ha ocurrido un error... " + e);
		}
		return guitars;
	}
}

Main.java

import java.util.List;

public class Main {
	
	public static void main(String[] args) {
		String membership = CRUD.getMembershipUser(3);
		List<Guitar> guitarras = CRUD.getGuitarsOfAnMembership(membership);
		
		for (Guitar guitar : guitarras) {
			System.out.println("-------------");
			System.out.println(guitar.getId());
			System.out.println(guitar.getName());
			System.out.println(guitar.getModality());
			System.out.println("-------------");
		}
	}
}

De acuerdo a la clase anterior debe ser con ** PrepareStatement, executeQuery** para ejecutar la consulta y **Resultset ** para almacenar los registros que cumplen con la sentencia dada.

public List<Guitar> getGuitarsByUserStatus(String status) {
	List<Guitar> guitars = new ArrayList<Guitar>();

	Try.of( () -> {
		Connection connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/gibsondb","slasher","1408");
		PreparedStatement ps;

		ps = connection.preparedStatement("SELECT * FROM guitar WHERE status = " + status);

		ResultSet rs = ps.executeQuery();

		while(rs.next()) {
			Guitar guitar = new Guitar();
			guitar.setName(rs.getString("name"));
			guitar.setStatus(rs.getString("status"));
			guitars.add(guitar);
		}
	}).onFailure( exception -> {
exception.printStackTrace()
	}).andFinaly( () -> { 
		connection.close(); 
		rs.close();
	});

	return guitars;
}

preparedStatement + executeQuery

PreparedStatement + Execute Query

PreparedStatement

PreparedStatement

Driver Manager, Conencection, PreparedStatment y ResulltSet

PreparedStatement

PreparedStatement() y executeQuery()

Debería usar preparedStatement

select * from guitarra, usuario where guitarra.type = "premium" AND usuario.membresia = "premium";```

PrepraredStatement

En este caso seria preparedStament

PreparedStatement guitaras= cn.preparedStatement(“Select * from guitarra, usuario where guitarra.tipo = premium AND usuario.tipo = premium”);

ResultSet rs = guitaras.executeQuery();

rs.close();
cn.close();

executeQuery()

PreparedStatement

Statemente.

Lo que se comento en la clase es que el elemento statemen nos permite colocar elementos en el where por lo tanto, con el podemos ejecutar el

select * from guitarra where menbresia = “premium”;

Se utilizaría el PreparedStatement en conjunto con executeQuery , para poder indicar la consulta de tipo SQL e indicar el tipo de guitarras(Premium).

Clases Java Database Connectivity.
DriverManager: Para cargar un driver.
Connection: Para establecer conexiones con las bases de datos.
Statement: Para ejecutar sentencias SQL y enviarlas a las BBDD.
PreparedStatement: La ruta de ejecución está predeterminada en el servidor de base de datos que le permite ser ejecutado varias veces.
ResultSet:Para almacenar el resultado de la consulta.

PrepareStatement y executeQuery

PrepareStatement
Coneccion conn= …
guitarras = conn.PrepareStatement("select * from gutarras where tipo =“premium” ")

PrepareStatement
select * from guitarras where tipo=‘premium’

Usaría PreparedStatement, teniendo en cuenta añadir a la consulta los datos que nos permitirán filtrar los datos.

se utiliciaria un PREPAREDSTATEMENT

select * from guitarras where user.getUserMembreship = premium; 

Utilizar
WHERE
También se utilizaría el PreparedStatement en conjunto con executeQuery , para poder indicar en el WHERE de la consulta que clase de guitarras se necesitan dependiendo de que tipo de usuario sea

PreparedStatement

string = "Select * from guitarra where user_id = 1 and premium= 123"
prepareStatement(string );
executeQuery();

Con el PreparedStatement.

PreparedStatement que es el elemento que recibe parámetros para la consulta.

ResultSet, en donde te permite aplicar Where, para relizar los filtros correspondientes en la consulta sql.

preparedStatement
Por que nos permite pasar parametros

¿Qué elemento de JDBC deberás usar para ejecutar una consulta con filtros?

PreparedStatement

select * from guitarra, usuario where guitarra.type = "premium" AND usuario.membresia = "premium";

El elemento JDBC para ejecutar la consulta es executeQuery(sqlString)

<String query=”select * from guitarras where campoidentificador="premiun"”;
	PreparedStatement prs=cnx.executeQuery(query);

>

Se debe utilizar el elemento ResultSet, ya que se va a enviar un query que deberia devolver un conjunto de datos.

Objetos de tipo Connection, **ResultSet **y PreparedStatement, ya que depende del tipo de membresia el query que se va a ejecutar.

PreparedStatement

Utilizaría PreparedStatement ya que éste nos permite filtrar mediante la cláusula where los datos.

		//código para conectarse a la DB
		PreparedStatement guitarrasPremium;
		ResultSet guitarrasPremiumList;
		guitarrasPremiumList = guitarrasPremium.executeQuery("select * from Guitarras where clasificacion = 111");
		PreparedStatement usuariosPremium;
		ResultSet usuariosPremiumList;
		usuariosPremiumList = usuariosPremium.executeQuery("select * from Usuarios where membresia = CON");
		

PreparedStatement
ExecuteQuery
Resultset

PreparedStatement

Utilizaría el elemento PreparedStatement junto con el método exexuteQuery y la sentencia SQL adecuada, de esta manera se puede extraer la información sobre guitarras y usuarios premium.

PreparedStatment y ResulltSet

un Conection
un PreparedStatement
y un ResultSet

PreparedStatement por que en la consulta sql usaremos “WHERE”

PreparedStatement

executeQuery(“query”) creando un objeto statement ej:

Statement s = conexion.createStatement(); 
c rs = s.executeQuery ("select * from usuarios, guitarras where usuario=premium AND guitarra=premium");

• Falta el try-catch

• PreparedStatement
• ExecuteQuery
  ResulSet

    public void metodo() {
        // PreparedStatement pstGuitarras =null;
        final String sql = "select * from guitarra, usuario where guitarra.tipo = premium AND usuario.tipo = premium";
        Connection cn ;
        PreparedStatement pstGuitarras;
        try (cn = DriverManager.getConnection("jdbc:mysql://localhost:3304/catalogo", " root", ""); pstGuitarras = cn.preparedStatement(sql);) {
            ResultSet rs = pstGuitarras.executeQuery();
            while (rs.next()) {
            }
        } catch (SQLException e) {
            System.err.println(" Error: " + e);
        }
    }

VERSION MEJORADA
Esta versión la mejoré de acuerdo a comentarios que vi de los demás compañeros.

ConnectionJDBC.jdbc

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionJDBC {
    
	public static final String DRIVER = "com.mysql.cj.jdbc.Driver";
	public static final String URL = "jdbc:mysql://localhost:3306/clients";
	public static final String USER = "root";
	public static final String PASSWORD = "root";
	
	public static Connection getConnection() {
		Connection con = null;
		try{
			Class.forName(DRIVER);
			con = DriverManager.getConnection(URL, USER, PASSWORD);
		}catch(ClassNotFoundException e){
			System.out.println("Clase " + DRIVER + "no encontrada en el driver... " + e);
		}catch(SQLException e) {
			System.out.println("Error obteniendo conexión... " + e);
		}
		return con;
	}
}

CRUD.java

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class CRUD {

	public static final String QUERY_USERS_GUITARS = "select * from guitars where modality = (select modality from users where id = ?)";
	
	public static List<Guitar> getGuitarsOfAnMembership(int userId) {
		PreparedStatement st = null;
		ResultSet rs = null;
		List<Guitar> guitars = new ArrayList<Guitar>();
		
		try (Connection con = ConnectionJDBC.getConnection()){
			st = con.prepareStatement(QUERY_USERS_GUITARS);
			st.setInt(1, userId);
			rs = st.executeQuery();
			while (rs.next()) {
				Guitar guitar = new Guitar();
				guitar.setId(rs.getInt("id"));
				guitar.setName(rs.getString("name"));
				guitar.setModality(rs.getString("modality"));
				guitars.add(guitar);
			}			
		} catch (SQLException e) {
			System.out.println("Ha ocurrido un error... " + e);
		}
		return guitars;
	}
}

Guitar.java

public class Guitar {
	
	private int id;
	private String name;
	private String modality;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getModality() {
		return modality;
	}
	public void setModality(String modality) {
		this.modality = modality;
	}
}

Main.java

import java.util.List;

public class Main {
	
	public static void main(String[] args) {
		List<Guitar> guitarras = CRUD.getGuitarsOfAnMembership(3);
		
		for (Guitar guitar : guitarras) {
			System.out.println(guitar.getId());
			System.out.println(guitar.getName());
			System.out.println(guitar.getModality());
			System.out.println("-------------");
		}
	}
}

usaria el executeQuery

para ejecutar la consulta la realizaría con executeQuery(si fuera un select where) pero si tambien necesito hacer un join utilizaria execute

Para ello sería adecuado utlilizar PreparedStatemet, dado que nos permite recibir y manejar los parámetros deseados.

PrepareStatement con executeQuery y Resultset.

El elemento JDBC que permite hacer una consulta es statement y para agregarle un filtro a los datos que se quieren traer se utiliza PreparedStetement.

Usaria un preparedStatement y el código sería el siguiente:

String consulta = "select * from guitar where membresyType = (select membresyType from users where userName = ?) ";
Connection conexion= DriverManager.getConnection(“jdbc:mysql://localhost/prueba”, “root”, “root”);
PreparedStatement sentencia= conexion.prepareStatement(consulta);
sentencia.setString(1, “pepe”);
ResultSet rs = sentencia.executeQuery();

1. PrepareStatement
2. ExecuteQuery
3. ResultSet

prepareStatement:

select g.*
from usuarios u,
guitarras_usuario gu,
user_types ut
where gu.user_id=u.user_id
amd gu.user_name=nvl(😛_USER_NAME,g.user_name)
and u.user_type_id=ut.user_type_id
and ut.user_type_name=:P_USER_TYPE;

Para la definir la consulta con filtros se debe usar prepareStatment y para ejecutar los datos executeQuery y para obtener los datos Resultset.

PrepareStatement y executeQuery

Connection conn = getConnection();
try(PreparedStament ps = conn.prepareStatement("select * from guitars where tipo_premium = ?") {
	// asumiendo que tipo_premium es boolean
	ps.setBoolean(1, tipoGuitarra); // parámetro del método
	ResulSet rs = ps.executeQuery();
	while(rs.next) {
		// continue code here ... 
	} 
} catch(SQLException e) {
	// code here
} 

Se puede hacer con un Statement normalmente pero con un PreparedStatement podemos agilizar las consultas debido a que la base de datos genera un hash específico para solo cambiar los parametros (En este caso el usuario), usamos tambien ExecuteQuery y lo almacenamos en un ResultSet debido a que es una consulta simple.

PreparedStatement
ExecuteQuery
Resulset

PreparedStatement
ExecuteQuery
Resulset

nada me traeria los usuarios premium y filtraria por el usuario logeado en el momento, luego haria un join cn la tabla donde se almacenan las guitarras por tipo premium y mostraria ese resultado.
select g.*
from usuarios u,
guitarras_usuario gu,
user_types ut
where gu.user_id=u.user_id
amd gu.user_name=nvl(😛_USER_NAME,g.user_name)
and u.user_type_id=ut.user_type_id
and ut.user_type_name=:P_USER_TYPE;

Suponiendo que el atributo “membresia” de la entidad “usuario”, me indica si es el usuario es premiun y si podrá ver las guitarras premiun. La tabla donde se encuentran las guitarras se llamará asi, “guitarras”.

executeQuery(select * from guitarras where membresia = “premium”)

PreparedStatement

se debe de usar un PreparedStatement

PreparedStatement ps = new PreparedStatement();
ps.setString(1,“PREMIUM”);
Resultset rs = ps.executeQuery(“Select * from guitarras where tipo = ?”);

Connection conexion = new getConnection();
String tipoGuitar = getTipoGuitar();
PreapredStatement prestat = new PreparedStatement("Select * From guitar where tipo guitar = " + tipoGuitar)

try(prestat){

Resulset rsguitar = prestat.executeQuery();
while(rsguitar.next()){

}

}catch(SQLexception e){

}

PreparedStatement: para colocar el SELECT que se ejecutará.
ExecuteQuery: para ejecutar la consulta definida en PreparedStatement.
ResultSet: para mostrar los resultados de la consulta.

Genial.

PrepareStatement

PreparedStatement

PreparedStatement

PREPAREDSTATEMENT 😃

PreparedStatement

PreparedStatement, ExecuteQuery y Resultset

Definir sentencia SQL PreparedStatement
Ejecutar la consulta con ExecuteQuery
Mostrar resultados ResultSet

Un prepared statement para posteriormente utilizar un resultset para manipular los datos obtenidos.

Sería PreparedStatement que recibiría mi consulta ya armada con los parámetros necesarios para recuperar la información solicitada.

PreparedStatement

PreparedStatement,executeQuery

PreparedStatement, ExecuteQuery

PreparedStatement,executeQuery

preparedStatement, executeQuery