Formación informática

Java | Joomla | MySQL

Curso de Java - Tema 32.3: realizando consultas SQL puras

¿Has estado en Mondoñedo?

Sin lugar a dudas es la tarea más común que hay que realizar cuando se trabaja con bases de datos puesto que es el método que implementa el lenguaje SQL para extraer los datos almacenados en nuestra base de datos.

Código para realizar consulta en MySQL

Según el manual de uso de MySQL en la versión 5.7 la instrucción para realizar consultas es:

SELECT            

[ALL | DISTINCT | DISTINCTROW ]

[HIGH_PRIORITY]

[STRAIGHT_JOIN]

[SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]

[SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]

select_expr [, select_expr ...]

[FROM table_references

[PARTITION partition_list]

[WHERE where_condition]

[GROUP BY {col_name | expr | position}

[ASC | DESC], ... [WITH ROLLUP]]

[HAVING where_condition]

[ORDER BY {col_name | expr | position}

[ASC | DESC], ...]

[LIMIT {[offset,] row_count | row_count OFFSET offset}]

[PROCEDURE procedure_name(argument_list)]

[INTO OUTFILE 'file_name'

[CHARACTER SET charset_name]

export_options

| INTO DUMPFILE 'file_name'

| INTO var_name [, var_name]]

[FOR UPDATE | LOCK IN SHARE MODE]]

Vemos que la potencia de esta instrucción es brutal puesto que nos permite filtrar, agrupar, ordenar y mucho más. Aunque parece muy compleja es muy sencilla de usar cuando se conoce para que sirve cada una de las claúsulas, siendo las más usadas WHERE, GROUP BY, HAVING y ORDER BY.

Es importante conocer bien la sintaxis para realizar consultas de selección puesto que uno de los fallos más comunes a la hora de trabajar con bases de datos es escribir mal la consulta bien en el orden de los modificadores bien en el nombre de los campos. Hay que recordar que aquí vamos a aprender a realizar consultas puras de SQL, sin usar variables Java.

Realizar consultas en NetBeans

NetBeans dispone de una consola para ejecutar comandos en lenguaje SQL. De esta forma podemos comprobar de una forma sencilla e integrada con NetBeans que los resultados devueltos son correctos. De esta forma, nos evitamos tener que abrir el S.G.B.D. para ejecutar en él las consultas.

Se accede a ella, haciendo click derecho sobre la conexión de la base de datos en la ventana Prestaciones y elegiendo Ejecutar Comando. Así obtenemos la pestaña siguiente dónde podemos escribir SQL la consulta SQL cuyo funcionamiento queremos comprobar.

Acceso a ejecutar comando SQL en Netbeans

La ventana está dividada en dos zonas principales. En la zona superior aparece el área de texto dónde podemos escribir la sentencia SQL cuyo funcionamiento queremos comprobar con muchos botones con funciones distintas pero el que usaremos con mayor frecuencia será el de lanzar la consulta, el primero de ellos. Cuando ejecutemos una consulta, en la parte inferior nos aparecerá el resultado de la consulta y datos sobre el rendimiento de la misma.

Ejecucíon consulta SQL en NetBeans

Realización de consulta y mostrar el resultado por línea de comandos

Este proceso nos vale para realizar consultas que usan sólamente el lenguaje SQL para recuperar los datos, pudiendo incluir tantas claúsulas cómo sea necesario, y mostrar el resultado a través de la línea de comandos. En ningún caso podremos usar variables para insertar valores puesto que se hace con otro tipo de objeto: un Prepared Statement, que veremos más adelante.

El proceso para mostrar por línea de comandos el resultado de una consulta sobre una tabla o varias tablas consiste en crear en la clase ManejadorBaseDatos un método, con el nombre y el tipo de objeto devuelto adecuado, de la siguiente forma:

  1. Inicializamos un objeto de tipo colección nulo que contendrá el JavaBean correspondiente a la tabla sobre la que se realizará la consulta. Esto es útil cuando se realizan consultas sobre una tabla y usamos el JavaBean. Si vamos a realizar consultas sobre varias tablas, tendremos que usar variables temporales del tipo adecuado que almacenen el valor devuelto por la ejecución de la consulta.
  2. El objeto Connection nos permitirá gestionar la conexión. Lo inicializamos con el método conector creado antes. Para evitar errores, el primer paso consiste en comprobar que la conexión no esté cerrada, dicho de otro modo, que exista este objeto. En caso positivo, la aplicación pasará al siguiente punto. En caso negativo, mostraremos un mensaje de error que informe adecuadamente del problema para que compruebe las credenciales del usuario. Usaremos el método createStatement del objeto Connection que enviará la consulta a la base de datos.
  3. Usaremos los métodos de la interface Statament para ejecutar la consulta y obtener el valor devuelto por la base de datos. Usaremos el método executeQuery para ejecutar la consulta almacenada en la variable y que nos devuelva un objeto ResultSet, que usaremos a continuación.
  4. Usaremos un variable de tipo String para almacenar la consulta SQL que queremos ejecutar.
  5. Usaremos la interface ResultSet para convertir en una tabla el resultado de la consulta devuelto por el método executeQuery de la interface Statement. Esta interface mantiene un cursor de avance que apunta al registro correspondiente de la base de datos, que inicialmente apunta a la fila cero. El método next mueve el cursor a la siguiente fila y devuelve false cuando el objeto ResultSet ha alcanzado el final del resultado devuelto por la consulta. Mediante un bucle while, usando el método next, realizamos el tratamiento del resultado devuelto.
  6. Dentro del bucle, usaremos los métodos get de cada tipo de dato que tiene la clase ResultSet para recuperar los datos de la tabla, al que indicaremos el nombre del campo del cuál vamos a recuperar los datos.
  7.      Cuando realizamos consultas sobre una tabla usaremos el método constructor adecuado del JavaBean correspondiente que hemos creado anteriormente para guardar los datos en un objeto de tipo colección: ArrayList, HashMap...

         Cuando realizamos consultas sobre varias tablas tenemos que usar variables correspondientes al tipo de datos devuelto por la consulta para almacenar los resultados.

         Algunos ejemplos de métodos get son:

    	resultado.getInt("nombre_del_campo_en la_tabla")
    	resultado.getBoolean("nombre_del_campo_en la_tabla")
    	resultado.getDouble("nombre_del_campo_en la_tabla")
    	resultado.getFloat(" nombre_del_campo_en la_tabla t")
    	resultado.getString("nombre_del_campo_en la_tabla")
    
  8. Por último, para liberar los recursos usados durante el proceso cerramos los objetos ResultSet, Statament y Connection que hemos creado. De esta forma evitamos el acceso a la base de datos y cualquier modificación sobre los valiosos datos que contiene.

En el método principal realizamos el tratamiento adecuado al caso:

  1. En el caso consultas sobre una sola tabla, usaremos un objeto de tipo colección para almacenar los valores devueltos por la base de datos para mostrarlos por la línea de comandos usando el cursor que recorre la respuesta de la consulta.
  2. En el caso de consultas sobre varias tablas, usaremos variables del tipo correspondiente al tipo de dato del campo de la base de datos.

Veamos el proceso tanto escrito con sintaxis genérica como usando nuestra base de datos de ejemplo de los Municipios de España.

Clase ManejadorBaseDatos

Tendremos que crear en esta clase tantos métodos distintos como consultas vayamos a realizar sobre la base de datos. Después los usaremos en la clase principal mediante la instanciación de un objeto de la clase ManejadorBaseDatos en ella.

Para realizar la consulta y almacenar el resultado necesitamos una variable, tres clases y realizar el tratamiento de excepciones que se produce en el proceso:

La sintaxis genérica del método para recuperar datos de una sola tabla usando un JavaBean sería:

public nombre_tabla nombreMetodo() {
	JavaBeanTabla identificador = null;
	Connection conexion = conector();
	if (conexion != null) {
	try {
		Statement consulta = conexion.createStatement();
		String sql = "consulta sql";
		ResultSet resultado = consulta.executeQuery(sql);
		while (resultado.next()) {
			objetoColeccion.métodoAñadir(
				new objetoJavaBean(
				rs.getInt("nombre_del_campo_en la_tabla"),
				rs.getInt("nombre_del_campo_en la_tabla"),
				rs.getString("nombre_del_campo_en la_tabla") 
				)
			);
		}
	resultado.close();
	consulta.close();
	conexion.close();
	} catch (SQLException ex) {
		System.out.println(ex.getMessage());
	}
	} else {
		System.out.println("Conexión no disponible. Compruebe los datos de conexión");
		}
	return nombre_tabla;
}

Así, por ejemplo, para recuperar un listado que muestre por línea de comandos todas las Comunidades Autónomas de España tenemos que escribir el siguiente método en el cuál usamos un ArrayList para almacenar los datos devueltos por la base de datos usando el JavaBean que hemos creado antes:

¡Atención si copias y pegas este código! Por motivos técnnicos no puedo escribir el operador diamante > del ArrayList

public ArrayList Comunidad listadoComunidades() {
        /*Instanciamos un ArrayList que guardará objetos de la clase Comunidad*/
        ArrayList Comunidad () ="" ;
        /*Realizamos la conexión con la base de datos usando el método conector*/
        Connection conexion = conector();
        /*Comprobamos si existe la condición para realizar el tratamiento adecuado*/
        if (conexion != null) {
            try {
                /*Creamos la conexión para hacer la consulta*/
                Statement consulta = conexion.createStatement();
                /*Creamos la consulta sql en una variable de tipo String*/
                String sql = "select * from comunidad";
                /*Ejecutamos la consulta y recuperamos los datos*/
                ResultSet resultado = consulta.executeQuery(sql);
                while (resultado.next()) {
                    /*Guardamos en una variable temporal los resultados*/
                    String codigoComunidad = resultado.getString("codigo_comunidad");
                    String comunidad = resultado.getString("comunidad");
                    /*Instanciamos un objeto de tipo Comunidad con los datos 
							  devueltos por la base de datos*/
                    Comunidad c = new Comunidad(codigoComunidad, comunidad);
                    /*Guardamos los datos del objeto en el ArrayList */
                    comunidadesAlfabetico.add(c);
                }
                /*Para liberar recursos cerramos los objetos*/
                resultado.close();
                consulta.close();
                conexion.close();

            } catch (SQLException ex) {
                System.out.println(ex.getMessage());
            }
        } else {
            System.out.println("Conexión no disponible. Compruebe los datos");
        }
        return comunidadesAlfabetico;
    }

Cuando el resultado de la consulta proviene de la unión de varias tablas no podemos usar los JavaBeans usados y el método varía algo. En este caso, tenemos que almacenar los valores devueltos por la base de datos en una variable temporal que después imprimiremos por línea de comandos.

Así, para recuperar el listado que contiene todos los Municipios de España ordenados por el nombre de la Comunidad y de la Provincia al que pertencen, con estos tres campos tenemos que escribir el siguiente método:

public void mostrarMunicipiosProvinciasComunidad() {
/*Realizamos la conexión con la base de datos usando el método conector*/
    Connection conexion = conector();
    /*Comprobamos si existe la condición para realizar el tratamiento adecuado*/
     if (conexion != null) {
     	try {
       		/*Creamos la conexión para hacer la consulta*/
         	Statement consulta = conexion.createStatement();
         	/*Creamos la consulta sql en una variable de tipo String*/
         	String sql = "SELECT comunidad, Provincia, Nombre "
         	+ "FROM comunidad "
         	+ "INNER JOIN provincia ON codigo_comunidad = CODAUTO "
         	+ "INNER JOIN municipio ON municipio.CODAUTO = provincia.CODAUTO AND 
         	municipio.CPRO = provincia.CPRO "
         	+ "ORDER BY codigo_comunidad, provincia.CPRO, Nombre";
         	/*Ejecutamos la consulta y recuperamos los datos*/
         	ResultSet resultado = consulta.executeQuery(sql);
         	System.out.println("--- Listado de Municipios ordenados por Comunidad, 
				Provincia y Nombre ---");
         	/*Utilizamos el cursor para recorrer el resultado devuelto por la base de 
				datos */
         	while (resultado.next()) {
         	/*Guardamos en una variable temporal los resultados de cada campo*/
         	String comunidad = resultado.getString("comunidad");
         	String provincia = resultado.getString("provincia");
         	String municipio = resultado.getString("Nombre");
         	/*Imprimimos los resultados usando las variables*/
         	System.out.println(comunidad + " - " + provincia + " - " + municipio);
         	}
			/*Para liberar recursos cerramos los objetos*/
			resultado.close();
			consulta.close();
			conexion.close();
       } catch (SQLException ex) {
				System.out.println(ex.getMessage());
        } else {
				System.out.println("Conexión no disponible. Compruebe los datos");
        }
    }

Clase Main

La aplicación que nos permite mostrar los resultados se ejecutará en el método main de la clase Main.

Para poder usar los métodos de la clase ManejadorBaseDatos, lo primero que tenemos hacer es instanciar un objeto vacío de esta clase.

Para mostrar resultados sobre tablas con un JavaBean, tendremos que inicializar un objeto de tipo colección del mismo tipo que hemos usado en la clase ManejadorBaseDatos con los datos devueltos por el método creado antes, pudiendo usar el mismo o distinto nombre. Por último, mostramos los datos almacenados en el objeto de tipo colección elegido con un bucle for each en el que usamos el método toString o equivalente de la clase JavaBean correspondiente a la tabla, comprobando antes que el objeto existe y tiene almacenados datos.. La sintaxis genérica sería:

package principal;

import java.util.Scanner;

public class Main {
	//Instanciamos un objeto vacio de la clase ManejadorBd
	ManejadorBd mnBd = new ManejadorBd();
	//Inicializamos un objeto coleccion y le pasamos lo que devuelve el método
	ArrayList identificador = mnBd.identificadorMetodo();
	//Comprobamos si tienes datos y si el objeto existe
	if (identificador.size() > 0 && identificador != null) {
	//Con un bucle for each recuperamos los datos
	for (JavaBeanTabla variable : identificador) {
		System.out.println(variable.metodotoString());
	}
	}else{
		System.out.println("Mensaje en caso de no devolver datos");
	}
}

Así para obtener el listado de Comunidades Autónomas de España ordenado de acuerdo al código de la Comunidad almacenado en la base de datos tenemos que escribir el siguiente código en el método Main:

package principal;

import beans.Comunidad;
import dao.ManejadorBaseDatos;
import java.util.ArrayList;

/**
 * Clase principal que ejecuta la aplicación
 * 
 * @author José María Torres Corral
 */
public class Main {
    
    public static void main(String[] args) {
        /* Instanciamos un objeto de la clase Manejador Base de datos para acceder a 
			 sus métodos*/
        ManejadorBaseDatos mbd = new ManejadorBaseDatos();
        /* Instanciamos un ArrayList que almacenará los datos de la tabla Comunidad*/
        ArrayList  comunidadAlfabetico = mbd.listadoComunidades();
        /* Mostramos por pantalla el contenido de la tabla*/
        System.out.println("--- Listado de Comunidades Autónomas de España ---");
        if (comunidadAlfabetico.size() > 0 && comunidadAlfabetico !=null) {
            for (Comunidad comunidad : comunidadAlfabetico) {
                System.out.println(comunidad.toString());
            }
        }else  {
            System.out.println("La base de datos no ha devuelto datos");
        }
    }    
}

Para mostrar el listado el listado de los Municipios de España, tenemos que recurrir al método que hemos escrito antes que se ocupa de realizar todo el proceso. Por lo tanto, tendremos que añadir la siguiente línea al final del método Main:

/* Usamos el método para mostrar la consulta que devuelve el listado de Municipios*/
mbd.mostrarMunicipiosProvinciasComunidad();  
Curso de Java - Tema 32.2: conexión con MySQL y JavaBeans | Curso de Java - Tema 32.4: realización de consultas SQL con variables Java
Curso de Java - Índice Ejercicios Nivel Medio

Escribir un comentario

Aunque los comentarios no expresan la opinión del administrador del sitio web, éste si que tiene una responsabilidad legal sobre lo que aparece. Por lo tanto, habrá una labor de moderación de los mensajes. No se permitirán mensajes ofensivos ni publicidad


Código de seguridad
Refescar

Solicitamos su permiso para obtener datos estadísticos de su navegación en esta web, en cumplimiento del Real Decreto-Ley 13/2012, de 30 de marzo. Si continúa navegando consideramos que acepta el uso de cookies. . Más información