15.- Ejercicios resueltos Operaciones en Hibernate.

DAM_AD_03_R_030

Altas, bajas , modificaciones y consultas sencillas en hibernate.

En los ejercicios se utilizarán las tablas creadas en la unidad 2, y cuyo modelo se muestra en el ejercicio DAM_AD_03_R_010. La base de datos va a ser prueba de MySQL.

Se trata de realizar altas, bajas y modificaciones en la tabla ARTICULOS creada en la unidad anterior.

Se muestra el siguiente menú:

	..............................................................
	. INSERT - UPDATE - DELETE de artículos en pruebas de MySQL...
	..............................................................
		.  1 Insertar un artículo. 
		.  2 Modificar el stock de un artículo.  
		.  3 Borrar un artículo. 
		.  4 Visualizar la tabla articulos. 
		.  5 Visualizar el detalle de las compras de los artículo. 
		.  0 SALIR.
	.................................................................

	Elige operación.

Para insertar un artículo, leeremos los datos de teclado y una vez validados se creará un objeto de la clase Articulos, se asignarán los datos tecleados y se grabarán en la BD, para ello se abre una transacción Transaction tx =session.beginTransaction(); se graba el objeto session.save(artinue); y luego se valida tx.commit(); Se captura la excepción ConstraintViolationException para controlar si no se puede insertar si el artículo ya existe, o si las claves ajenas no existe.

 try
 {     Transaction tx =session.beginTransaction();
	Articulos artinue = new Articulos();
	artinue.setCodarticulo(codarticulo);
	artinue.setDenominacion(denominacion);
	artinue.setPrecio(precio);
	artinue.setStock(stock);
	artinue.setZona(zona);
	artinue.setProveedores(prove);
	session.save(artinue);
	tx.commit();
	System.out.println("<<<<ARTÍCULO INSERTADO CORRECTAMENTE>>>>>");	
	System.out.println("--------------------------------------------------------------------");
} catch (ConstraintViolationException e){
              System.out.println ("-------------------------------------");
	      System.out.println ("Código de error: " + e.getErrorCode());
	      System.out.println ("Mensaje de error: " + e.getMessage());
	      System.out.println ("-------------------------------------");
}

Antes de insertar el artículo se comprueba si existe en la BD. Se utiliza el método get() , de la clase Session, Si el objeto no existe en la BD el método devuelve null.

do{
  try {
	System.out.print("Teclea el número de artículo: "); 
	codarticulo=teclado.nextShort(); 
        teclado.nextLine();
	artic = (Articulos) session.get(Articulos.class, codarticulo);	
	if (!(artic==null) )			
	   System.out.println(">>>El CODIGO DE ARTÍCULO YAAA EXISTE: "+ 
		                     codarticulo + ", teclea de nuevo."); 	
	else break; 
  } catch (InputMismatchException e) {
        System.out.println(">>>El CODIGO DE artículo DEBE SER NUMÉRICO SHORT. "); 
        teclado.nextLine();
     } 	
 }while (true);

Como el artículo tiene un objeto Proveedores que es el que lo suministra, para asignar el objeto primero lo hemos de localizar en la BD, y guardarlo. Utilizamos el método get() , de la clase Session, a continuación se muestra el código que localiza el proveedor, si no existe el método devolverá null:

 do{
     try {  // se lee el proveedor
	  System.out.print("Teclea el número de proveedor: "); 
	  codigo_prov=teclado.nextShort(); 
	  teclado.nextLine();
	  prove = (Proveedores) session.get(Proveedores.class, codigo_prov);	
	  if (prove==null) 			
		   System.out.println(">>>El CODIGO DE PROVEEDOR NOOO EXISTE: "+ 
				   codigo_prov + ", teclea de nuevo."); 	
		else break; 
 	 } catch (InputMismatchException e) {
        System.out.println(">>>El CODIGO DE PROVEEDOR DEBE SER NUMÉRICO SHORT. "); 
        teclado.nextLine();
     } 	
  }while (true);

El método modificar pedirá de teclado el código de artículo a modificar, se comprueba si existe, con el método get(), si existe el método devuelve el objeto. Se teclea la cantidad a añadir al stock, y una vez que los datos se han validado, se abre una nueva transacción, se asignan los nuevos valores al objeto, se guarda el objeto con los cambios y se valida la transacción:

	Transaction tx =session.beginTransaction();
	short stockant = artic.getStock();
	artic.setStock((short) (stockant + stock));
	session.save(artic);
	tx.commit();
        System.out.println("<<<<ARTÍCULO ACTUALIZADO.>>>>>");

El método borrar es muy similar al modificar, pedirá de teclado el código de artículo a borrar, se comprueba si existe, con el método get(), si existe el método devuelve el objeto. Y se borra. Se captura la excepción ConstraintViolationException para controlar si no se puede borrar porque tuviera registros relacionados.

try
{
        Transaction tx =session.beginTransaction();	
	session.delete(artic);
	tx.commit();
        System.out.println("<<<<ARTÍCULO BORRADO.>>>>>");
	System.out.println("--------------------------------------------------------------------");
	} catch (ConstraintViolationException e){
	      System.out.println ("-------------------------------------");
	      System.out.println ("Código de error: " + e.getErrorCode());
	      System.out.println ("Mensaje de error: " + e.getMessage());
	      System.out.println ("-------------------------------------");
}

El ejercicio añade dos métodos de visualización, uno para ver los datos del artículo y su proveedor, la visualización ha de ser la siguiente:

------------------------------------------------------------------------------------------------------------------
COD ARTI     DENOMINACION             PRECIO      STOCK     ZONA     COD PROV     NOMBRE PROV         LOCALIDAD   
-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------
1        Pala Padel                   88,00 	    800      Centro 	   10 Almacenes Talavera   TALAVERA       
2        Portátil Acer               588,00 	     34      Centro 	   20 Distribuidor MSI     MADRID         
3        Calendario Gregoriano        50,00 	    700       Oeste 	   10 Almacenes Talavera   TALAVERA       
4        Tablet SamSung              200,00 	     54         Sur 	   40 EL CORTE CHINO       AVILA          
5        Portatil MAC                158,60 	    610      Centro 	   10 Almacenes Talavera   TALAVERA       
6        Bolsa Padel                  28,50 	    610      Centro 	   10 Almacenes Talavera   TALAVERA       
7        Bolsa Portatil               56,40 	    140       Oeste 	   30 HIPER CASH           TOLEDO         
8        Lapiceros                     5,50 	     50         Sur 	   30 HIPER CASH           TOLEDO         
9        Ratón Optico                 15,50 	    700       Oeste 	   10 Almacenes Talavera   TALAVERA       
10       Equipo Música               130,60 	     54         Sur 	   40 EL CORTE CHINO       AVILA          
11       Estufa de cristal            50,70 	    755       Oeste 	   10 Almacenes Talavera   TALAVERA       
12       TV 20 pulgadas              150,90 	     50         Sur 	   30 HIPER CASH           TOLEDO             
-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------

Y otro para visualizar el detalle de las compras de cada artículo. El segundo informe será similar a este:

------------------------------------------------------------------------------------------------------------------
COD ARTI     DENOMINACION             PRECIO      STOCK     ZONA     COD PROV     NOMBRE PROV         LOCALIDAD   
-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------
1        Pala Padel                   88,00 	    800      Centro 	   10 Almacenes Talavera   TALAVERA       
Número de compras del artículo: 4
		------ -------- -------- ------------- ----------------------
		NumCom Unidades  Importe  Fecha comp   Nombre Cliente 
		------ -------- -------- ----------- ----------------------
		5      5         440,00   2014-12-17 Alicia Ramos             
		6      5         440,00   2014-01-10 Pedro Iglesias           
		1      5         440,00   2014-10-10 Juan García              
		2      5         440,00   2014-11-10 Juan García              
-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------
2        Portátil Acer               588,00 	     34      Centro 	   20 Distribuidor MSI     MADRID         
Número de compras del artículo: 4
		------ -------- -------- ------------- ----------------------
		NumCom Unidades  Importe  Fecha comp   Nombre Cliente 
		------ -------- -------- ----------- ----------------------
		6      10       5880,00   2014-01-10 Pedro Iglesias           
		5      10       5880,00   2014-12-17 Alicia Ramos             
		1      4        2352,00   2014-10-10 Juan García              
		2      10       5880,00   2014-11-10 Juan García              
-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------
3        Calendario Gregoriano        50,00 	    700       Oeste 	   10 Almacenes Talavera   TALAVERA       
Número de compras del artículo: 1
		------ -------- -------- ------------- ----------------------
		NumCom Unidades  Importe  Fecha comp   Nombre Cliente 
		------ -------- -------- ----------- ----------------------
		1      10        500,00   2014-10-10 Juan García              
-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------

Las clases Iterator, List y Set se utilizarán para recorrer los valores de las consultas y los set de registros. Se deben importar de java.util.

Una consulta devuelve los datos en una lista (List), para recorrer los registros utilizamos una lista de objetos.

En el primer informe la consulta que se ejecuta es "from Articulos", se muestra el código a continuación. La consulta se carga en una lista de artículos. Para cargar los datos del proveedor vamos navegando por el objeto proveedor del artículo correspondiente:

System.out.println("------------------------------------------------------------------------------------------------------------------");
System.out.println("COD ARTI     DENOMINACION             PRECIO      STOCK     ZONA     COD PROV     NOMBRE PROV         LOCALIDAD   ");
System.out.println("-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------");	   
String patron="%-8d %-26s %7.2f \t%7d %11s \t%5d %-20s %-15s";
String cadena ="";

Articulos arti = new Articulos(); 			
Query q = session.createQuery("from Articulos");
List <Articulos> lista = q.list();
for(int i=0;i<lista.size();i++)
{
	arti = lista.get(i); 
	cadena = String.format(patron, arti.getCodarticulo(),  arti.getDenominacion(), arti.getPrecio(),
	arti.getStock(), arti.getZona(), arti.getProveedores().getCodigoProv(), 
	arti.getProveedores().getNombre(), arti.getProveedores().getLocalidad());
	System.out.println(cadena);	   
}
System.out.println("-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------");	   

volveralmenu();

En la segunda visualización se mostrará el detalle de las compras que se han realizado para cada artículo que tiene compras. La única consulta que hacemos es esta:

Query q = session.createQuery("from Articulos a order by a.codarticulo");

y para cada objeto artículos es necesario cargar su set de detallecomprases, para obtener el detalle de las compras de ese artículo:

Set<Detallecompras> listacompras = arti.getDetallecomprases();

Para recorrer el Set utilizaremos la clase Iterator.

Iterator <Detallecompras> it = listacompras.iterator();

Detallecompras det = new Detallecompras();

while(it.hasNext()) {

det=it.next();
// proceso de los datos

} // fin while

Desde el detalle de la compra detallecomprases podremos navegar a la fecha de la compra y al cliente que realiza la compra de ese artículo en esa fecha.

System.out.println("------------------------------------------------------------------------------------------------------------------");
System.out.println("COD ARTI     DENOMINACION             PRECIO      STOCK     ZONA     COD PROV     NOMBRE PROV         LOCALIDAD   ");
System.out.println("-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------");	   
String patron="%-8d %-26s %7.2f \t%7d %11s \t%5d %-20s %-15s";
String cadena ="";
String patron2="%-6d %-8d %7.2f %12s %-25s";

Articulos arti = new Articulos(); 			
Query q = session.createQuery("from Articulos a order by a.codarticulo");
List <Articulos> lista = q.list();
for(int i=0;i<lista.size();i++)
{
    arti = lista.get(i); 
    cadena = String.format(patron, arti.getCodarticulo(),  arti.getDenominacion(), arti.getPrecio(),
    		arti.getStock(), arti.getZona(), arti.getProveedores().getCodigoProv(), 
    		arti.getProveedores().getNombre(), arti.getProveedores().getLocalidad());
    System.out.println(cadena);	   
    // cargamos las compras de ese artículo
    Set<Detallecompras> listacompras = arti.getDetallecomprases();
    //obtenemos las compras
    Iterator <Detallecompras> it = listacompras.iterator();
    System.out.println("Número de compras del artículo: "+listacompras.size() );	
    if (listacompras.size()!=0)
    {   System.out.println("\t\t------ -------- -------- ------------- ----------------------");
	System.out.println("\t\tNumCom Unidades  Importe  Fecha comp   Nombre Cliente ");
	System.out.println("\t\t------ -------- -------- ----------- ----------------------");
	Detallecompras det = new Detallecompras();
	while(it.hasNext()) {
		det=it.next();
		cadena = String.format(patron2,det.getId().getNumcompra(), det.getUnidades(),
		det.getUnidades() * arti.getPrecio(), det.getCompras().getFechacompra(),
		det.getCompras().getClientes().getNombre());
	        System.out.println("\t\t" + cadena);	   
	 } // fin while detallecomprases
	}// fin if listacompras.size() 	    
    System.out.println("-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------");	   
} // fin while articulos

volveralmenu();

Retroalimentación

Clase DAM_AD_03_030.

package operaciones;

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.InputMismatchException;

import java.util.Iterator;
import java.util.List;
import java.util.Set; 
import java.util.Scanner;


import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.exception.ConstraintViolationException;

import datos.*;

public class OperacionesArticulos {
	static	SessionFactory sesion = Conexion.getSession();			
	static Session session = sesion.openSession();	
	static Scanner teclado = new Scanner(System.in);
 
public static void main(String[] args)    
 {
        int op = 0;
    do 
    { 
	dibujamenu();
        System.out.print( "\tElige operación.\t");
        op = teclado.nextInt(); 
        switch(op){
	    case 1: insertar(); break;
	    case 2: modificar();  break;
	    case 3: borrar(); break;
	    case 4: Visualizararticulo(); break;
	    case 5: Visualizardetallearticulo(); break;
    }  
  }while(op!=0);

session.close();
sesion.close();
	
}//fin main
////////////////////////////////////////////////////////////////////////////////////
private static void Visualizararticulo () {

System.out.println("------------------------------------------------------------------------------------------------------------------");
System.out.println("COD ARTI     DENOMINACION             PRECIO      STOCK     ZONA     COD PROV     NOMBRE PROV         LOCALIDAD   ");
System.out.println("-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------");	   
String patron="%-8d %-26s %7.2f \t%7d %11s \t%5d %-20s %-15s";
String cadena ="";

Articulos arti = new Articulos(); 			
Query q = session.createQuery("from Articulos");
List <Articulos> lista = q.list();
for(int i=0;i<lista.size();i++)
{
  arti = lista.get(i); 
  cadena = String.format(patron, arti.getCodarticulo(),  arti.getDenominacion(), arti.getPrecio(),
  arti.getStock(), arti.getZona(), arti.getProveedores().getCodigoProv(), 
  arti.getProveedores().getNombre(), arti.getProveedores().getLocalidad());
  System.out.println(cadena);	   
}
System.out.println("-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------"); 
volveralmenu();	
}//Visualizar

////////////////////////////////////////////////////////////////////////////////////
private static void Visualizardetallearticulo() {

System.out.println("------------------------------------------------------------------------------------------------------------------");
System.out.println("COD ARTI     DENOMINACION             PRECIO      STOCK     ZONA     COD PROV     NOMBRE PROV         LOCALIDAD   ");
System.out.println("-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------");	   
String patron="%-8d %-26s %7.2f \t%7d %11s \t%5d %-20s %-15s";
String cadena ="";
String patron2="%-6d %-8d %7.2f %12s %-25s";

Articulos arti = new Articulos(); 			
Query q = session.createQuery("from Articulos a order by a.codarticulo");
List <Articulos> lista = q.list();
for(int i=0;i<lista.size();i++)
{
    arti = lista.get(i); 
    cadena = String.format(patron, arti.getCodarticulo(),  arti.getDenominacion(), arti.getPrecio(),
    		arti.getStock(), arti.getZona(), arti.getProveedores().getCodigoProv(), 
    		arti.getProveedores().getNombre(), arti.getProveedores().getLocalidad());
    System.out.println(cadena);	   
    // cargamos las compras de ese artículo
    Set<Detallecompras> listacompras = arti.getDetallecomprases();
    //obtenemos las compras
    Iterator <Detallecompras> it = listacompras.iterator();
    System.out.println("Número de compras del artículo: "+listacompras.size() );	
    if (listacompras.size()!=0)
	{   System.out.println("\t\t------ -------- -------- ------------- ----------------------");
            System.out.println("\t\tNumCom Unidades  Importe  Fecha comp   Nombre Cliente ");
	    System.out.println("\t\t------ -------- -------- ----------- ----------------------");
	    Detallecompras det = new Detallecompras();
	    while(it.hasNext()) {
		det=it.next();
		cadena = String.format(patron2,det.getId().getNumcompra(), det.getUnidades(),
		det.getUnidades() * arti.getPrecio(), det.getCompras().getFechacompra(),
		det.getCompras().getClientes().getNombre());
		System.out.println("\t\t" + cadena);	   
	     } // fin while detallecomprases
     }// fin if listacompras.size() 	    
     System.out.println("-------- -------------------------- ------------ ------- ----------- -------- -------------------- ---------------");	   
} // fin while articulos
volveralmenu();	
}//Visualizardetalle


////////////////////////////////////////////////////////////////////////////////////
private static void modificar() {

short codarticulo;	 
short stock ;
Articulos artic;
System.out.println("----------------------------------------------");
System.out.println("<<<< ACTUALIZAR EL STOCK DE UN ARTÍCULO  >>>>>");
System.out.println("----------------------------------------------");

do{
try {
	System.out.print("Teclea el número de artículo: "); 
	codarticulo=teclado.nextShort(); 
	teclado.nextLine();
	artic = (Articulos) session.get(Articulos.class, codarticulo);	
	if (artic==null) 			
	   System.out.println(">>>El CODIGO DE ARTÍCULO NOOO EXISTE: "+ 
	                     codarticulo + ", teclea de nuevo."); 	
	else break; 
	} catch (InputMismatchException e) {
	    System.out.println(">>>El CODIGO DE artículo DEBE SER UN NUMÉRICO SHORT. "); 
	    teclado.nextLine();
	} 	
}while (true);
// Visualizamos el articulo a actualizar
System.out.println("--------------------------------------------------------------------");
System.out.println("DENOMINACION: " + artic.getDenominacion() + ", PRECIO: " +
		artic.getPrecio() +", STOCK:" + artic.getStock());
// Leemos el nuevo stock
do{
	System.out.print("Teclea las unidades a sumar al STOCK del artículo: "); 
	try {
		stock=teclado.nextShort(); 
		teclado.nextLine();
		break;
	} catch (InputMismatchException e) {
	System.out.println(">>>EL STOCK DEBE SER NUMÉRICO"); 
	teclado.nextLine();
	} 		
}while (true);

Transaction tx =session.beginTransaction();
short stockant = artic.getStock();
artic.setStock((short) (stockant + stock));
session.save(artic);
tx.commit();
System.out.println("<<<<ARTÍCULO ACTUALIZADO.>>>>>");
System.out.println("--------------------------------------------------------------------");
volveralmenu();	
} // modificar
////////////////////////////////////////////////////////////////////////////////////
private static void insertar() {
short codarticulo; String denominacion;	 
float precio; short stock ;
String zona ; short codigo_prov;
Articulos artic; Proveedores prove;
System.out.println("<<<<Teclea los datos del artículo a insertar>>>>>");
System.out.println("-------------------------------------------------");
do{
 try {
	  System.out.print("Teclea el número de artículo: "); 
	  codarticulo=teclado.nextShort(); 
	  teclado.nextLine();
	  artic = (Articulos) session.get(Articulos.class, codarticulo);	
	  if (!(artic==null) )			
		   System.out.println(">>>El CODIGO DE ARTÍCULO YAAA EXISTE: "+ 
	                     codarticulo + ", teclea de nuevo."); 	
	  else break; 
	 } catch (InputMismatchException e) {
        System.out.println(">>>El CODIGO DE artículo DEBE SER NUMÉRICO SHORT. "); 
        teclado.nextLine();
     } 	
  }while (true);
  // Leemos nombre      		       
  System.out.print("Teclea la denominación del artículo: "); 
  denominacion=teclado.nextLine(); 
   // leemos el precio
  do{
	   System.out.print("Teclea el precio de artículo: "); 
	   try {
		   precio=teclado.nextFloat(); 
		   teclado.nextLine();
		   break;
		 } catch (InputMismatchException e) {
	         System.out.println(">>>El PRECIO DEL artículo DEBE SER NUMÉRICO FLOAT. "); 	
	         teclado.nextLine();
	      } 		 
   }while (true);
   // Leemos el stock
   do{
	   System.out.print("Teclea el stock del artículo: "); 
	   try {
		   stock=teclado.nextShort(); 
		   teclado.nextLine();
		   break;
		 } catch (InputMismatchException e) {
	         System.out.println(">>>EL STOCK DEBE SER NUMÉRICO SHORT."); 
	         teclado.nextLine();
	      } 		
    }while (true);
   // Leemos zona      		       
   System.out.print("Teclea el nombre de la zona: "); 
   zona=teclado.nextLine(); 
   do{
     try {  // se lee el proveedor
		  System.out.print("Teclea el número de proveedor: "); 
		  codigo_prov=teclado.nextShort(); 
		  teclado.nextLine();
		  prove = (Proveedores) session.get(Proveedores.class, codigo_prov);	
		  if (prove==null) 			
			   System.out.println(">>>El CODIGO DE PROVEEDOR NOOO EXISTE: "+ 
					   codigo_prov + ", teclea de nuevo."); 	
			else break; 
	 	 } catch (InputMismatchException e) {
	        System.out.println(">>>El CODIGO DE PROVEEDOR DEBE SER NUMÉRICO SHORT. "); 
	        teclado.nextLine();
	     } 	
	  }while (true);

   try
     {
        Transaction tx =session.beginTransaction();
	Articulos artinue = new Articulos();
	artinue.setCodarticulo(codarticulo);
	artinue.setDenominacion(denominacion);
	artinue.setPrecio(precio);
	artinue.setStock(stock);
	artinue.setZona(zona);
	artinue.setProveedores(prove);
	session.save(artinue);
	tx.commit();
	System.out.println("<<<<ARTÍCULO INSERTADO CORRECTAMENTE>>>>>");	
	System.out.println("--------------------------------------------------------------------");
      } catch (ConstraintViolationException e){
	      System.out.println ("-------------------------------------");
	      System.out.println ("Código de error: " + e.getErrorCode());
	      System.out.println ("Mensaje de error: " + e.getMessage());
	      System.out.println ("-------------------------------------");
	}

volveralmenu();			
} // insertar

////////////////////////////////////////////////////////////////////////////////////
private static void borrar() {

short codarticulo;	 
Articulos artic;
System.out.println("----------------------------------------------");
System.out.println("<<<< BORRAR UN ARTÍCULO  >>>>>");
System.out.println("----------------------------------------------");

do{
try {
		System.out.print("Teclea el número de artículo: "); 
		codarticulo=teclado.nextShort(); 
		teclado.nextLine();
		artic = (Articulos) session.get(Articulos.class, codarticulo);	
		if (artic==null) 			
		   System.out.println(">>>El CODIGO DE ARTÍCULO NOOO EXISTE: "+ 
		                     codarticulo + ", teclea de nuevo."); 	
		else break; 
	} catch (InputMismatchException e) {
	    System.out.println(">>>El CODIGO DE artículo DEBE SER UN NUMÉRICO SHORT. "); 
	    teclado.nextLine();
	} 	
}while (true);
System.out.println("--------------------------------------------------------------------");
System.out.println("DENOMINACION: " + artic.getDenominacion() + ", PRECIO: " +
		artic.getPrecio() +", STOCK:" + artic.getStock());

try
{
	Transaction tx =session.beginTransaction();
	session.delete(artic);
	tx.commit();
	System.out.println("<<<<ARTÍCULO BORRADO.>>>>>");
	System.out.println("--------------------------------------------------------------------");
} catch (ConstraintViolationException e){
	  System.out.println ("-------------------------------------");
      System.out.println ("Código de error: " + e.getErrorCode());
      System.out.println ("Mensaje de error: " + e.getMessage());
      System.out.println ("-------------------------------------");
}
volveralmenu();	
}// borrar

////////////////////////////////////////////////////////////////////////////////////
private static void dibujamenu() {  	
	System.out.println("\t..............................................................");
	System.out.println("\t. INSERT - UPDATE - DELETE de artículos en pruebas de MySQL...");
	System.out.println("\t..............................................................\n"
	+ "\t\t.  1 Insertar un artículo. \n"
	+ "\t\t.  2 Modificar el stock de un artículo.  \n"
	+ "\t\t.  3 Borrar un artículo. \n"
	+ "\t\t.  4 Visualizar la tabla articulos. \n"
	+ "\t\t.  5 Visualizar el detalle de las compras de los artículo. \n"
	+ "\t\t.  0 SALIR.\n"
	+ "\t.................................................................\n");
} // fin dibujamenu
////////////////////////////////////////////////////////////////////////////////////
private static void volveralmenu() {
try {
	System.out.println( "Pulsa una tecla para volver. ");
	System.in.read();
	} catch (IOException e) {System.out.println (e);}
}// volveralmenu
////////////////////////////////////////////////////////////////////////////////////
}

DAM_AD_03_R_040

Consultas más complejas con HIBERNATE

En este ejercicio se van a realizar resúmenes con todos los datos de las tablas que se están utilizando a lo largo de la unidad. Estos resúmenes se obtendrán realizando consultas más complejas a la base de datos. Hasta ahora las consultas devolvían objetos asociados a alguna de las clases mapeadas. En estas nuevas consultas se devuelven listas de objetos, cada elemento de la lista será una fila de la consulta. A su vez cada elemento de la lista contendrá un array de objetos correspondiente a las columnas de la consulta.

Por ejemplo esta consulta devuelve los datos del proveedor y el número de artículos que suministra.

Query q = session.createQuery("select p.codigoProv, p.nombre, p.localidad , "
+ " count(a.codarticulo) from Proveedores p join p.articuloses a "
+ " group by p.codigoProv, p.nombre, p.localidad ");

Los datos se recuperan en una lista de objetos.

List<Object[]> listaprove = q.list();

Y cada elemento de la lista es a su vez un array de objetos, tantos como columnas devuelva la select.

long sumaartic = 0;
for (int i = 0; i < listaprove.size(); i++)
{
Object res[] = listaprove.get(i);
cadena = String.format(patron, res[0], res[1], res[2], res[3]);
System.out.println(cadena);
sumaartic = sumaartic + (long)res[3];
}

En el ejercicio se muestra el siguiente menú:

	..............................................................
	. Resúmenes. Consultas más complejas. BD prueba de MySQL ..
	..............................................................
		.  1 Resumen de artículos. 
		.  2 Resumen de clientes.  
		.  3 Resumen de proveedores. 
		.  4 Detalle de las compras de los clientes. 
		.  0 SALIR.
	.................................................................

	Elige operación.

El resumen de ARTÍCULOS muestra el siguiente resultado

--------------------------------------------------------------------------------------------------------------
                           RESUMEN DATOS DE ARTICULOS 
--------------------------------------------------------------------------------------------------------------
COD ARTI     DENOMINACION            PRECIO   STOCK  SUM UNIDAVEND  TOTALIMPORTE NUM_COMP NOMBRE PROVEEDOR
-------- -------------------------- -------- ------- -------------- ------------ -------- --------------------
1        Pala Padel                   88,00     800 	     20 	 1760,00        4 Almacenes Talavera  
2        Portátil Acer               588,00      34 	     34 	19992,00        4 Distribuidor MSI    
3        Calendario Gregoriano        50,00     744 	     10 	  500,00        1 Almacenes Talavera  
4        Tablet SamSung              200,00      54 	      5 	 1000,00        1 EL CORTE CHINO      
5        Portatil MAC                158,60     610 	     15 	 2379,00        2 Almacenes Talavera  
6        Bolsa Padel                  28,50     610 	     13 	  370,50        4 Almacenes Talavera  
7        Bolsa Portatil               56,40     140 	     22 	 1240,80        4 HIPER CASH          
8        Lapiceros                     5,50      50 	      7 	   38,50        1 HIPER CASH          
9        Ratón Optico                 15,50     700 	      0 	    0,00        0 Almacenes Talavera  
10       Equipo Música               130,60      54 	      7 	  914,20        1 EL CORTE CHINO      
11       Estufa de cristal            50,70     755 	      0 	    0,00        0 Almacenes Talavera  
12       TV 20 pulgadas              150,90      50 	      0 	    0,00        0 HIPER CASH          
-------- -------------------------- -------- ------- -------------- ------------ -------- --------------------
         TOTALES                               4601 	    133 	28195,00
-------- -------------------------- -------- ------- -------------- ------------ -------- --------------------
Número de artículos:  12      
Media de unidades por artículo:  11,00  
Media de importe por artículo:  2349,58 
Media de stock :   383,42 
Artículos con más unidades (máximo = 34): 
	Cod articulo: 2, Denominación: Portátil Acer 
Artículos con más importe (máximo = 19992,00): 
	Cod articulo: 2, Denominación: Portátil Acer 
Artículos con más compras (máximo = 4): 
	Cod articulo: 1, Denominación: Pala Padel 
	Cod articulo: 2, Denominación: Portátil Acer 
	Cod articulo: 6, Denominación: Bolsa Padel 
	Cod articulo: 7, Denominación: Bolsa Portatil 
--------------------------------------------------------------------------------------------------------------
Pulsa una tecla para volver.

La consulta para obtener los artículos es la siguiente:

Query q = session.createQuery("select a.codarticulo , a.denominacion , a.precio , a.stock , " +

" coalesce(sum(det.unidades), 0) , coalesce(a.precio * sum(det.unidades),0) , " +
" count(distinct det.compras.numcompra) , a.proveedores.nombre " +
" from Articulos a left join a.detallecomprases det " +
" group by a.codarticulo , a.denominacion, a.stock, a.precio, a.proveedores.nombre " +
" order by a.codarticulo");

El número de artículos lo obtenemos con el tamaño de la lista de objetos donde se almacenan los datos de la consulta.

La media de unidades y la media de importe se obtienen sumando las unidades y los importes de los artículos y dividiendo por el número de ellos.

Para calcular la media de stock se realiza una consulta que devuelva un único resultado, es decir un solo valor.

Double mediastc = (Double) session.createQuery(
"select avg(a.stock) from Articulos a").uniqueResult();

Para calcular los máximos: en el bucle del tratamiento de artículos se va preguntando por las unidades vendidas de cada artículo, por los importes y por las compras, con el fin de obtener los valores máximos. Una vez que se termina el bucle se realizan consultas de unidades, de importes y de compras para que devuelva los artículos con esos valores máximos. Las consultas son las siguientes:

// Artículos con más unidades vendidas
q = session.createQuery("select a.codarticulo , a.denominacion "+
" from Articulos a join a.detallecomprases det " +
" group by a.codarticulo " +
" having sum(det.unidades)= " + maxuni );
List<Object[]> armaxunida = q.list();
System.out.printf("Artículos con más unidades (máximo = %d): \n",maxuni );
for (int i = 0; i < armaxunida.size(); i++)
{
Object res[] = armaxunida.get(i);
System.out.printf("\tCod articulo: %d, Denominación: %s \n", res[0], res[1]);
}

// Artículo o artículos con más importe
q = session.createQuery("select a.codarticulo , a.denominacion "+
" from Articulos a join a.detallecomprases det " +
" group by a.codarticulo, a.precio " +
" having (a.precio * sum(det.unidades)) = " + maximpor );
List<Object[]> armaximp = q.list();
System.out.printf("Artículos con más importe (máximo = %.2f): \n",maximpor );
for (int i = 0; i < armaximp.size(); i++)
{
Object res[] = armaximp.get(i);
System.out.printf("\tCod articulo: %d, Denominación: %s \n", res[0], res[1]);
}

// Artículos con más compras
q = session.createQuery("select a.codarticulo , a.denominacion "+
" from Articulos a join a.detallecomprases det " +
" group by a.codarticulo, a.precio " +
" having count(distinct det.compras.numcompra) = " + maxnumcompra );
List<Object[]> armaxcomp = q.list();
System.out.printf("Artículos con más compras (máximo = %d): \n",maxnumcompra );
for (int i = 0; i < armaxcomp.size(); i++)
{
Object res[] = armaxcomp.get(i);
System.out.printf("\tCod articulo: %d, Denominación: %s \n", res[0], res[1]);
}

El resumen de CLIENTES muestra el siguiente resultado

-------------------------------------------------------------------------
                     RESUMEN DATOS DE CLIENTES 
-------------------------------------------------------------------------
COD CLI  NOMBRE                LOCALIDAD        NUM_COMPRAS TOTALIMPORTE
-------- --------------------- ---------------- ----------- -------------
1        Juan García           TALAVERA               2 	10035,30 
2        Alicia Ramos          TALAVERA               3 	11416,40 
3        Pedro Iglesias        TOLEDO                 1 	 6743,30 
4        Alejandro Spart       AVILA                  0 	    0,00 
-------- --------------------- ---------------- ----------- -------------
         TOTALES                                      6 	28195,00 
-------- --------------------- ---------------- ----------- -------------
Número de clientes:  4       
Media de compras por clientes:  1,50    
Media de importe por clientes:  7048,75 
Clientes con máximo de compras (máximo=3): 
	Cod Cliente: 2, Nombre: Alicia Ramos 
Clientes con importe máximo (máximo=11416,40): 
	Cod Cliente: 2, Nombre: Alicia Ramos 
-------- --------------------- ---------------- ----------- -------------
Pulsa una tecla para volver.

Para el tratamiento de los clientes se crea una consulta que nos devuelva los objetos cliente, y para cada objeto cliente se calcula el número de compras y el total importe.

Consulta clientes:

Query q = session.createQuery("from Clientes");

Para cada cliente realizamos una consulta que devuelva el número de compras, un uniqueresult.

cli = (Clientes) lista.get(i);
Long numc = (Long) session.createQuery(
"select count(*) from Compras c where c.clientes.codigoCli = "+ cli.getCodigoCli() ).uniqueResult();

Y otra consulta que devuelva el total importe del cliente. Se utiliza la función coalesce para que devuelva un 0 a los clientes que no tienen compras, que salga 0 en lugar de espacios en blanco o null:

Query consu = session.createQuery(
" select coalesce(sum( det.articulos.precio * det.unidades),0) " +
" from Compras co join co.detallecomprases det " +
" where co.clientes.codigoCli = ?");
consu.setShort(0,cli.getCodigoCli());
Double imp = (Double) consu.uniqueResult();

Los cálculos de las líneas de pie son los siguientes:

El número de clientes se obtiene con el tamaño de la lista.

Para obtener la media de compras y de importe, se realizan dos consultas una que devuelva el número de compras, y otra la suma de importes. Y luego se calcula la media dividiendo por el número de clientes:

Long numco = (Long) session.createQuery("select count(*) from Compras").uniqueResult();
Double suma = (Double) session.createQuery(
" select coalesce(sum( det.articulos.precio * det.unidades),0) " +
" from Compras co join co.detallecomprases det " ).uniqueResult();

// número de clientes
System.out.printf("Número de clientes: %-7d \n", lista.size());
// media de compras por cliente
float mediacomp = (float) (numco)/(lista.size());
System.out.printf("Media de compras por clientes: %-7.2f \n", mediacomp);
// media de importe por cliente
float mediaimp = (suma.floatValue())/(lista.size());
System.out.printf("Media de importe por clientes: %-7.2f \n", mediaimp);

Para calcular los máximos procedemos como en el caso anterior, en el bucle de clientes se va preguntando por el máximo de compras y de importe, y se van guardando en una variable. Cuando termina el bucle de clientes se realiza una consulta para cada caso, por si hay varios clientes que tienen esos valores máximos. Las consultas son las siguientes:

// Clientes con más compra
q = session.createQuery(" select co.clientes.codigoCli, co.clientes.nombre, " +
" count(*) from Compras co " +
" group by co.clientes.codigoCli, co.clientes.nombre " +
" having count(*) = " + maxcom );
List<Object[]> climacommax = q.list();
System.out.printf("Clientes con máximo de compras (máximo=%.0f): \n",maxcom );
for (int i = 0; i < climacommax.size(); i++)
{
Object res[] = climacommax.get(i);
System.out.printf("\tCod Cliente: %d, Nombre: %s \n", res[0], res[1]);
}
// Clientes con mas importe
q = session.createQuery("select co.clientes.codigoCli, co.clientes.nombre, "+
" sum( det.articulos.precio * det.unidades) "+
" from Compras co join co.detallecomprases det "+
" group by co.clientes.codigoCli,co.clientes.nombre "+
" having sum( det.articulos.precio * det.unidades) = " + maximp );
List<Object[]> climaximp = q.list();
System.out.printf("Clientes con importe máximo (máximo=%7.2f): \n",maximp );
for (int i = 0; i < climaximp.size(); i++)
{
Object res[] = climaximp.get(i);
System.out.printf("\tCod Cliente: %d, Nombre: %s \n", res[0], res[1]);
}

El resumen de PROVEEDORES muestra el siguiente resultado:

-----------------------------------------------------
              RESUMEN DE PROVEEDORES 
--------------------------------------------------------
COD PROV  NOMBRE                LOCALIDAD       NUM_ART 
-------- --------------------- ---------------- --------
10       Almacenes Talavera    TALAVERA             6 
20       Distribuidor MSI      MADRID               1 
30       HIPER CASH            TOLEDO               3 
40       EL CORTE CHINO        AVILA                2 
-------- --------------------- ---------------- ---------------
Número de proveedores 4: 
Media de artículos por proveedor: 3,00 
Proveedores que suministran más artículos (máximo = 6): 
	Cod proveedor: 10, Nombre: Almacenes Talavera 
-------- --------------------- ---------------- ---------------
Pulsa una tecla para volver.

En este informe se procede como en los anteriores.

La consulta para los proveedores es la siguiente:

En el tratamiento del proveedor vamos preguntando por el máximo de número de artículos, y cuando termina el bucle de proveedores calculamos la consulta para el proveedor con más artículos::

// Proveedor con más artículos
q = session.createQuery("select p.codigoProv, p.nombre, count(a.codarticulo) " +
" from Proveedores p join p.articuloses a "
+ " group by p.codigoProv, p.nombre, p.localidad having "
+ " count(a.codarticulo) = " + maximo);
List<Object[]> provmaxartis = q.list();
System.out.printf("Proveedores que suministran más artículos (máximo = %d): \n",maximo );
for (int i = 0; i < provmaxartis.size(); i++)
{
Object res[] = provmaxartis.get(i);
System.out.printf("\tCod proveedor: %d, Nombre: %s \n", res[0], res[1]);
}

El resumen del DETALLE DE LAS COMPRAS DE CLIENTES, nos muestra un listado con los datos de los clientes, las compras que tiene y el detalle de cada una de las compras.

La consulta para los clientes es la siguiente:

Query q = session.createQuery("from Clientes");

Cada cliente tiene un set de Compras, se utilizará un Iterator para extraer los datos de las compras del cliente:

Set<Compras> listacompras = cli.getComprases();
//obtenemos las compras
Iterator <Compras> itcompras = listacompras.iterator();

Y cada compra tiene un set de detalle-compras, igualmente se utilizará un Iterator para recorrer y visualizar los detalles de las compras.

Set<Detallecompras> listadetalle = comp.getDetallecomprases();
//obtenemos los detalle de la compra
Iterator <Detallecompras> itdetalle = listadetalle.iterator();

El informe se muestra a continuación:

-------------------------------------------------------------------------
              DETALLE DE LAS COMPRAS DE LOS CLIENTES 
-------------------------------------------------------------------------
COD CLI: 1,  NOMBRE: Juan García, LOCALIDAD: TALAVERA 
Número de compras del cliente: 2
   ------ --------------------- ---------------- ------
	NumCom: 1,  Fecha compra: 2014-10-10 
	---------------------------------------
	Número de artículos de la compra: 3
	COD     UNIDADES     PVP       IMPORTE 
	---------------------------------------
	3     	   10       50,00       500,00 
	1     	    5       88,00       440,00 
	2     	    4      588,00      2352,00 
	---------------------------------------
	TOTALES:  19    	       3292,00 
   ------ --------------------- ---------------- ------
	NumCom: 2,  Fecha compra: 2014-11-10 
	---------------------------------------
	Número de artículos de la compra: 4
	COD     UNIDADES     PVP       IMPORTE 
	---------------------------------------
	1     	    5       88,00       440,00 
	6     	    1       28,50        28,50 
	7     	    7       56,40       394,80 
	2     	   10      588,00      5880,00 
	---------------------------------------
	TOTALES:  23    	       6743,30 
-------- --------------------- ---------------- -----------
COD CLI: 2,  NOMBRE: Alicia Ramos, LOCALIDAD: TALAVERA 
Número de compras del cliente: 3
   ------ --------------------- ---------------- ------
	NumCom: 5,  Fecha compra: 2014-12-17 
	---------------------------------------
	Número de artículos de la compra: 2
	COD     UNIDADES     PVP       IMPORTE 
	---------------------------------------
	1     	    5       88,00       440,00 
	2     	   10      588,00      5880,00 
	---------------------------------------
	TOTALES:  15    	       6320,00 

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Para los clientes sin compra se visualizará una línea indicando que el cliente no tiene compras. Por ejemplo el cliente 4 no tiene compras:

-------- --------------------- ---------------- -----------
COD CLI: 3,  NOMBRE: Pedro Iglesias, LOCALIDAD: TOLEDO 
Número de compras del cliente: 1
   ------ --------------------- ---------------- ------
	NumCom: 6,  Fecha compra: 2014-01-10 
	---------------------------------------
	Número de artículos de la compra: 4
	COD     UNIDADES     PVP       IMPORTE 
	---------------------------------------
	6     	    1       28,50        28,50 
	2     	   10      588,00      5880,00 
	7     	    7       56,40       394,80 
	1     	    5       88,00       440,00 
	---------------------------------------
	TOTALES:  23    	       6743,30 
-------- --------------------- ---------------- -----------
COD CLI: 4,  NOMBRE: Alejandro Spart, LOCALIDAD: AVILA 
Número de compras del cliente: 0
 <<<<<<<<<CLIENTE SIN COMPRA >>>>>>> 
-------- --------------------- ---------------- -----------
-------- --------------------- ---------------- -----------
Pulsa una tecla para volver.

Retroalimentación

Clase DAM_AD_03_040.

package operaciones;

import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import datos.*;

public class ResumenesEstadisticos {
	
	static SessionFactory sesion = Conexion.getSession();			
	static Session session = sesion.openSession();	
	
	static Scanner teclado = new Scanner(System.in);
 
public static void main(String[] args)    
 	 {
 		int op = 0;
 		do 
 		  { 
 			dibujamenu();
 	        System.out.print( "\tElige operación.\t");
	        op = teclado.nextInt(); 
            switch(op){ 
		    	case 1: resumenarticulos(); break;
			    case 2: resumenclientes();  break;
			    case 3: resumenproveedores();  break;
			    case 4: detallecomprasdeclientes(); break;
			    case 5: break;
        }  
	  }while(op!=0);
 	  session.close();
 	  sesion.close();
	
}//fin main
////////////////////////////////////////////////////////////////////////////////////
private static void resumenproveedores() {
	
System.out.println("-----------------------------------------------------");
System.out.println("              RESUMEN DE PROVEEDORES ");	  
System.out.println("--------------------------------------------------------");	
System.out.println("COD PROV  NOMBRE                LOCALIDAD       NUM_ART ");
System.out.println("-------- --------------------- ---------------- --------");	   
String patron="%-8d %-20s  %-20s %d ";
String cadena ="";			
Query q = session.createQuery("select p.codigoProv, p.nombre, p.localidad , "
		+ " count(a.codarticulo)  from Proveedores p join p.articuloses a "
		+ " group by  p.codigoProv, p.nombre, p.localidad ");
long maximo=0;
List<Object[]> listaprove = q.list(); 

if (listaprove.size()>0)
{   long sumaartic = 0;
	for (int i = 0; i < listaprove.size(); i++)
	{
	  Object res[] = listaprove.get(i); 
	  cadena = String.format(patron, res[0], res[1], res[2], res[3]);
	  System.out.println(cadena);
	  sumaartic = sumaartic + (long)res[3];
	  if (maximo < (long)res[3])
		  maximo = (long)res[3];
	}
	System.out.println("-------- --------------------- ---------------- ---------------");	
	System.out.printf("Número de proveedores %d: \n",listaprove.size() );
	System.out.printf("Media de artículos por proveedor: %4.2f \n",(float)sumaartic/(float)listaprove.size() );
	// Proveedor con más artículos
	 q = session.createQuery("select p.codigoProv, p.nombre,  count(a.codarticulo) " + 
	             " from Proveedores p join p.articuloses a "
				+ " group by  p.codigoProv, p.nombre, p.localidad having "
				+ "  count(a.codarticulo) = " + maximo);
	 List<Object[]> provmaxartis = q.list(); 
	 System.out.printf("Proveedores que suministran más artículos (máximo = %d): \n",maximo );
	 for (int i = 0; i < provmaxartis.size(); i++)
		{
		   Object res[] = provmaxartis.get(i); 
		   System.out.printf("\tCod proveedor: %d, Nombre: %s \n", res[0],  res[1]); 
		 }
}
else
	System.out.println(" <<<<<<<<< NO HAY PROVEEDORES >>>>>>> ");	
System.out.println("-------- --------------------- ---------------- ---------------");	 
volveralmenu();		
}//resumenproveedores
////////////////////////////////////////////////////////////////////////////////////
private static void detallecomprasdeclientes () 
{
System.out.println("-------------------------------------------------------------------------");
System.out.println("              DETALLE DE LAS COMPRAS DE LOS CLIENTES ");	  
System.out.println("-------------------------------------------------------------------------");	
Query q = session.createQuery("from Clientes");
List <Clientes> lista = q.list();
if (lista.size()>0)
	{   
	    Clientes cli = new Clientes(); 	
		for (int i=0;i<lista.size();i++)
		{
		    cli=lista.get(i);
			System.out.printf("COD CLI: %d,  NOMBRE: %s, LOCALIDAD: %s \n",
					 cli.getCodigoCli(), cli.getNombre(), cli.getLocalidad());
			Set<Compras> listacompras = cli.getComprases();
			//obtenemos las compras
			Iterator <Compras> itcompras = listacompras.iterator();
			System.out.println("Número de compras del cliente: "+listacompras.size() );	
			if (listacompras.size()!=0)
			{  
				comprasdeuncliente(itcompras);
			} 
			else
				System.out.println(" <<<<<<<<<CLIENTE SIN COMPRA >>>>>>> ");	  
			System.out.println("-------- --------------------- ---------------- -----------");	  
		} // fin while clientes	   
  }
  else
	System.out.println(" <<<<<<<<< NO HAY CLIENTES >>>>>>> ");	  
System.out.println("-------- --------------------- ---------------- -----------");	 
volveralmenu();		
	
} //detallecomprasdeclientes
////////////////////////////////////////////////////////////////////////////////////
private static void comprasdeuncliente(Iterator<Compras> itcompras) {
Compras comp = new Compras();
while(itcompras.hasNext()) {
	System.out.println("   ------ --------------------- ---------------- ------");
	comp = itcompras.next(); 
	System.out.printf("\tNumCom: %d,  Fecha compra: %s \n",comp.getNumcompra(), comp.getFechacompra());
	System.out.println("\t---------------------------------------");
	Set<Detallecompras> listadetalle = comp.getDetallecomprases();
	//obtenemos los detalle de la compra
	Iterator <Detallecompras> itdetalle = listadetalle.iterator();
	System.out.println("\tNúmero de artículos de la compra: "+listadetalle.size() );	
	if (listadetalle.size()!=0)	  
		detalledelascomprasdeunclien(itdetalle);		
	else
		System.out.println(" <<<<<<<<<CLIENTE SIN DETALLE-COMPRA >>>>>>> ");	  
	 } // fin while compras del cliente
}//comprasdeuncliente
////////////////////////////////////////////////////////////////////////////////////
private static void detalledelascomprasdeunclien(
	Iterator<Detallecompras> itdetalle)
{
	System.out.println("\tCOD     UNIDADES     PVP       IMPORTE ");
	System.out.println("\t---------------------------------------");
	String cadena;
	float totaluni=0, totalimpor=0;
	String patron="\t%-5d \t%5d %11.2f %12.2f ";
	Detallecompras det = new Detallecompras();
	while(itdetalle.hasNext()) {
		det=itdetalle.next();
		float importe = det.getUnidades().floatValue() * det.getArticulos().getPrecio().floatValue();
		cadena = String.format(patron,det.getArticulos().getCodarticulo(),
				det.getUnidades(), det.getArticulos().getPrecio(), importe);
		  System.out.println(cadena);	
		// sumar a totales  
		totaluni= totaluni + det.getUnidades().floatValue() ;
		totalimpor = totalimpor +	importe;	  
	 } // fin while listadetallecomprases
	 // Visualizar totales
	 System.out.println("\t---------------------------------------");
	 String patron2="\t%-9s %-5.0f \t%s %12.2f ";
	 cadena = String.format(patron2,"TOTALES:",totaluni," ", totalimpor );
	 System.out.println(cadena);
} //detalledelascomprasdeunclien
////////////////////////////////////////////////////////////////////////////////////
private static void resumenclientes () {
float maximp = 0, maxcom=0;

System.out.println("-------------------------------------------------------------------------");
System.out.println("                     RESUMEN DATOS DE CLIENTES ");	  
System.out.println("-------------------------------------------------------------------------");
System.out.println("COD CLI  NOMBRE                LOCALIDAD        NUM_COMPRAS TOTALIMPORTE");
System.out.println("-------- --------------------- ---------------- ----------- -------------");	   
String patron="%-8d %-20s  %-15s %8d \t%8.2f ";
String cadena ="";	
Clientes cli = new Clientes(); 			
Query q = session.createQuery("from Clientes");
List <Clientes> lista = q.list();
if (lista.size()>0)
{
	for (int i=0;i<lista.size(); i++) 
	{
		cli = (Clientes) lista.get(i); 
		Long numc =  (Long) session.createQuery(
			    "select count(*) from Compras c where c.clientes.codigoCli = "+ cli.getCodigoCli() ).uniqueResult();
		 Query consu =  session.createQuery(
				"select coalesce(sum( det.articulos.precio * det.unidades),0) " + 
			    " from Compras co  join co.detallecomprases det " + 
			    "  where co.clientes.codigoCli = ?");
		 consu.setShort(0,cli.getCodigoCli());
		 Double imp  = (Double) consu.uniqueResult();
		 if (imp >maximp) maximp=imp.floatValue();
		 if (numc >maxcom) maxcom=numc;
		 cadena=String.format(patron, cli.getCodigoCli(), cli.getNombre(), cli.getLocalidad(), numc,imp );
	     System.out.println(cadena);	   
	}
	System.out.println("-------- --------------------- ---------------- ----------- -------------");	   
	// total compras
	Long numco =   (Long) session.createQuery(
		    "select count(*) from Compras").uniqueResult();
	Double suma =  (Double) session.createQuery(
			"select coalesce(sum( det.articulos.precio * det.unidades),0) " + 
		    " from Compras co  join co.detallecomprases det " ).uniqueResult();
	 patron="%-8s %-20s  %-15s %8d \t%7.2f ";
	 cadena = String.format(patron, " ","TOTALES ",  " ", numco,  suma);
	 System.out.println(cadena);	
	 System.out.println("-------- --------------------- ---------------- ----------- -------------");	 
	
	 // número de clientes
	 System.out.printf("Número de clientes:  %-7d \n", lista.size()); 
	 // media de compras por cliente
	 float mediacomp = (float) (numco)/(lista.size());
	 System.out.printf("Media de compras por clientes:  %-7.2f \n", mediacomp); 
	 // media de importe por cliente
	 float mediaimp =  (suma.floatValue())/(lista.size());
	 System.out.printf("Media de importe por clientes:  %-7.2f \n", mediaimp); 
	 // cliente con más compra
	 
	 q = session.createQuery(" select co.clientes.codigoCli, co.clientes.nombre, " +
	    " count(*) from Compras co  " + 
	    " group by co.clientes.codigoCli, co.clientes.nombre " +
	    " having   count(*)  = " + maxcom );
	 List<Object[]> climacommax = q.list(); 
	 System.out.printf("Clientes con máximo de compras (máximo=%.0f): \n",maxcom );
	 for (int i = 0; i < climacommax.size(); i++)
	 {
	   Object res[] = climacommax.get(i); 
	   System.out.printf("\tCod Cliente: %d, Nombre: %s \n", res[0],  res[1]); 
	  }
	 // clientes con mas importe
	 q = session.createQuery("select co.clientes.codigoCli, co.clientes.nombre, "+
	    " sum( det.articulos.precio * det.unidades)  "+
	     " from Compras co  join co.detallecomprases det "+
	     " group by  co.clientes.codigoCli,co.clientes.nombre "+
	     " having  sum( det.articulos.precio * det.unidades) = " + maximp );
	List<Object[]> climaximp = q.list(); 
	System.out.printf("Clientes con importe máximo (máximo=%7.2f): \n",maximp );
	for (int i = 0; i < climaximp.size(); i++)
	{
	  Object res[] = climaximp.get(i); 
	  System.out.printf("\tCod Cliente: %d, Nombre: %s \n", res[0],  res[1]); 
	 }
}
else
	System.out.println(" <<<<<<<<< NO HAY CLIENTES >>>>>>> ");	  
System.out.println("-------- --------------------- ---------------- ----------- -------------");	 
volveralmenu();	

} // resumenclientes
////////////////////////////////////////////////////////////////////////////////////
private static void resumenarticulos () {
int sumastock =0;
long sumuni=0, maxuni = 0, maxnumcompra=0;
float totalimpor=0, maximpor=0;

System.out.println("--------------------------------------------------------------------------------------------------------------");
System.out.println("                           RESUMEN DATOS DE ARTICULOS ");	  
System.out.println("--------------------------------------------------------------------------------------------------------------");
System.out.println("COD ARTI     DENOMINACION            PRECIO   STOCK  SUM UNIDAVEND  TOTALIMPORTE NUM_COMP NOMBRE PROVEEDOR");
System.out.println("-------- -------------------------- -------- ------- -------------- ------------ -------- --------------------");	   
String patron="%-8d %-26s %7.2f %7d \t%7d \t%8.2f %8d %-20s";
String cadena ="";

Articulos arti = new Articulos(); 			
Query q = session.createQuery("select a.codarticulo , a.denominacion , a.precio , a.stock , " +
      " coalesce(sum(det.unidades), 0) , coalesce(a.precio * sum(det.unidades),0) , " + 
	  " count(distinct det.compras.numcompra) , a.proveedores.nombre " +
      " from Articulos a left join a.detallecomprases det " +
      " group by a.codarticulo , a.denominacion, a.stock, a.precio,  a.proveedores.nombre " +
      " order by a.codarticulo");

List<Object[]> artic = q.list(); 
if (artic.size() >0)
{
	for (int i = 0; i < artic.size(); i++)
	{
	   Object res[] = artic.get(i); 
	   cadena = String.format(patron, res[0],  res[1],  res[2],  res[3],  
			      res[4],  res[5],  res[6], res[7]);
	   System.out.println(cadena);	 
	   sumastock = sumastock + (short)res[3] ;
	   sumuni= sumuni + ((long) res[4]) ;
	   totalimpor= totalimpor +  (float) res[5];
	   float imp = (float) res[5];;
	   long numc = (long) res[6];   
	   long uni = (long) res[4];  
	   // guardamos los máximos para luego seleccionar los que tienen ese máximo
	   if (uni > maxuni)  maxuni = uni;
	   if (imp > maximpor)  maximpor = imp;
	   if (numc > maxnumcompra)  maxnumcompra = numc;
	}
	
	System.out.println("-------- -------------------------- -------- ------- -------------- ------------ -------- --------------------");
	patron="%-8s %-26s %7s %7d \t%7d \t%8.2f";
	cadena = String.format(patron, " ","TOTALES ",  " ", sumastock,  sumuni,  totalimpor);
	System.out.println(cadena);	
	float mediauni = sumuni / artic.size();
	float mediaimpor = totalimpor / artic.size();
	System.out.println("-------- -------------------------- -------- ------- -------------- ------------ -------- --------------------");
	System.out.printf("Número de artículos:  %-7d \n", artic.size()); 
	System.out.printf("Media de unidades por artículo:  %-7.2f\n", mediauni); 
	System.out.printf("Media de importe por artículo:  %-7.2f \n", mediaimpor); 
	// Media de stock, creamos una consulta
	Double mediastc =   (Double) session.createQuery(
			  "select avg(a.stock) from Articulos a").uniqueResult();
	System.out.printf("Media de stock :  %7.2f \n",mediastc );
	// Artículo con más unidades vendidas
	q = session.createQuery("select a.codarticulo , a.denominacion "+
		      " from Articulos a  join a.detallecomprases det " +
		      " group by a.codarticulo  " +
		      " having sum(det.unidades)= " + maxuni );
	List<Object[]> armaxunida = q.list(); 	
	System.out.printf("Artículos con más unidades (máximo = %d): \n",maxuni );
	for (int i = 0; i < armaxunida.size(); i++)
	{
	   Object res[] = armaxunida.get(i); 
	   System.out.printf("\tCod articulo: %d, Denominación: %s \n", res[0],  res[1]); 
	  }
	
	// artículo o artículos con más importe
	q = session.createQuery("select a.codarticulo , a.denominacion "+
		      " from Articulos a join a.detallecomprases det " +
		      " group by a.codarticulo, a.precio  " +
		      " having  (a.precio * sum(det.unidades)) = " + maximpor );
	List<Object[]> armaximp = q.list(); 
	System.out.printf("Artículos con más importe (máximo = %.2f): \n",maximpor );
	for (int i = 0; i < armaximp.size(); i++)
	{
	 Object res[] = armaximp.get(i); 
	 System.out.printf("\tCod articulo: %d, Denominación: %s \n", res[0],  res[1]); 
	}
	
	// artículos con más compras
	q = session.createQuery("select a.codarticulo , a.denominacion "+
		      " from Articulos a join a.detallecomprases det " +
		      " group by a.codarticulo, a.precio  " +
		      " having  count(distinct det.compras.numcompra) = " + maxnumcompra );
	List<Object[]> armaxcomp = q.list(); 
	System.out.printf("Artículos con más compras (máximo = %d): \n",maxnumcompra );
	for (int i = 0; i < armaxcomp.size(); i++)
	{
		Object res[] = armaxcomp.get(i); 
		System.out.printf("\tCod articulo: %d, Denominación: %s \n", res[0],  res[1]); 
	}
}
else
	System.out.println(" <<<<<<<<< NO HAY ARTÍCULOS >>>>>>> ");	  
System.out.println("--------------------------------------------------------------------------------------------------------------");

volveralmenu();	

}//resumenarticulos

////////////////////////////////////////////////////////////////////////////////////
private static void dibujamenu() {  	
	System.out.println("\t..............................................................");
	System.out.println("\t. Resúmenes. Consultas más complejas. BD prueba de MySQL ..");
	System.out.println("\t..............................................................\n"
	+ "\t\t.  1 Resumen de artículos. \n"
	+ "\t\t.  2 Resumen de clientes.  \n"
	+ "\t\t.  3 Resumen de proveedores. \n"
	+ "\t\t.  4 Detalle de las compras de los clientes. \n"
	+ "\t\t.  0 SALIR.\n"
	+ "\t.................................................................\n");
} // fin dibujamenu
////////////////////////////////////////////////////////////////////////////////////
private static void volveralmenu() {
try {
	System.out.println( "Pulsa una tecla para volver. ");
	System.in.read();
	} catch (IOException e) {System.out.println (e);}
}// volveralmenu
////////////////////////////////////////////////////////////////////////////////////
}

Descarga los proyectos

Descarga los proyectos de las actividades 30 y 40.

Haz clic para descargar los proyectos.

Obra publicada con Licencia de Documentación Libre de GNU (GNU Free Documentation License) (Versión local)

« Anterior | Siguiente »