Carlos Fernández García

Ejercicio 1

Durante los próximos ejercicios vamos a trabajar Bases de datos en mySql, dando en el boton de descarga de este primer ejercicio bajais un archivo que contiene los script para crear dos tablas clientes y ventas asi como para cargar estas tablas con campos ficticios a la base de datos la llame empresa, hay que agregar tambien el conector mysql al paquete java para que funcione

package conecta;

public class Ejercicio1 {

	public static void main(String[] args) {
		/*CREATE TABLE IF NOT EXISTS clientes (
    codigocliente INT AUTO_INCREMENT PRIMARY KEY,
    nombre VARCHAR(100) NOT NULL,
    apellido VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL,
    telefono VARCHAR(15),
    direccion VARCHAR(200)
);*/
		
		/*CREATE TABLE IF NOT EXISTS ventas (
    id_venta INT AUTO_INCREMENT PRIMARY KEY,
    codigocliente INT,
    fecha_venta DATE,
    total DECIMAL(10, 2),
    FOREIGN KEY (codigocliente) REFERENCES clientes(codigocliente)
);*/
	/*-- Insertando 100 clientes sin correos electrónicos duplicados
INSERT INTO clientes (codigocliente, nombre, apellido, email, telefono, direccion) VALUES 
(1, 'Juan', 'Perez', 'juan.perez@example.com', '123456789', 'Calle Principal'),
(2, 'María', 'González', 'maria.gonzalez@example.com', '987654321', 'Avenida Central'),
(3, 'Pedro', 'Martínez', 'pedro.martinez@example.com', '456789123', 'Plaza Mayor'),
(4, 'Ana', 'Rodríguez', 'ana.rodriguez@example.com', '789123456', 'Calle Secundaria'),
(5, 'José', 'López', 'jose.lopez@example.com', '321654987', 'Boulevard Norte'),
(6, 'Sofía', 'Fernández', 'sofia.fernandez@example.com', '654321789', 'Carretera Sur'),
(7, 'Carlos', 'Díaz', 'carlos.diaz@example.com', '147258369', 'Paseo del Bosque'),
(8, 'Laura', 'Sánchez', 'laura.sanchez@example.com', '258369147', 'Avenida del Sol'),
(9, 'Diego', 'Ramírez', 'diego.ramirez@example.com', '369147258', 'Callejón Oscuro'),
(10, 'Paula', 'Gómez', 'paula.gomez@example.com', '951753468', 'Camino Real'),
(11, 'Javier', 'Vázquez', 'javier.vazquez@example.com', '753951852', 'Ruta 66'),
(12, 'Lucía', 'Torres', 'lucia.torres@example.com', '852147963', 'Calle de la Luna'),
(13, 'Miguel', 'Flores', 'miguel.flores@example.com', '159753246', 'Avenida de los Ángeles'),
(14, 'Elena', 'Morales', 'elena.morales@example.com', '357951468', 'Callejón del Diablo'),
(15, 'Alejandro', 'Ortega', 'alejandro.ortega@example.com', '852369741', 'Carretera Estatal'),
(16, 'Andrea', 'Hernández', 'andrea.hernandez@example.com', '123987456', 'Paseo de la Montaña'),
(17, 'Adrián', 'Dominguez', 'adrian.dominguez@example.com', '789456123', 'Avenida del Cielo'),
(18, 'Raquel', 'Jiménez', 'raquel.jimenez@example.com', '456123789', 'Calle Principal'),
(19, 'Mario', 'Moreno', 'mario.moreno@example.com', '987654123', 'Avenida Central'),
(20, 'Natalia', 'Alvarez', 'natalia.alvarez@example.com', '321456987', 'Plaza Mayor'),
(21, 'Alberto', 'Romero', 'alberto.romero@example.com', '654789321', 'Calle Secundaria'),
(22, 'Silvia', 'Pérez', 'silvia.perez@example.com', '789321654', 'Boulevard Norte'),
(23, 'Fernando', 'Gutiérrez', 'fernando.gutierrez@example.com', '147963852', 'Carretera Sur'),
(24, 'Alicia', 'Muñoz', 'alicia.munoz@example.com', '369852147', 'Paseo del Bosque'),
(25, 'Carmen', 'Ruiz', 'carmen.ruiz@example.com', '258147369', 'Avenida del Sol'),
(26, 'Roberto', 'Castro', 'roberto.castro@example.com', '951852963', 'Callejón Oscuro'),
(27, 'Marina', 'Santos', 'marina.santos@example.com', '741852963', 'Camino Real'),
(28, 'Cristian', 'Reyes', 'cristian.reyes@example.com', '852963741', 'Ruta 66'),
(29, 'Sara', 'Iglesias', 'sara.iglesias@example.com', '963852741', 'Calle de la Luna'),
(30, 'Víctor', 'Marín', 'victor.marin@example.com', '789456123', 'Avenida de los Ángeles'),
(31, 'Patricia', 'Molina', 'patricia.molina@example.com', '123789456', 'Callejón del Diablo'),
(32, 'Rubén', 'Herrero', 'ruben.herrero@example.com', '456123789', 'Carretera Estatal'),
(33, 'Eva', 'Arias', 'eva.arias@example.com', '987654321', 'Paseo de la Montaña'),
(34, 'Francisco', 'Vidal', 'francisco.vidal@example.com', '321456987', 'Avenida del Cielo'),
(35, 'Sandra', 'López', 'sandra.lopez@example.com', '654987321', 'Calle Principal'),
(36, 'Óscar', 'Suárez', 'oscar.suarez@example.com', '321654987', 'Avenida Central'),
(37, 'Isabel', 'García', 'isabel.garcia@example.com', '987321654', 'Plaza Mayor'),
(38, 'Gabriel', 'Torres', 'gabriel.torres@example.com', '456987123', 'Calle Secundaria'),
(39, 'Nerea', 'Gómez', 'nerea.gomez@example.com', '123456789', 'Boulevard Norte'),
(40, 'Rosa', 'Ortega', 'rosa.ortega@example.com', '987654321', 'Carretera Sur'),
(41, 'Daniel', 'Jiménez', 'daniel.jimenez@example.com', '321654987', 'Paseo del Bosque'),
(42, 'Celia', 'Moreno', 'celia.moreno@example.com', '789321654', 'Avenida del Sol'),
(43, 'Manuel', 'Alvarez', 'manuel.alvarez@example.com', '654987321', 'Callejón Oscuro'),
(44, 'Natalia', 'Ruiz', 'natalia.ruiz@example.com', '321456987', 'Camino Real'),
(45, 'Jorge', 'Sánchez', 'jorge.sanchez@example.com', '987654123', 'Ruta 66'),
(46, 'Elena', 'Romero', 'elena.romero@example.com', '654321987', 'Calle de la Luna'),
(47, 'Ángel', 'Pérez', 'angel.perez@example.com', '123987456', 'Avenida de los Ángeles'),
(48, 'Sonia', 'Gutiérrez', 'sonia.gutierrez@example.com', '456789123', 'Callejón del Diablo'),
(49, 'Juan', 'Castro', 'juan.castro@example.com', '789123456', 'Carretera Estatal'),
(50, 'Carla', 'Santos', 'carla.santos@example.com', '147852369', 'Paseo de la Montaña'),
(51, 'Marcos', 'Reyes', 'marcos.reyes@example.com', '369258147', 'Avenida del Cielo'),
(52, 'Rocío', 'Iglesias', 'rocio.iglesias@example.com', '852369147', 'Calle Principal'),
(53, 'Pablo', 'Marín', 'pablo.marin@example.com', '159753486', 'Avenida Central'),
(54, 'Laura', 'Molina', 'laura.molina@example.com', '357159684', 'Plaza Mayor'),
(55, 'Santiago', 'Herrero', 'santiago.herrero@example.com', '753951456', 'Calle Secundaria'),
(56, 'Cristina', 'Arias', 'cristina.arias@example.com', '654321789', 'Boulevard Norte'),
(57, 'David', 'Vidal', 'david.vidal@example.com', '987654123', 'Carretera Sur'),
(58, 'Ainhoa', 'López', 'ainhoa.lopez@example.com', '147852369', 'Paseo del Bosque'),
(59, 'Mario', 'Suárez', 'mario.suarez@example.com', '369852147', 'Avenida del Sol'),
(60, 'Nuria', 'García', 'nuria.garcia@example.com', '258147369', 'Callejón Oscuro'),
(61, 'Sara', 'Torres', 'sara.torres@example.com', '951753852', 'Camino Real'),
(62, 'Adrián', 'Gómez', 'adrian.gomez@example.com', '852369741', 'Ruta 66'),
(63, 'Eva', 'Ortega', 'eva.ortega@example.com', '741852963', 'Calle de la Luna'),
(64, 'Rubén', 'Jiménez', 'ruben.jimenez@example.com', '963852741', 'Avenida de los Ángeles'),
(65, 'Olga', 'Moreno', 'olga.moreno@example.com', '159753486', 'Callejón del Diablo'),
(66, 'Alberto', 'Alvarez', 'alberto.alvarez@example.com', '369852147', 'Carretera Estatal'),
(67, 'Marta', 'Ruiz', 'marta.ruiz@example.com', '258369147', 'Paseo de la Montaña'),
(68, 'Daniel', 'Sánchez', 'daniel.sanchez@example.com', '147963852', 'Avenida del Cielo'),
(69, 'Celia', 'Romero', 'celia.romero@example.com', '741852963', 'Calle Principal'),
(70, 'Manuel', 'Pérez', 'manuel.perez@example.com', '852369741', 'Avenida Central'),
(71, 'Nuria', 'Gutiérrez', 'nuria.gutierrez@example.com', '963852741', 'Plaza Mayor'),
(72, 'Raquel', 'Castro', 'raquel.castro@example.com', '123789456', 'Calle Secundaria'),
(73, 'Iván', 'Santos', 'ivan.santos@example.com', '456123789', 'Boulevard Norte'),
(74, 'Sergio', 'Reyes', 'sergio.reyes@example.com', '987654321', 'Carretera Sur'),
(75, 'Ana', 'López', 'ana.lopez@example.com', '321654987', 'Paseo del Bosque'),
(76, 'David', 'Suárez', 'david.suarez@example.com', '654987321', 'Avenida del Sol'),
(77, 'Elena', 'García', 'elena.garcia@example.com', '321456987', 'Callejón Oscuro'),
(78, 'Jorge', 'Torres', 'jorge.torres@example.com', '987654123', 'Camino Real'),
(79, 'Sara', 'Gómez', 'sara.gomez@example.com', '147852369', 'Ruta 66'),
(80, 'Adrián', 'Ortega', 'adrian.ortega@example.com', '369852147', 'Calle de la Luna'),
(81, 'Eva', 'Jiménez', 'eva.jimenez@example.com', '258369147', 'Avenida de los Ángeles'),
(82, 'Marta', 'Moreno', 'marta.moreno@example.com', '741852963', 'Callejón del Diablo'),
(83, 'Daniel', 'Alvarez', 'daniel.alvarez@example.com', '852369741', 'Carretera Estatal'),
(84, 'Celia', 'Ruiz', 'celia.ruiz@example.com', '963852741', 'Paseo de la Montaña'),
(85, 'Manuel', 'Sánchez', 'manuel.sanchez@example.com', '123789456', 'Avenida del Cielo'),
(86, 'Nuria', 'Romero', 'nuria.romero@example.com', '456123789', 'Calle Principal'),
(87, 'Raquel', 'Pérez', 'raquel.perez@example.com', '789456123', 'Avenida Central'),
(88, 'Iván', 'Gutiérrez', 'ivan.gutierrez@example.com', '321654987', 'Plaza Mayor'),
(89, 'Sergio', 'Castro', 'sergio.castro@example.com', '654987321', 'Calle Secundaria'),
(90, 'Ana', 'Santos', 'ana.santos@example.com', '147852369', 'Boulevard Norte'),
(91, 'David', 'Reyes', 'david.reyes@example.com', '369852147', 'Carretera Sur'),
(92, 'Elena', 'López', 'elena.lopez@example.com', '987654123', 'Paseo del Bosque'),
(93, 'Jorge', 'Suárez', 'jorge.suarez@example.com', '123456789', 'Avenida del Sol'),
(94, 'Sara', 'García', 'sara.garcia@example.com', '987321654', 'Callejón Oscuro'),
(95, 'Adrián', 'Torres', 'adrian.torres@example.com', '456987123', 'Camino Real'),
(96, 'Eva', 'Gómez', 'eva.gomez@example.com', '123456789', 'Ruta 66'),
(97, 'Marta', 'Ortega', 'marta.ortega@example.com', '987654321', 'Calle de la Luna'),
(98, 'Daniel', 'Jiménez', 'daniel.jimenez@example.com', '654987321', 'Avenida de los Ángeles'),
(99, 'Celia', 'Moreno', 'celia.moreno@example.com', '321654987', 'Callejón del Diablo'),
(100, 'Manuel', 'Alvarez', 'manuel.alvarez@example.com', '789321654', 'Carretera Estatal');
*/	
		/*INSERT INTO ventas (codigocliente, fecha_venta, total) VALUES 
(1, '2024-01-01', 100.50),
(2, '2024-01-02', 75.25),
(3, '2024-01-03', 200.00),
(4, '2024-01-04', 150.75),
(5, '2024-01-05', 80.90),
(6, '2024-01-06', 120.00),
(7, '2024-01-07', 95.60),
(8, '2024-01-08', 180.25),
(9, '2024-01-09', 210.75),
(10, '2024-01-10', 300.00),
(11, '2024-01-11', 150.25),
(12, '2024-01-12', 90.30),
(13, '2024-01-13', 120.50),
(14, '2024-01-14', 250.75),
(15, '2024-01-15', 180.90),
(16, '2024-01-16', 160.00),
(17, '2024-01-17', 95.60),
(18, '2024-01-18', 210.25),
(19, '2024-01-19', 220.75),
(20, '2024-01-20', 400.00),
(1, '2024-01-21', 200.25),
(2, '2024-01-22', 110.30),
(3, '2024-01-23', 90.50),
(4, '2024-01-24', 150.75),
(5, '2024-01-25', 280.90),
(6, '2024-01-26', 200.00),
(7, '2024-01-27', 105.60),
(8, '2024-01-28', 190.25),
(9, '2024-01-29', 230.75),
(10, '2024-01-30', 320.00),
(11, '2024-01-31', 170.25),
(12, '2024-02-01', 100.30),
(13, '2024-02-02', 130.50),
(14, '2024-02-03', 220.75),
(15, '2024-02-04', 190.90),
(16, '2024-02-05', 150.00),
(17, '2024-02-06', 115.60),
(18, '2024-02-07', 250.25),
(19, '2024-02-08', 240.75),
(20, '2024-02-09', 400.00),
(1, '2024-02-10', 180.25),
(2, '2024-02-11', 120.30),
(3, '2024-02-12', 110.50),
(4, '2024-02-13', 200.75),
(5, '2024-02-14', 320.90),
(6, '2024-02-15', 180.00),
(7, '2024-02-16', 135.60),
(8, '2024-02-17', 210.25),
(9, '2024-02-18', 250.75),
(10, '2024-02-19', 350.00),
(11, '2024-02-20', 170.25),
(12, '2024-02-21', 130.30),
(13, '2024-02-22', 140.50),
(14, '2024-02-23', 240.75),
(15, '2024-02-24', 220.90),
(16, '2024-02-25', 170.00),
(17, '2024-02-26', 125.60),
(18, '2024-02-27', 280.25),
(19, '2024-02-28', 260.75),
(20, '2024-02-29', 380.00),
(1, '2024-03-01', 200.25),
(2, '2024-03-02', 140.30),
(3, '2024-03-03', 100.50),
(4, '2024-03-04', 180.75),
(5, '2024-03-05', 290.90),
(6, '2024-03-06', 190.00),
(7, '2024-03-07', 145.60),
(8, '2024-03-08', 220.25),
(9, '2024-03-09', 270.75),
(10, '2024-03-10', 370.00),
(11, '2024-03-11', 190.25),
(12, '2024-03-12', 150.30),
(13, '2024-03-13', 110.50),
(14, '2024-03-14', 220.75),
(15, '2024-03-15', 200.90),
(16, '2024-03-16', 150.00),
(17, '2024-03-17', 105.60),
(18, '2024-03-18', 240.25),
(19, '2024-03-19', 220.75),
(20, '2024-03-20', 350.00),
(1, '2024-03-21', 170.25),
(2, '2024-03-22', 130.30),
(3, '2024-03-23', 120.50),
(4, '2024-03-24', 220.75),
(5, '2024-03-25', 190.90),
(6, '2024-03-26', 150.00),
(7, '2024-03-27', 115.60),
(8, '2024-03-28', 280.25),
(9, '2024-03-29', 260.75),
(10, '2024-03-30', 380.00),
(11, '2024-03-31', 200.25),
(12, '2024-04-01', 140.30),
(13, '2024-04-02', 100.50),
(14, '2024-04-03', 180.75),
(15, '2024-04-04', 290.90),
(16, '2024-04-05', 190.00),
(17, '2024-04-06', 145.60),
(18, '2024-04-07', 220.25),
(19, '2024-04-08', 270.75),
(20, '2024-04-09', 370.00),
(1, '2024-04-10', 190.25),
(2, '2024-04-11', 150.30),
(3, '2024-04-12', 110.50),
(4, '2024-04-13', 220.75),
(5, '2024-04-14', 200.90),
(6, '2024-04-15', 150.00),
(7, '2024-04-16', 115.60),
(8, '2024-04-17', 280.25),
(9, '2024-04-18', 260.75),
(10, '2024-04-19', 380.00),
(11, '2024-04-20', 200.25),
(12, '2024-04-21', 140.30),
(13, '2024-04-22', 100.50),
(14, '2024-04-23', 180.75),
(15, '2024-04-24', 290.90),
(16, '2024-04-25', 190.00),
(17, '2024-04-26', 145.60),
(18, '2024-04-27', 220.25),
(19, '2024-04-28', 270.75),
(20, '2024-04-29', 370.00),
(1, '2024-04-30', 180.25),
(2, '2024-05-01', 120.30),
(3, '2024-05-02', 110.50),
(4, '2024-05-03', 200.75),
(5, '2024-05-04', 320.90),
(6, '2024-05-05', 180.00),
(7, '2024-05-06', 135.60),
(8, '2024-05-07', 210.25),
(9, '2024-05-08', 250.75),
(10, '2024-05-09', 350.00),
(11, '2024-05-10', 170.25),
(12, '2024-05-11', 130.30),
(13, '2024-05-12', 140.50),
(14, '2024-05-13', 240.75),
(15, '2024-05-14', 220.90),
(16, '2024-05-15', 170.00),
(17, '2024-05-16', 125.60),
(18, '2024-05-17', 280.25),
(19, '2024-05-18', 260.75),
(20, '2024-05-19', 380.00),
(1, '2024-05-20', 200.25),
(2, '2024-05-21', 140.30),
(3, '2024-05-22', 100.50),
(4, '2024-05-23', 180.75),
(5, '2024-05-24', 290.90),
(6, '2024-05-25', 190.00),
(7, '2024-05-26', 145.60),
(8, '2024-05-27', 220.25),
(9, '2024-05-28', 270.75),
(10, '2024-05-29', 370.00),
(11, '2024-05-30', 190.25),
(12, '2024-05-31', 150.30),
(13, '2024-06-01', 110.50),
(14, '2024-06-02', 220.75),
(15, '2024-06-03', 200.90),
(16, '2024-06-04', 150.00),
(17, '2024-06-05', 105.60),
(18, '2024-06-06', 240.25),
(19, '2024-06-07', 220.75),
(20, '2024-06-08', 350.00),
(1, '2024-06-09', 170.25),
(2, '2024-06-10', 130.30),
(3, '2024-06-11', 120.50),
(4, '2024-06-12', 220.75),
(5, '2024-06-13', 190.90),
(6, '2024-06-14', 150.00),
(7, '2024-06-15', 115.60),
(8, '2024-06-16', 280.25),
(9, '2024-06-17', 260.75),
(10, '2024-06-18', 380.00),
(11, '2024-06-19', 200.25),
(12, '2024-06-20', 140.30),
(13, '2024-06-21', 100.50),
(14, '2024-06-22', 180.75),
(15, '2024-06-23', 290.90),
(16, '2024-06-24', 190.00),
(17, '2024-06-25', 145.60),
(18, '2024-06-26', 220.25),
(19, '2024-06-27', 270.75),
(20, '2024-06-28', 370.00),
(1, '2024-06-29', 190.25),
(2, '2024-06-30', 150.30),
(3, '2024-07-01', 110.50),
(4, '2024-07-02', 220.75),
(5, '2024-07-03', 200.90),
(6, '2024-07-04', 150.00),
(7, '2024-07-05', 115.60),
(8, '2024-07-06', 280.25),
(9, '2024-07-07', 260.75),
(10, '2024-07-08', 380.00),
(11, '2024-07-09', 200.25),
(12, '2024-07-10', 140.30),
(13, '2024-07-11', 100.50),
(14, '2024-07-12', 180.75),
(15, '2024-07-13', 290.90),
(16, '2024-07-14', 190.00),
(17, '2024-07-15', 145.60),
(18, '2024-07-16', 220.25),
(19, '2024-07-17', 270.75),
(20, '2024-07-18', 370.00),
(1, '2024-07-19', 190.25),
(2, '2024-07-20', 150.30),
(3, '2024-07-21', 110.50),
(4, '2024-07-22', 220.75),
(5, '2024-07-23', 200.90),
(6, '2024-07-24', 150.00),
(7, '2024-07-25', 115.60),
(8, '2024-07-26', 280.25),
(9, '2024-07-27', 260.75),
(10, '2024-07-28', 380.00),
(11, '2024-07-29', 200.25),
(12, '2024-07-30', 140.30),
(13, '2024-07-31', 100.50),
(14, '2024-08-01', 180.75),
(15, '2024-08-02', 290.90),
(16, '2024-08-03', 190.00),
(17, '2024-08-04', 145.60),
(18, '2024-08-05', 220.25),
(19, '2024-08-06', 270.75),
(20, '2024-08-07', 370.00),
(1, '2024-08-08', 190.25),
(2, '2024-08-09', 150.30),
(3, '2024-08-10', 110.50),
(4, '2024-08-11', 220.75),
(5, '2024-08-12', 200.90),
(6, '2024-08-13', 150.00),
(7, '2024-08-14', 115.60),
(8, '2024-08-15', 280.25),
(9, '2024-08-16', 260.75),
(10, '2024-08-17', 380.00),
(11, '2024-08-18', 200.25),
(12, '2024-08-19', 140.30),
(13, '2024-08-20', 100.50),
(14, '2024-08-21', 180.75),
(15, '2024-08-22', 290.90),
(16, '2024-08-23', 190.00),
(17, '2024-08-24', 145.60),
(18, '2024-08-25', 220.25),
(19, '2024-08-26', 270.75),
(20, '2024-08-27', 370.00);
*/
		
	}

}

Ejercicio 2

Desarrolla un programa en Java que se conecte a la base de datos "empresa" en MySQL y recupere los datos de la tabla "clientes". El programa debe mostrar en la consola la lista de clientes con todos sus campos, incluyendo el código de cliente, nombre, apellido, email y teléfono. El programa debe utilizar JDBC para establecer la conexión con la base de datos y realizar la consulta SQL necesaria para recuperar los datos de la tabla "clientes". Luego, debe procesar los resultados de la consulta y mostrar la información de cada cliente en la consola de manera legible. Asegúrate de manejar adecuadamente cualquier excepción que pueda ocurrir durante la conexión a la base de datos o la ejecución de la consulta SQL, proporcionando mensajes de error informativos al usuario en caso de que algo salga mal.

package conecta;

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

public class Ejercicio2 {

    public static void main(String[] args) {
        Connection miConexion = null;
        Statement miStatement = null;
        ResultSet miResultset = null;
        
        try {
            miConexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/EMPRESA", "root", "*prueba2024*");
            miStatement = miConexion.createStatement();
            
            miResultset = miStatement.executeQuery("SELECT * FROM clientes");
            
            while (miResultset.next()) {
                System.out.println(miResultset.getString("codigocliente") + " " + 
                                   miResultset.getString("nombre") + " " + 
                                   miResultset.getString("apellido") + " " + 
                                   miResultset.getString("email") + " " + 
                                   miResultset.getString("telefono")+ " " + 
                                   miResultset.getString("direccion"));
            }
        } catch (SQLException e) {
            System.err.println("Error de SQL: " + e.getMessage());
        } finally {
            // Cerrar recursos
            if (miResultset != null) {
                try {
                    miResultset.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar ResultSet: " + e.getMessage());
                }
            }
            if (miStatement != null) {
                try {
                    miStatement.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar Statement: " + e.getMessage());
                }
            }
            if (miConexion != null) {
                try {
                    miConexion.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar conexión: " + e.getMessage());
                }
            }
        }
    }
}

Ejercicio 3

Desarrolla un programa en Java que se conecte a la base de datos "empresa" en MySQL y recupere los datos de la tabla "ventas". El programa debe mostrar en la consola la lista de ventas con todos sus campos, incluyendo el código de venta, código de cliente, fecha y total de la venta. El programa debe utilizar JDBC para establecer la conexión con la base de datos y realizar la consulta SQL necesaria para recuperar los datos de la tabla "ventas". Luego, debe procesar los resultados de la consulta y mostrar la información de cada venta en la consola de manera legible. Asegúrate de manejar adecuadamente cualquier excepción que pueda ocurrir durante la conexión a la base de datos o la ejecución de la consulta SQL, proporcionando mensajes de error informativos al usuario en caso de que algo salga mal.

Ejercicio 4

Desarrolla un programa en Java que permita a un usuario agregar un nuevo cliente a la base de datos "empresa" en MySQL. El programa debe solicitar al usuario que ingrese los datos del nuevo cliente, como el nombre, apellido, email, teléfono y dirección. Luego, debe conectar con la base de datos y agregar el nuevo cliente a la tabla "clientes". Después de agregar el cliente, el programa debe mostrar un mensaje indicando que el cliente ha sido agregado con éxito. El programa debe utilizar JDBC para establecer la conexión con la base de datos y ejecutar una consulta SQL de inserción para agregar el nuevo cliente. Asegúrate de manejar adecuadamente cualquier excepción que pueda ocurrir durante la conexión a la base de datos o la ejecución de la consulta SQL, proporcionando mensajes de error informativos al usuario en caso de que algo salga mal.

Ejercicio 5

Desarrolla un programa en Java que permita eliminar clientes de la base de datos "empresa" en MySQL según un criterio específico. Eliminar clientes por apellido: El programa debe solicitar al usuario ingresar un apellido específico. Luego, debe conectar con la base de datos y eliminar todos los clientes que tengan ese apellido de la tabla "clientes". Después de eliminar los clientes, el programa debe mostrar un mensaje indicando la cantidad de clientes eliminados.

Ejercicio 6

Desarrolla un programa en Java que permita eliminar clientes de la base de datos "empresa" en MySQL según un criterio específico. Eliminar clientes por apellido: El programa debe solicitar al usuario ingresar un apellido específico. Luego, debe conectar con la base de datos y eliminar todos los clientes que tengan ese apellido de la tabla "clientes". Después de eliminar los clientes, el programa debe mostrar un mensaje indicando la cantidad de clientes eliminados.

package conecta;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio6 {

	public static void main(String[] args) {
		String apellidoActual,apellidoNuevo;
		Scanner entrada=new Scanner(System.in);
		String consulta;
		Connection miConexion=null;
		ResultSet miResultset=null;
		PreparedStatement actualizo=null;
		
		System.out.println("Introduce el apellido que quieres actualzar:");
		apellidoActual=entrada.nextLine();
		
		System.out.println("Introduce el apellido que quieres poner:");
		apellidoNuevo=entrada.nextLine();
		
		try {
			miConexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/EMPRESA", "root", "*prueba2024*");
			consulta="Select codigocliente from clientes where apellido=?";
			actualizo=miConexion.prepareStatement(consulta);
			actualizo.setString(1, apellidoActual);
			miResultset=actualizo.executeQuery();
			
			ArrayList<String> codigos=new ArrayList<String>();
			while(miResultset.next()) {
				codigos.add(miResultset.getString("codigocliente"));
			}
			
			int actualizados=0;
			
			for (String codigo : codigos) {
				consulta="update clientes set apellido=? where codigocliente=?";
				actualizo=miConexion.prepareStatement(consulta);
				actualizo.setString(1, apellidoNuevo);
				actualizo.setString(2, codigo);
				actualizados+=actualizo.executeUpdate();
			}
			System.out.println("Se actualizaron los apellidos de " + actualizados + " clientes");
			miResultset.close();
			actualizo.close();
			miConexion.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			System.err.println("Error al actualizar " + e.getMessage());
			
		}
		try {
			miResultset.close();
		} catch (SQLException e) {
			
			System.err.println("Error al actualizar " + e.getMessage());
		}
		try {
			actualizo.close();
		} catch (SQLException e) {
			
			System.err.println("Error al actualizar " + e.getMessage());
		}
		try {
			miConexion.close();
		} catch (SQLException e) {
			
			System.err.println("Error al actualizar " + e.getMessage());
		}
		
	}

}

Ejercicio 7

Desarrolla un programa en Java que permita actualizar el total de las ventas en la tabla "ventas" de la base de datos "empresa" en MySQL. El programa debe solicitar al usuario ingresar un apellido específico. Luego, debe conectar con la base de datos y buscar todos los clientes que tengan ese apellido en la tabla "clientes". Posteriormente, debe calcular un descuento del 10% sobre el total de las ventas para cada cliente encontrado y actualizar el campo "total" en la tabla "ventas" con el nuevo valor. Después de actualizar los totales, el programa debe mostrar un mensaje indicando la cantidad de ventas actualizadas. El programa debe utilizar JDBC para establecer la conexión con la base de datos y ejecutar consultas SQL para buscar los clientes y actualizar los totales de ventas. Asegúrate de manejar adecuadamente cualquier excepción que pueda ocurrir durante la conexión a la base de datos o la ejecución de las consultas SQL, proporcionando mensajes de error informativos al usuario en caso de que algo salga mal.

Ejercicio 8

Desarrolla un programa en Java que permita consultar las ventas realizadas por un cliente específico en la base de datos "empresa" en MySQL. El programa debe solicitar al usuario ingresar el correo electrónico del cliente. Luego, debe conectar con la base de datos y buscar el cliente con ese correo electrónico en la tabla "clientes". Posteriormente, debe mostrar todas las ventas realizadas por ese cliente, incluyendo el id de la venta, la fecha de la venta y el total de la venta. Si el cliente no tiene ventas registradas, el programa debe mostrar un mensaje indicando que el cliente no tiene ventas. El programa debe utilizar JDBC para establecer la conexión con la base de datos y ejecutar consultas SQL para buscar el cliente y sus ventas. Asegúrate de manejar adecuadamente cualquier excepción que pueda ocurrir durante la conexión a la base de datos o la ejecución de las consultas SQL, proporcionando mensajes de error informativos al usuario en caso de que algo salga mal.

package conecta;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio8 {

	public static void main(String[] args) {
		Scanner entrada=new Scanner(System.in);
		String email,consulta="",codigo="";
		
		Connection miConexion=null;
		ResultSet rs=null;
		PreparedStatement miStatement=null;
		
		
		System.out.println("Introduce el email del cliente");
		email=entrada.next();
		entrada.close();
		
		
		try {
			miConexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/EMPRESA", "root", "*prueba2024*");
			consulta="select codigocliente from clientes where email=?";
			miStatement=miConexion.prepareStatement(consulta);
			miStatement.setString(1,email);
			rs=miStatement.executeQuery();
			
			while(rs.next()) {
				codigo=rs.getString("codigocliente");
			}
			
			double total=0.0;
			if(codigo!="") {
				consulta="select id_venta,fecha_venta,total from ventas where codigocliente=?";
				miStatement=miConexion.prepareStatement(consulta);
				miStatement.setString(1,codigo);
				rs=miStatement.executeQuery();
				
				if(rs.isBeforeFirst()) {
					System.out.println("id_ventas           fecha_venta        total");
					while(rs.next()){
						System.out.println("  " + rs.getString("id_venta")+ "              " + rs.getString("fecha_venta") + "           " + rs.getString("total") + "€");
						total+=Double.parseDouble(rs.getString("total"));
					}
					System.out.println("Total de todas las compras del cliente: " +String.format("%.2f", total) + "€" );
				}else {
					System.out.println("El cliente no tiene compras aun");
				}
			}else {
				System.err.println("El cliente no esta en la base de datos con ese email");
			}
			
			
			
			
			
			miConexion.close();
			miStatement.close();
			rs.close();
		} catch (SQLException e) {
			System.err.println("Error a trabajar con la base de datos "  +e.getMessage());
		}
	}

}

Ejercicio 9

Desarrolla un programa en Java que genere un reporte de ventas para un período de tiempo específico. El programa debe solicitar al usuario ingresar dos fechas: la fecha de inicio y la fecha de fin del período de tiempo para el cual se desea generar el reporte. Luego, debe conectar con la base de datos "empresa" en MySQL y buscar todas las ventas realizadas dentro de ese período de tiempo en la tabla "ventas". Posteriormente, debe mostrar en la consola un resumen de las ventas, incluyendo el número de ventas realizadas, el total de ventas en ese período y la fecha de cada venta. El programa debe utilizar JDBC para establecer la conexión con la base de datos y ejecutar una consulta SQL para recuperar las ventas dentro del período especificado. Asegúrate de manejar adecuadamente cualquier excepción que pueda ocurrir durante la conexión a la base de datos o la ejecución de la consulta SQL, proporcionando mensajes de error informativos al usuario en caso de que algo salga mal.

Ejercicio 10

Desarrolla un programa en Java que permita actualizar los datos de una venta en la tabla "ventas" de la base de datos "empresa" en MySQL. El programa debe solicitar al usuario que ingrese el ID de la venta que desea actualizar y los nuevos datos para dicha venta, como la fecha de venta y el total. Luego, debe conectar con la base de datos y actualizar la venta correspondiente en la tabla "ventas". Después de actualizar la venta, el programa debe mostrar un mensaje indicando que la venta ha sido actualizada con éxito.

Ejercicio 11

Desarrolla un programa en Java que permita consultar clientes junto con sus ventas realizadas en la base de datos "empresa" en MySQL. El programa debe solicitar al usuario ingresar el ID de un cliente específico. Luego, debe conectar con la base de datos y buscar todas las ventas realizadas por ese cliente en la tabla "ventas", así como también mostrar los datos del cliente de la tabla "clientes". Posteriormente, debe mostrar en la consola un resumen de las ventas del cliente, incluyendo el número de ventas realizadas, el total de ventas y la fecha de cada venta.

package conecta;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio11 {

	public static void main(String[] args) {
		Scanner entrada=new Scanner(System.in);
		String codigoCliente,consulta="";
		
		System.out.println("Introduce el codigo de cliente");
		codigoCliente=entrada.next();
		
		entrada.close();
		
		
		Connection miConexion=null;
		ResultSet rs=null;
		PreparedStatement miStatement=null;
		
		
		try {
			miConexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/EMPRESA", "root", "*prueba2024*");
			consulta="select * from clientes where codigocliente=?";
			miStatement=miConexion.prepareStatement(consulta);
			miStatement.setString(1, codigoCliente);
			rs=miStatement.executeQuery();
			
			if(rs.isBeforeFirst()) {
				while(rs.next()) {
					System.out.println("Codigo:" + rs.getString("codigocliente"));
					System.out.println("Nombre:" + rs.getString("nombre"));
					System.out.println("Apellido:" + rs.getString("apellido"));
					System.out.println("Email:" + rs.getString("email"));
					System.out.println("Telefono:" + rs.getString("telefono"));
					System.out.println("Direccion:" + rs.getString("direccion"));
				}
				
				consulta="select * from ventas where codigocliente=?";
				miStatement=miConexion.prepareStatement(consulta);
				miStatement.setString(1, codigoCliente);
				rs=miStatement.executeQuery();
				double total=0.0;
				int ventas=0;
				if(rs.isBeforeFirst()) {
					while(rs.next()) {
						System.out.println(rs.getString("id_venta") + "     " + rs.getString("fecha_venta") + "      " + rs.getString("total"));
						total+=Double.parseDouble(rs.getString("total"));
						ventas++;
					}
					System.out.println("El cliente realizo " + ventas + " ventas y ascienden a un total de " + total + "€");
				}else {
					System.out.println("El cliente no tiene ventas en la base de datos");
				}
				
			}else {
				System.out.println("El cliente no se encuentra en la base de datos");
			}
			
			
			miConexion.close();
			rs.close();
			miStatement.close();
		} catch (SQLException e) {
			System.err.println("Error en la base de datos " + e.getMessage());
		}

	}

}

Ejercicio 12

Desarrolla un programa en Java que permita actualizar los datos de un cliente en la tabla "clientes" de la base de datos "empresa" en MySQL. El programa debe solicitar al usuario que ingrese el ID del cliente que desea actualizar y los nuevos datos para dicho cliente, como el nombre, el apellido, el correo electrónico, el teléfono y la dirección. Luego, debe conectar con la base de datos y actualizar los datos correspondientes del cliente en la tabla "clientes". Después de actualizar los datos, el programa debe mostrar un mensaje indicando que los datos del cliente han sido actualizados con éxito.

package conecta;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio12 {

	public static void main(String[] args) {
		Scanner entrada=new Scanner(System.in);
		String codigoCliente,nombre,apellido,email,telefono,direccion,consulta="";
		
		System.out.println("Introduce el codigo de cliente");
		codigoCliente=entrada.next();
		
		entrada.nextLine();
		Connection miConexion=null;
		ResultSet rs=null;
		PreparedStatement miStatement=null;
		
		try {
			miConexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/EMPRESA", "root", "*prueba2024*");
			consulta="select * from clientes where codigocliente=?";
			miStatement=miConexion.prepareStatement(consulta);
			miStatement.setString(1, codigoCliente);
			rs=miStatement.executeQuery();
			
			if(rs.isBeforeFirst()) {
				System.out.println("Introduce el nuevo nombre");
				nombre=entrada.nextLine();
				
				System.out.println("Introduce el nuevo apellido");
				apellido=entrada.nextLine();
				
				System.out.println("Introduce el nuevo email");
				email=entrada.next();
				
				System.out.println("Introduce el nuevo telefono");
				telefono=entrada.next();
				
				entrada.nextLine();
				
				System.out.println("Introduce la nueva direccion");
				direccion=entrada.nextLine();
				
				entrada.close();
				
				consulta="update clientes set nombre=?,apellido=?,email=?,telefono=?,direccion=? where codigoCliente=?";
				miStatement=miConexion.prepareStatement(consulta);
				miStatement.setString(1, nombre);
				miStatement.setString(2, apellido);
				miStatement.setString(3, email);
				miStatement.setString(4, telefono);
				miStatement.setString(5, direccion);
				miStatement.setString(6, codigoCliente);
				
				int actualizo=miStatement.executeUpdate();
				
				if(actualizo!=0) {
					System.out.println("Cliente actualizdo correctamente");
				}else {
					System.err.println("Fallo de la actualizacion");
				}
				
			}else {
				System.out.println("El cliente no se encuentra en la base de datos");
			}
			
			miConexion.close();
			rs.close();
			miStatement.close();
		} catch (SQLException e) {
			System.err.println("Error al trabajar con la base de datos " + e.getMessage());
		}

	}

}

Ejercicio 13

Desarrolla un programa en Java que permita eliminar un cliente de la tabla "clientes" en la base de datos "empresa" en MySQL. El programa debe solicitar al usuario que ingrese el ID del cliente que desea eliminar. Luego, debe conectar con la base de datos y buscar si el cliente existe en la tabla "clientes". Si el cliente existe, se debe eliminar de la tabla y mostrar un mensaje indicando que el cliente ha sido eliminado con éxito. Si el cliente no existe, se debe mostrar un mensaje indicando que el cliente no se encontró en la base de datos.

package conecta;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio13 {

	public static void main(String[] args) {
		Scanner entrada=new Scanner(System.in);
		
		String codigo,consulta="";
		
		System.out.println("Introduce el codigo de cliente a borrar");
		codigo=entrada.next();
		
		entrada.close();
		
		Connection miConexion=null;
		ResultSet rs=null;
		PreparedStatement miStatement=null;
		
		
		try {
			miConexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/EMPRESA", "root", "*prueba2024*");
			consulta="select codigocliente from clientes where codigocliente=?";
			miStatement=miConexion.prepareStatement(consulta);
			miStatement.setString(1, codigo);
			rs=miStatement.executeQuery();
			
			if(rs.isBeforeFirst()) {
				consulta="select id_venta from ventas where codigocliente=?";
				miStatement=miConexion.prepareStatement(consulta);
				miStatement.setString(1, codigo);
				rs=miStatement.executeQuery();
				int ventas=0;
				if(rs.isBeforeFirst()) {
					while(rs.next()) {
						consulta="delete from ventas where codigocliente=?";
						miStatement=miConexion.prepareStatement(consulta);
						miStatement.setString(1, rs.getString("id_venta"));
						ventas+=miStatement.executeUpdate();
					}
					System.out.println("Se borraron " + ventas + " registros de la tabla ventas asociados al cliente");
					ventas=0;
					consulta="delete from clientes where codigocliente=?";
					miStatement=miConexion.prepareStatement(consulta);
					miStatement.setString(1,codigo);
					ventas+=miStatement.executeUpdate();
					
					if(ventas==0) {
						System.out.println("El cliente no se borro");
					}else {
						System.out.println("Cliente borrado con exito");
					}
				}else {
					System.out.println("El cliente no tenia ventas asociadas");
				}
			}else {
				System.out.println("El cliente no se encuentra en nuestra base de datos");
			}
			
			miConexion.close();
			rs.close();
			miStatement.close();
		} catch (SQLException e) {
			System.err.println("Error al trabajar con la base de datos " + e.getMessage());
		}
		

	}

}

Ejercicio 14

Desarrolla un programa en Java que permita insertar una nueva venta en la tabla "ventas" de la base de datos "empresa" en MySQL. El programa debe solicitar al usuario que ingrese los datos de la nueva venta, incluyendo el ID del cliente, la fecha de la venta y el total. Luego, debe conectar con la base de datos y realizar la inserción de la nueva venta en la tabla "ventas". Después de insertar la venta, el programa debe mostrar un mensaje indicando que la venta ha sido agregada con éxito.

package conecta;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio14 {

	public static void main(String[] args) {
		Scanner entrada=new Scanner(System.in);
		String consulta="",codigoCliente;
		
		System.out.println("Introduce el codigo de cliente para hacerle una venta");
		codigoCliente=entrada.nextLine();
		
		Connection miConexion=null;
		ResultSet rs=null;
		PreparedStatement miStatement=null;
		
		try {
			miConexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/EMPRESA", "root", "*prueba2024*");
			consulta="select codigocliente from clientes where codigocliente=?";
			miStatement=miConexion.prepareStatement(consulta);
			miStatement.setString(1, codigoCliente);
			rs=miStatement.executeQuery();
			
			if(rs.next()) {
				String fechaVenta;
				double total;
				
				System.out.println("introduce la fecha de venta (yyyy-mm-dd)");
				fechaVenta=entrada.nextLine();
				while(true)
				{
					try {
						System.out.println("introduce la cantidad total de la venta");
						total=Double.parseDouble(entrada.nextLine());
						break;
					}catch(NumberFormatException e) {
						System.out.println("No es una cantidad valida");
					}
				}
				
				entrada.close();
				
				consulta="insert into ventas (codigocliente,fecha_venta,total) values(?,?,?)";
				miStatement=miConexion.prepareStatement(consulta);
				miStatement.setString(1, codigoCliente);
				miStatement.setString(2, fechaVenta);
				miStatement.setDouble(3, total);
				int venta=miStatement.executeUpdate();
				
				if(venta!=0) {
					System.out.println("Venta realizada corectamente");
				}else {
					System.err.println("Error en la venta");
				}
				
			}else {
				System.out.println("El cliente no esta dado de alta en la base de datos");
			}
			
			miConexion.close();
			miStatement.close();
			rs.close();
		} catch (SQLException e) {
			System.err.println("Error al trabajar conla base de datos " + e.getMessage());
		}

	}

}

Ejercicio 15

Suma los subtotales

package conecta;

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


public class Ejercicio15 {

	public static void main(String[] args) {
		String consulta="";
		ArrayList<Cliente> clientes=new ArrayList<Cliente>();
		Cliente cliente=new Cliente();
		
		Connection miConexion=null;
		ResultSet rs=null;
		PreparedStatement miStatement=null;
		
		cliente.listaClientes(clientes);
		
		try {
			miConexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/EMPRESA", "root", "*prueba2024*");
			for (Cliente cli : clientes) {
				consulta="select codigocliente,sum(total) as totales from ventas where codigocliente=? group by codigocliente";
				miStatement=miConexion.prepareStatement(consulta);
				miStatement.setString(1, cli.getCodigoCliente());
				rs=miStatement.executeQuery();
				if(rs.next()) {
					System.out.println("\nCodigo: " + cli.getCodigoCliente());
					System.out.println("Nombre: " + cli.getNombre());
					System.out.println("Apellido: " + cli.getApellido());
					System.out.println("Total de compras: " + rs.getString("totales") +"€");
				}
					
			}
			
			rs.close();
			miConexion.close();
			miStatement.close();
		} catch (SQLException e) {
			System.err.println("Error en la base de datos " +e.getMessage());
		}
		
		

	}

}


class Cliente{
	private String codigoCliente;
	private String nombre;
	private String apellido;
	
	public Cliente(String codigoCliente, String nombre, String apellido) {
		
		this.codigoCliente = codigoCliente;
		this.nombre = nombre;
		this.apellido = apellido;
	}
	
	public Cliente() {
		
	}

	/**
	 * @return the codigoCliente
	 */
	public String getCodigoCliente() {
		return codigoCliente;
	}

	/**
	 * @param codigoCliente the codigoCliente to set
	 */
	public void setCodigoCliente(String codigoCliente) {
		this.codigoCliente = codigoCliente;
	}

	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}

	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	/**
	 * @return the apellido
	 */
	public String getApellido() {
		return apellido;
	}

	/**
	 * @param apellido the apellido to set
	 */
	public void setApellido(String apellido) {
		this.apellido = apellido;
	}
	
	public void listaClientes(ArrayList<Cliente> clientes) {
		Connection miConexion=null;
		ResultSet rs=null;
		PreparedStatement miStatement=null;
		String codigoCliente,nombre,apellido,consulta;
		try {
			miConexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/EMPRESA", "root", "*prueba2024*");
			consulta="Select codigocliente,nombre,apellido from clientes";
			miStatement=miConexion.prepareStatement(consulta);
			rs=miStatement.executeQuery();
			
			if(rs.next()) {
				while(rs.next()) {
					codigoCliente=rs.getString("codigocliente");
					nombre=rs.getString("nombre");
					apellido=rs.getString("apellido");
					Cliente cliente=new Cliente(codigoCliente,nombre,apellido);
					clientes.add(cliente);
				}
			}else {
				System.err.println("Error de consulta ningun registro");
			}
			
			miConexion.close();
			miStatement.close();
			rs.close();
		} catch (SQLException e) {
			System.err.println("Error al listar clientes");
		}
		
	}

}

Ejercicio 16

Desarrolla un programa en Java que permita calcular el total de ventas realizadas en un mes específico por todos los clientes en la tabla "ventas" de la base de datos "empresa" en MySQL. El programa debe solicitar al usuario que ingrese el mes y el año para el cual desea calcular el total de ventas. Luego, debe conectar con la base de datos y calcular la suma total de todas las ventas realizadas en ese mes y año. Finalmente, el programa debe mostrar el resultado al usuario.

package conecta;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.LocalDate;
import java.util.Scanner;

public class Ejercicio16 {

	public static void main(String[] args) {
	Scanner entrada=new Scanner(System.in);
	String consulta="";
	
	int mes=0,anio=0;
	
	do {
		
		System.out.println("Introduce el mes");
		while(true) {
			try{
				mes=Integer.parseInt(entrada.next());
				break;
			}catch(NumberFormatException e) {
				System.out.println("Formato de numero incorrecto");
			}
		}
	}while(mes<1 || mes>12);
	 LocalDate fechaActual = LocalDate.now();
     int anioActual = fechaActual.getYear();
do {
		
		System.out.println("Introduce el año, la empresa tiene registros desde el 2024 hasta el año presente");
		while(true) {
			try{
				anio=Integer.parseInt(entrada.next());
				break;
			}catch(NumberFormatException e) {
				System.out.println("Formato de numero incorrecto");
			}
		}
	}while(anio<2024 || anio>anioActual);
	
	entrada.close();

	Connection miConexion=null;
	ResultSet rs=null;
	PreparedStatement miStatement=null;
	
	try {
		miConexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/EMPRESA", "root", "*prueba2024*");
		consulta="SELECT * FROM ventas where month(fecha_venta)=? and year(fecha_venta)=?";
		miStatement=miConexion.prepareStatement(consulta);
		miStatement.setInt(1,mes);
		miStatement.setInt(2, anio);
		rs=miStatement.executeQuery();
		
		if(rs.next()) {
			do {
				System.out.println("\nID_venta: " +rs.getString("id_venta"));
				System.out.println("Codigo Cliente: " +rs.getString("codigocliente"));
				System.out.println("Fecha: " +rs.getString("fecha_venta"));
				System.out.println("Total: " +rs.getString("total"));
			}while(rs.next());
		}else {
			System.out.println("No hay registros");
		}
		
		
		
	} catch (SQLException e) {
		System.err.println("Error al trabajar con la base de datos");
	}finally {
		try {
			if(rs!=null) {
				rs.close();
				
			}
			if(miConexion!=null) {
				miConexion.close();
			}
			if(miStatement!=null) {
				miStatement.close();
			}
			
			
		} catch (SQLException e) {
			System.err.println("Error al cerrar recursos");
		}
		
	}

	}

}

Ejercicio 17

Durante los próximos ejercicios vamos a trabajar Bases de datos en mySql, dando en el boton de descarga de este primer ejercicio bajais un archivo que contiene los script para crear la BBDD vivero y para cargar esta BBDD con campos ficticios a la base de datos la llame vivero, hay que agregar tambien el conector mysql al paquete java para que funcione

package conecta;

/*
Ejercicio 17

Crear una base de datos llamada tienda_practica.

Dentro de la base de datos se deben crear las siguientes tablas:

- clientes: con id, nombre, email, telefono, ciudad y fecha_registro
- empleados: con id, nombre, puesto, salario y fecha_contrato
- categorias: con id y nombre
- proveedores: con id, nombre, ciudad y telefono
- productos: con id, nombre, precio, stock, categoria_id y proveedor_id
- pedidos: con id, cliente_id, empleado_id, fecha y total
- detalle_pedido: con id, pedido_id, producto_id, cantidad y precio_unitario

Se deben definir correctamente las claves primarias y las claves foráneas para relacionar las tablas:

- productos con categorias y proveedores
- pedidos con clientes y empleados
- detalle_pedido con pedidos y productos
*/
package jdbc;

public class Ejercicio17 {

    public static void main(String[] args) {

        /*
        DROP DATABASE IF EXISTS tienda_practica;
        CREATE DATABASE tienda_practica;
        USE tienda_practica;

        CREATE TABLE clientes (
            id INT AUTO_INCREMENT PRIMARY KEY,
            nombre VARCHAR(100),
            email VARCHAR(120),
            telefono VARCHAR(20),
            ciudad VARCHAR(100),
            fecha_registro DATE
        );

        CREATE TABLE empleados (
            id INT AUTO_INCREMENT PRIMARY KEY,
            nombre VARCHAR(100),
            puesto VARCHAR(100),
            salario DECIMAL(10,2),
            fecha_contrato DATE
        );

        CREATE TABLE categorias (
            id INT AUTO_INCREMENT PRIMARY KEY,
            nombre VARCHAR(100)
        );

        CREATE TABLE proveedores (
            id INT AUTO_INCREMENT PRIMARY KEY,
            nombre VARCHAR(100),
            ciudad VARCHAR(100),
            telefono VARCHAR(20)
        );

        CREATE TABLE productos (
            id INT AUTO_INCREMENT PRIMARY KEY,
            nombre VARCHAR(120),
            precio DECIMAL(10,2),
            stock INT,
            categoria_id INT,
            proveedor_id INT,
            FOREIGN KEY (categoria_id) REFERENCES categorias(id),
            FOREIGN KEY (proveedor_id) REFERENCES proveedores(id)
        );

        CREATE TABLE pedidos (
            id INT AUTO_INCREMENT PRIMARY KEY,
            cliente_id INT,
            empleado_id INT,
            fecha DATE,
            total DECIMAL(10,2),
            FOREIGN KEY (cliente_id) REFERENCES clientes(id),
            FOREIGN KEY (empleado_id) REFERENCES empleados(id)
        );

        CREATE TABLE detalle_pedido (
            id INT AUTO_INCREMENT PRIMARY KEY,
            pedido_id INT,
            producto_id INT,
            cantidad INT,
            precio_unitario DECIMAL(10,2),
            FOREIGN KEY (pedido_id) REFERENCES pedidos(id),
            FOREIGN KEY (producto_id) REFERENCES productos(id)
        );
        */
	USE tienda_practica;

INSERT INTO categorias (nombre) VALUES
('Herramientas'),
('Jardineria'),
('Electricidad'),
('Fontaneria'),
('Construccion'),
('Automovil'),
('Pintura');

INSERT INTO proveedores (nombre, ciudad, telefono) VALUES
('Proveedor Norte','Oviedo','985111111'),
('Proveedor Centro','Madrid','911111111'),
('Proveedor Sur','Sevilla','954111111'),
('Proveedor Este','Valencia','961111111'),
('Proveedor Oeste','Coruña','981111111');

INSERT INTO empleados (nombre, puesto, salario, fecha_contrato) VALUES
('Carlos Perez','Vendedor',1800,'2021-03-10'),
('Ana Lopez','Vendedor',1750,'2022-01-15'),
('Luis Martin','Encargado',2200,'2020-06-01'),
('Marta Ruiz','Caja',1600,'2023-02-20'),
('Pedro Gomez','Almacen',1700,'2021-11-05');

DELIMITER $$

CREATE PROCEDURE llenar_datos()
BEGIN

DECLARE i INT DEFAULT 1;

-- CLIENTES
WHILE i <= 300 DO
INSERT INTO clientes(nombre,email,telefono,ciudad,fecha_registro)
VALUES(
CONCAT('Cliente ',i),
CONCAT('cliente',i,'@mail.com'),
CONCAT('600',LPAD(i,6,'0')),
ELT(FLOOR(1+RAND()*5),'Oviedo','Gijon','Aviles','Madrid','Leon'),
DATE_SUB(CURDATE(), INTERVAL FLOOR(RAND()*1000) DAY)
);
SET i = i + 1;
END WHILE;

SET i = 1;

-- PRODUCTOS
WHILE i <= 200 DO
INSERT INTO productos(nombre,precio,stock,categoria_id,proveedor_id)
VALUES(
CONCAT('Producto ',i),
ROUND(5 + RAND()*200,2),
FLOOR(10 + RAND()*200),
FLOOR(1 + RAND()*7),
FLOOR(1 + RAND()*5)
);
SET i = i + 1;
END WHILE;

SET i = 1;

-- PEDIDOS
WHILE i <= 500 DO
INSERT INTO pedidos(cliente_id,empleado_id,fecha,total)
VALUES(
FLOOR(1 + RAND()*300),
FLOOR(1 + RAND()*5),
DATE_SUB(CURDATE(), INTERVAL FLOOR(RAND()*365) DAY),
0
);
SET i = i + 1;
END WHILE;

SET i = 1;

-- DETALLE PEDIDO
WHILE i <= 2000 DO
INSERT INTO detalle_pedido(pedido_id,producto_id,cantidad,precio_unitario)
VALUES(
FLOOR(1 + RAND()*500),
FLOOR(1 + RAND()*200),
FLOOR(1 + RAND()*5),
ROUND(5 + RAND()*200,2)
);
SET i = i + 1;
END WHILE;

END$$

DELIMITER ;

CALL llenar_datos();
	/* 
	
	*/
    }
}

Ejercicio 18

Crea un programa en Java que se conecte a la base de datos "vivero" usando JDBC. Una vez establecida la conexión, realiza una consulta SQL para obtener todas las filas de la tabla "plantas". El programa debe mostrar por consola, para cada planta, los siguientes datos: - id - nombre - variedad - precio - stock Los resultados deben recorrerse utilizando un ResultSet y mostrarse fila por fila en consola. Ejemplo de salida esperada: 1 - Manzano - Golden - 15.50€ - stock: 40 2 - Manzano - Fuji - 16.00€ - stock: 25 3 - Peral - Conference - 18.20€ - stock: 30 Al finalizar, el programa debe cerrar la conexión con la base de datos.

Ejercicio 19

Crea un programa en Java que se conecte a la base de datos "vivero" usando JDBC. Realiza una consulta SQL que obtenga todas las plantas cuyo stock sea menor a 20. El programa debe mostrar por consola los siguientes datos: - nombre - variedad - stock Formato de salida esperado: Limonero - Eureka - stock: 15 Melocotonero - Rojo de Calanda - stock: 10 Recorre los resultados usando un ResultSet. Al finalizar, cierra el ResultSet, el Statement y la conexión.

package jdbc;

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

public class Ejercicio19 {

	public static void main(String[] args) {

		// Variables JDBC declaradas fuera del try para poder cerrarlas en el finally
		Connection conexion = null;      // Representa la conexión con la base de datos
		Statement miStatement = null;    // Permite ejecutar consultas SQL
		ResultSet miResultset = null;    // Contiene los datos devueltos por la consulta

		try {

			// 1️⃣ Establecer conexión con la base de datos
			conexion = DriverManager.getConnection(
					"jdbc:mysql://localhost:3306/vivero",
					"root",
					"*prueba2024*"
			);

			// 2️⃣ Crear un Statement para ejecutar la consulta SQL
			miStatement = conexion.createStatement();

			// 3️⃣ Ejecutar la consulta SELECT filtrando stock menor a 20
			miResultset = miStatement.executeQuery(
					"SELECT nombre, variedad, stock FROM plantas WHERE stock < 20"
			);

			// 4️⃣ Mostrar mensaje inicial por consola
			System.out.println("Listado de plantas con stock menor a 20");

			// 5️⃣ Recorrer el ResultSet fila por fila
			while (miResultset.next()) {

				// Obtener datos de cada columna de la fila actual
				String nombre = miResultset.getString("nombre");
				String variedad = miResultset.getString("variedad");
				int stock = miResultset.getInt("stock");

				// Mostrar información formateada
				System.out.println(nombre + " - " + variedad + " - stock: " + stock);
			}

		} catch (SQLException e) {

			// Captura errores relacionados con la base de datos
			e.printStackTrace();

		} finally {

			// 6️⃣ Cerrar ResultSet si está abierto
			if (miResultset != null) {
				try {
					miResultset.close();
				} catch (SQLException e) {
					System.err.println("Error al cerrar ResultSet: " + e.getMessage());
				}
			}

			// 7️⃣ Cerrar Statement si está abierto
			if (miStatement != null) {
				try {
					miStatement.close();
				} catch (SQLException e) {
					System.err.println("Error al cerrar Statement: " + e.getMessage());
				}
			}

			// 8️⃣ Cerrar conexión con la base de datos
			if (conexion != null) {
				try {
					conexion.close();
				} catch (SQLException e) {
					System.err.println("Error al cerrar conexión: " + e.getMessage());
				}
			}
		}
	}
}

Ejercicio 20

Crea un programa en Java que se conecte a la base de datos "vivero" usando JDBC. Realiza una consulta SQL que obtenga todas las plantas ordenadas por precio de mayor a menor. El programa debe mostrar por consola los siguientes datos: - nombre - variedad - precio Formato de salida esperado: Naranjo - Valencia - 22.50€ Melocotonero - Rojo de Calanda - 19.90€ Peral - Conference - 18.20€ Recorre los resultados usando un ResultSet. Al finalizar, cierra el ResultSet, el Statement y la conexión.

package jdbc;

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

public class Ejercicio20 {

	public static void main(String[] args) {
		
		// 🔹 Variables JDBC declaradas fuera del try para poder cerrarlas después
		Connection conexion = null;     // Representa la conexión con MySQL
		Statement miStatement = null;   // Permite ejecutar consultas SQL
		ResultSet miResultset = null;    // Contiene los datos devueltos por la consulta
		
		try {
			
			// 🔹 Establecemos conexión con la base de datos
			conexion = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);
			
			// 🔹 Creamos el Statement para ejecutar la consulta
			miStatement = conexion.createStatement();
			
			// 🔹 Ejecutamos el SELECT ordenando por precio de mayor a menor (DESC)
			miResultset = miStatement.executeQuery(
					"SELECT nombre, variedad, precio FROM plantas ORDER BY precio DESC"
			);
			
			// 🔹 Recorremos el ResultSet fila por fila
			while (miResultset.next()) {
				
				// 🔹 Obtenemos los valores de cada columna de la fila actual
				String nombre = miResultset.getString("nombre");
				String variedad = miResultset.getString("variedad");
				double precio = miResultset.getDouble("precio");
				
				// 🔹 Mostramos los datos formateados por consola
				System.out.println(
						nombre + " - " +
						variedad + " - " +
						String.format("%.2f€", precio)
				);
			}

		} catch (SQLException e) {
			
			// 🔹 Capturamos errores relacionados con la base de datos
			e.printStackTrace();
			
		} finally {
			
			// 🔹 Cerramos ResultSet si fue creado
			if (miResultset != null) {
				try {
					miResultset.close();
				} catch (SQLException e) {
					System.err.println("Error al cerrar ResultSet: " + e.getMessage());
				}
			}
			
			// 🔹 Cerramos Statement si fue creado
			if (miStatement != null) {
				try {
					miStatement.close();
				} catch (SQLException e) {
					System.err.println("Error al cerrar Statement: " + e.getMessage());
				}
			}
			
			// 🔹 Cerramos la conexión con la base de datos
			if (conexion != null) {
				try {
					conexion.close();
				} catch (SQLException e) {
					System.err.println("Error al cerrar conexión: " + e.getMessage());
				}
			}
		}
	}
}

Ejercicio 21

Crea un programa en Java que se conecte a la base de datos "vivero" usando JDBC. Realiza una consulta SQL que obtenga todas las plantas junto con el nombre de su categoría. Para ello debes usar un JOIN entre la tabla plantas y la tabla categorias. El programa debe mostrar por consola: - nombre de la planta - variedad - nombre de la categoría - precio Formato esperado: Manzano - Golden - Manzanos - 15.50€ Naranjo - Valencia - Cítricos - 22.50€ Recorre los resultados usando un ResultSet. Al finalizar, cierra el ResultSet, el Statement y la conexión.

package jdbc;

// Importamos las clases necesarias para trabajar con JDBC
import java.sql.Connection;   // Representa la conexión con la base de datos
import java.sql.DriverManager; // Permite establecer la conexión
import java.sql.ResultSet;     // Contiene los resultados de la consulta SQL
import java.sql.SQLException;  // Manejo de errores SQL
import java.sql.Statement;      // Permite ejecutar consultas SQL

public class Ejercicio21 {

	public static void main(String[] args) {

		// Declaramos las variables fuera del try para poder cerrarlas en el finally
		Connection conexion = null;     // Conexión con la base de datos
		Statement miStatement = null;   // Objeto para ejecutar la consulta SQL
		ResultSet miResultset = null;   // Resultado devuelto por la consulta

		try {

			// 🔹 Establecemos conexión con la base de datos "vivero"
			conexion = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);

			// 🔹 Creamos el Statement para ejecutar la consulta
			miStatement = conexion.createStatement();

			// 🔹 Ejecutamos la consulta con INNER JOIN para obtener plantas + categoría
			miResultset = miStatement.executeQuery(
					"SELECT p.nombre AS nombre, " +
					"p.variedad, " +
					"c.nombre AS categoria, " +
					"p.precio " +
					"FROM plantas p " +
					"INNER JOIN categorias c ON p.categoria_id = c.id"
			);

			// 🔹 Recorremos el ResultSet fila por fila
			while (miResultset.next()) {

				// Obtenemos los valores usando los alias definidos en la consulta
				String nombre = miResultset.getString("nombre");
				String variedad = miResultset.getString("variedad");
				String categoria = miResultset.getString("categoria");
				double precio = miResultset.getDouble("precio");

				// 🔹 Mostramos los datos formateados por consola
				System.out.println(
						nombre + " - " +
						variedad + " - " +
						categoria + " - " +
						String.format("%.2f€", precio)
				);
			}

		} catch (SQLException e) {

			// 🔹 Capturamos errores relacionados con la base de datos
			e.printStackTrace();

		} finally {

			// 🔹 Cerramos ResultSet si fue abierto
			if (miResultset != null) {
				try {
					miResultset.close();
				} catch (SQLException e) {
					System.err.println("Error al cerrar ResultSet: " + e.getMessage());
				}
			}

			// 🔹 Cerramos Statement si fue creado
			if (miStatement != null) {
				try {
					miStatement.close();
				} catch (SQLException e) {
					System.err.println("Error al cerrar Statement: " + e.getMessage());
				}
			}

			// 🔹 Cerramos la conexión con la base de datos
			if (conexion != null) {
				try {
					conexion.close();
				} catch (SQLException e) {
					System.err.println("Error al cerrar conexión: " + e.getMessage());
				}
			}
		}
	}
}

Ejercicio 22

Crea un programa en Java que se conecte a la base de datos vivero usando JDBC. Realiza una consulta SQL que obtenga todas las plantas cuyo precio sea mayor a 20 euros. El programa debe mostrar por consola los siguientes datos: nombre variedad precio Formato de salida esperado: Naranjo - Valencia - 22.50€ Limonero - Eureka - 24.00€ Condiciones: Debes usar un Statement. Utiliza una consulta con WHERE precio > 20. Recorre los resultados usando un ResultSet. Al finalizar, cierra: ResultSet Statement Connection.

package jdbc;

// Importamos las clases necesarias para trabajar con JDBC
import java.sql.Connection;      // Representa la conexión con la base de datos
import java.sql.DriverManager;   // Permite crear la conexión con la BD
import java.sql.ResultSet;       // Contiene los resultados de una consulta SQL
import java.sql.SQLException;    // Manejo de errores relacionados con SQL
import java.sql.Statement;       // Permite ejecutar consultas SQL simples

public class Ejercicio22 {

	public static void main(String[] args) {

		// Declaramos las variables fuera del try para poder cerrarlas en el finally
		Connection conexion = null;      // Conexión con la base de datos
		Statement miStatement = null;    // Objeto que ejecuta la consulta SQL
		ResultSet miResultset = null;    // Resultado de la consulta

		try {

			// Establecemos conexión con la base de datos "vivero"
			conexion = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);

			// Creamos el Statement que nos permitirá ejecutar la consulta SQL
			miStatement = conexion.createStatement();

			// Ejecutamos una consulta que obtiene las plantas con precio mayor a 20€
			miResultset = miStatement.executeQuery(
					"Select nombre,variedad,precio from plantas where precio>20"
			);

			// Recorremos los resultados fila por fila
			while(miResultset.next()) {

				// Obtenemos los valores de cada columna por su nombre
				String nombre = miResultset.getString("nombre");
				String variedad = miResultset.getString("variedad");
				double precio = miResultset.getDouble("precio");

				// Mostramos los datos por consola con el precio formateado
				System.out.println(
						nombre + " - " +
						variedad + " - " +
						String.format("%.2f€", precio)
				);
			}

		} catch(SQLException e) {

			// Si ocurre un error con la base de datos lo mostramos en consola
			e.printStackTrace();

		} finally {

			// Cerramos el ResultSet si fue abierto
			if (miResultset != null) {
                try {
                    miResultset.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar ResultSet: " + e.getMessage());
                }
            }

			// Cerramos el Statement si fue creado
            if (miStatement != null) {
                try {
                    miStatement.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar Statement: " + e.getMessage());
                }
            }

            // Cerramos la conexión con la base de datos
            if (conexion != null) {
                try {
                    conexion.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar conexión: " + e.getMessage());
                }
            }
		}
	}
}

Ejercicio 23

Crea un programa en Java que se conecte a la base de datos vivero usando JDBC. Debes realizar una consulta SQL que obtenga todas las plantas que pertenecen a la categoría "Cítricos". Para ello tendrás que usar un JOIN entre las tablas: plantas categorias La consulta debe mostrar: nombre de la planta variedad nombre de la categoría precio Los resultados deben aparecer ordenados por precio de mayor a menor. Formato de salida esperado: Naranjo - Valencia - Cítricos - 22.50€ Limonero - Eureka - Cítricos - 21.00€ Mandarino - Clementina - Cítricos - 19.80€ Condiciones: Usa Statement. Usa INNER JOIN. Usa WHERE para filtrar la categoría "Cítricos". Usa ORDER BY precio DESC. Recorre los resultados con ResultSet. Cierra al final: ResultSet Statement Connection.

package jdbc;

// Importamos las clases necesarias para trabajar con JDBC
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Ejercicio23 {

	public static void main(String[] args) {

		// Declaramos las variables fuera del try para poder cerrarlas en finally
		Connection conexion = null;      // Conexión con la base de datos
		Statement miStatement = null;    // Objeto que ejecutará la consulta SQL
		ResultSet miResultset = null;    // Resultado de la consulta

		try {

			// Establecemos la conexión con la base de datos "vivero"
			conexion = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);

			// Creamos el Statement para poder ejecutar la consulta SQL
			miStatement = conexion.createStatement();

			// Ejecutamos la consulta:
			// - INNER JOIN para unir plantas con categorías
			// - WHERE para filtrar la categoría "Cítricos"
			// - ORDER BY para ordenar por precio de mayor a menor
			miResultset = miStatement.executeQuery(
					"select p.nombre as nombre,p.variedad as variedad,c.nombre as categoria, p.precio as precio"
					+ " from plantas as p"
					+ " inner join  categorias c On p.categoria_id=c.id"
					+ " where c.nombre='Cítricos'"
					+ " order by p.precio DESC"
			);

			// Recorremos los resultados fila por fila
			while (miResultset.next()) {

				// Obtenemos los datos de cada columna usando su nombre
				System.out.println(
						miResultset.getString("nombre") + " - " +
						miResultset.getString("variedad") + " - " +
						miResultset.getString("categoria") + " - " +
						String.format("%.2f€", miResultset.getDouble("precio"))
				);
			}

		} catch (SQLException e) {

			// Si ocurre un error con la base de datos se muestra en consola
			e.printStackTrace();

		} finally {

			// Cerramos el ResultSet si fue creado
			if (miResultset != null) {
                try {
                    miResultset.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar ResultSet: " + e.getMessage());
                }
            }

			// Cerramos el Statement
            if (miStatement != null) {
                try {
                    miStatement.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar Statement: " + e.getMessage());
                }
            }

            // Cerramos la conexión con la base de datos
            if (conexion != null) {
                try {
                    conexion.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar conexión: " + e.getMessage());
                }
            }
		}
	}
}

Ejercicio 24

Crea un programa en Java que se conecte a la base de datos "vivero" usando JDBC. El programa debe ejecutar dos consultas SQL diferentes: 1️⃣ Contar cuántos tipos de plantas existen en la tabla "plantas". Para ello debes usar la función SQL: COUNT(*) El programa debe mostrar algo como: Número total de tipos de plantas: 12 2️⃣ Calcular el número total de unidades disponibles en stock. Para ello debes usar la función SQL: SUM(stock) El programa debe mostrar algo como: Número total de plantas en stock: 145 Condiciones: - Usa Statement para ejecutar las consultas. - Ejecuta las consultas con executeQuery(). - Usa ResultSet para obtener los resultados. - Recuerda que las funciones agregadas devuelven una sola fila. - Cierra el ResultSet antes de ejecutar una nueva consulta. - Cierra al final: ResultSet Statement Connection


package jdbc;

// Importamos las clases necesarias para trabajar con JDBC
import java.sql.Connection;      // Representa la conexión con la base de datos
import java.sql.DriverManager;   // Permite establecer la conexión con la BD
import java.sql.ResultSet;       // Contiene los resultados de una consulta SQL
import java.sql.SQLException;    // Manejo de errores SQL
import java.sql.Statement;       // Permite ejecutar consultas SQL simples

public class Ejercicio24 {

	public static void main(String[] args) {

		// Declaramos las variables fuera del try para poder cerrarlas en finally
		Connection conexion = null;      // Conexión con la base de datos
		Statement miStatement = null;    // Objeto que ejecutará las consultas SQL
		ResultSet miResultset = null;    // Resultado devuelto por las consultas

		try {

			// Establecemos la conexión con la base de datos "vivero"
			conexion = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);

			// Creamos el Statement que permitirá ejecutar las consultas SQL
			miStatement = conexion.createStatement();

			// Ejecutamos la primera consulta: contar cuántos tipos de plantas existen
			miResultset = miStatement.executeQuery(
					"Select count(*) as totalPlantas from plantas"
			);

			// Como COUNT devuelve solo una fila usamos if en lugar de while
			if (miResultset.next()) {
				System.out.println(
						"Hay un total de -> " +
						miResultset.getInt("totalPlantas") +
						" plantas diferentes"
				);
			}

			// Cerramos el ResultSet antes de ejecutar otra consulta
			miResultset.close();

			// Ejecutamos la segunda consulta: sumar todas las unidades en stock
			miResultset = miStatement.executeQuery(
					"Select sum(stock) as totalStock from plantas"
			);

			// SUM también devuelve una única fila
			if (miResultset.next()) {
				System.out.println(
						"Hay un total de -> " +
						miResultset.getInt("totalStock") +
						" plantas en stock"
				);
			}

		} catch (SQLException e) {

			// Si ocurre un error relacionado con SQL se muestra en consola
			e.printStackTrace();

		} finally {

			// Cerramos el ResultSet si fue creado
			if (miResultset != null) {
                try {
                    miResultset.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar ResultSet: " + e.getMessage());
                }
            }

			// Cerramos el Statement
            if (miStatement != null) {
                try {
                    miStatement.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar Statement: " + e.getMessage());
                }
            }

            // Cerramos la conexión con la base de datos
            if (conexion != null) {
                try {
                    conexion.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar conexión: " + e.getMessage());
                }
            }
		}
	}
}

Ejercicio 25

Ejercicio JDBC – Agrupar resultados (GROUP BY) Crea un programa en Java que se conecte a la base de datos "vivero" usando JDBC. Debes realizar una consulta SQL que muestre cuántas plantas hay en cada categoría. Para ello tendrás que usar un JOIN entre las tablas: plantas categorias La consulta debe mostrar: nombre de la categoría número total de plantas que hay en esa categoría Los resultados deben aparecer ordenados por el número de plantas de mayor a menor. Formato de salida esperado: Cítricos -> 5 plantas Frutales -> 4 plantas Coníferas -> 2 plantas Condiciones: Usa Statement. Usa INNER JOIN entre plantas y categorias. Usa COUNT(*) para contar las plantas. Usa GROUP BY para agrupar por categoría. Usa ORDER BY para ordenar de mayor a menor. Recorre los resultados con ResultSet. Cierra al final: ResultSet Statement Connection.


package jdbc;

// Importaciones necesarias para trabajar con JDBC
import java.sql.Connection;      // Representa la conexión con la base de datos
import java.sql.DriverManager;   // Permite crear la conexión
import java.sql.ResultSet;       // Contiene los resultados de una consulta SQL
import java.sql.SQLException;    // Manejo de errores relacionados con SQL
import java.sql.Statement;       // Permite ejecutar consultas SQL simples

public class Ejercicio25 {

	public static void main(String[] args) {
		
		// Declaramos las variables fuera del try para poder cerrarlas en finally
		Connection conexion = null;     // Objeto que representa la conexión con la base de datos
		Statement miStatement = null;   // Objeto que ejecutará la consulta SQL
		ResultSet miResultset = null;   // Objeto que almacenará el resultado de la consulta
		
		try {
			
			// Establecemos la conexión con la base de datos "vivero"
			conexion = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);
			
			// Creamos el Statement que nos permitirá ejecutar la consulta SQL
			miStatement = conexion.createStatement();
			
			// Ejecutamos la consulta SQL:
			// - Se hace un JOIN entre plantas y categorias
			// - Se cuentan las plantas de cada categoría con COUNT(*)
			// - Se agrupan los resultados con GROUP BY
			// - Se ordenan de mayor a menor número de plantas
			miResultset = miStatement.executeQuery(
					"SELECT c.nombre AS categoria, COUNT(*) as plantas"
					+ " FROM plantas p"
					+ " INNER JOIN categorias c ON p.categoria_id = c.id"
					+ " GROUP BY c.nombre"
					+ " ORDER BY plantas DESC"
			);
			
			// Recorremos el ResultSet.
			// GROUP BY devuelve varias filas (una por cada categoría),
			// por eso usamos while.
			while (miResultset.next()) {
				
				// Mostramos el nombre de la categoría y el número de plantas
				System.out.println(
						miResultset.getString("categoria") + " -> " 
						+ miResultset.getInt("plantas") + " plantas"
				);
			}

		} catch (SQLException e) {
			
			// Si ocurre algún error relacionado con la base de datos se imprime aquí
			e.printStackTrace();
			
		} finally {
			
			// Cerramos el ResultSet si fue creado
			if (miResultset != null) {
                try {
                    miResultset.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar ResultSet: " + e.getMessage());
                }
            }
			
			// Cerramos el Statement
            if (miStatement != null) {
                try {
                    miStatement.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar Statement: " + e.getMessage());
                }
            }
            
            // Cerramos la conexión con la base de datos
            if (conexion != null) {
                try {
                    conexion.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar conexión: " + e.getMessage());
                }
            }
		}
	}
}

Ejercicio 26

Crea un programa en Java que se conecte a la base de datos vivero usando JDBC. El programa debe: Insertar un nuevo registro en la tabla plantas con los siguientes datos: nombre: "Ciruelo" variedad: "Autumn Pride" precio: 17.50 stock: 15 categoria_id: 2 (asegúrate de que esa categoría existe en tu tabla categorias) Mostrar por consola cuántas filas fueron afectadas por el INSERT. Al finalizar, cerrar Statement y Connection.

Ejercicio 27

Crea un programa en Java que se conecte a la base de datos vivero usando JDBC. El programa debe: Insertar tres nuevas plantas en la tabla plantas usando PreparedStatement y batch. Los datos de las plantas son: nombre variedad precio stock categoria_id Manzano Fuji 18.00 10 1 Naranjo Navel 20.50 12 2 Limonero Eureka 15.75 8 2 Ejecutar el batch y mostrar por consola cuántas filas se insertaron en total. Al finalizar, cerrar PreparedStatement y Connection. Condiciones: Usa PreparedStatement con parámetros (?). Usa addBatch() y executeBatch(). Mostrar el total de filas afectadas. Formato de salida esperado: Se han insertado 3 plantas correctamente.

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;

public class Ejercicio27 {

	public static void main(String[] args) {
		
		// Variables para la conexión y el PreparedStatement
		Connection conexion = null;
		PreparedStatement ps = null;
		
		try {
			
			// 1️⃣ Crear la conexión con la base de datos MySQL
			conexion = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);
			
			// 2️⃣ Crear la consulta SQL con parámetros (?)
			// Se usarán después con setString, setInt, etc.
			String sql = "INSERT INTO plantas (nombre,variedad,precio,stock,categoria_id)"
					+ " VALUES (?,?,?,?,?)";
						
			// 3️⃣ Preparar la sentencia SQL
			ps = conexion.prepareStatement(sql);
			
			// 4️⃣ Crear una lista de objetos Planta que queremos insertar en la base de datos
			List<Planta> listaPlantas = Arrays.asList(
				    new Planta("Manzano","Fuji",18.00,10,1),
				    new Planta("Naranjo","Navel",20.50,12,2),
				    new Planta("Limonero","Eureka",15.75,8,2)
				);
			
			// 5️⃣ Recorrer la lista de plantas
			// Por cada planta se asignan los valores a la sentencia SQL
			for (Planta planta : listaPlantas) {
				
				// Asignar valores a los parámetros de la consulta
				ps.setString(1, planta.getNombre());
				ps.setString(2, planta.getVariedad());
				ps.setDouble(3, planta.getPrecio());
				ps.setInt(4, planta.getStock());
				ps.setInt(5, planta.getCategoria());
				
				// Añadir la sentencia al batch (cola de ejecuciones)
				ps.addBatch();
			}
			
			// 6️⃣ Ejecutar todas las sentencias acumuladas en el batch
			int[] resultados = ps.executeBatch();
			
			// 7️⃣ Calcular el total de filas afectadas
			int total = 0;
			for (int r : resultados) {
			    total += r;
			}
			
			// 8️⃣ Mostrar el resultado por consola
			if (total == 1) {
				System.out.println("Se han insertado " + total + " planta correctamente.");
			} else {
				System.out.println("Se han insertado " + total + " plantas correctamente.");
			}
				
		} catch (SQLException e) {
			
			// 9️⃣ Si ocurre un error SQL se muestra el stacktrace
			e.printStackTrace();
			
		} finally {
			
			// 🔟 Cerrar el PreparedStatement si está abierto
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar Statement: " + e.getMessage());
                }
            }
            
            // 1️⃣1️⃣ Cerrar la conexión con la base de datos
            if (conexion != null) {
                try {
                    conexion.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar conexión: " + e.getMessage());
                }
            }
		}
	}
}

class Planta {
	
	// Atributos que representan las columnas de la tabla plantas
	private String nombre;
	private String variedad;
	private double precio;
	private int stock;
	private int categoria;
	
	// Constructor para crear objetos Planta
	public Planta(String nombre, String variedad, double precio, int stock, int categoria) {
		this.nombre = nombre;
		this.variedad = variedad;
		this.precio = precio;
		this.stock = stock;
		this.categoria = categoria;
	}

	// Getters y setters para acceder y modificar los atributos
	
	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public String getVariedad() {
		return variedad;
	}

	public void setVariedad(String variedad) {
		this.variedad = variedad;
	}

	public double getPrecio() {
		return precio;
	}

	public void setPrecio(double precio) {
		this.precio = precio;
	}

	public int getStock() {
		return stock;
	}

	public void setStock(int stock) {
		this.stock = stock;
	}

	public int getCategoria() {
		return categoria;
	}

	public void setCategoria(int categoria) {
		this.categoria = categoria;
	}

	// Método toString para mostrar el objeto de forma legible
	@Override
	public String toString() {
		return "Planta [nombre=" + nombre + ", variedad=" + variedad + ", precio=" + precio + ", stock=" + stock
				+ ", categoria=" + categoria + "]";
	}
}

Ejercicio 28

Crea un programa en Java que se conecte a la base de datos vivero usando JDBC. El programa debe insertar una nueva planta en la tabla plantas utilizando PreparedStatement. Datos a insertar nombre variedad precio stock categoria_id Peral Conferencia 19.95 6 1 Requisitos Conectarse a la base de datos vivero. Crear una sentencia INSERT con parámetros ?. Usar PreparedStatement. Ejecutar la sentencia con executeUpdate(). Guardar el número de filas afectadas en una variable. Mostrar un mensaje por consola según el resultado. Salida esperada Si se insertó correctamente: Planta insertada correctamente. Si no se insertó ninguna fila: No se ha insertado ninguna planta.

package jdbc;

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

public class Ejercicio28 {

	public static void main(String[] args) {
		
		// Variables para la conexión a la base de datos y la sentencia preparada
		Connection conexion = null;
		PreparedStatement ps = null;
		
		try {
			
			// 1️⃣ Crear la conexión con la base de datos MySQL
			conexion = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);
			
			// 2️⃣ Crear el objeto que representa la planta que queremos insertar
			Frutal frutal = new Frutal("Peral","Conferencia",19.95,6,1);
			
			// 3️⃣ Crear la consulta SQL con parámetros (?)
			// Los valores reales se asignarán después con setString, setDouble, etc.
			String sql = "INSERT INTO plantas(nombre,variedad,precio,stock,categoria_id)"
					+ " VALUES(?,?,?,?,?)";
			
			// 4️⃣ Preparar la sentencia SQL
			ps = conexion.prepareStatement(sql);
			
			// 5️⃣ Asignar los valores del objeto frutal a los parámetros de la consulta
			ps.setString(1, frutal.getNombre());
			ps.setString(2, frutal.getVariedad());
			ps.setDouble(3, frutal.getPrecio());
			ps.setInt(4, frutal.getStock());
			ps.setInt(5, frutal.getCategoria());
			
			// 6️⃣ Ejecutar la sentencia INSERT
			// executeUpdate devuelve el número de filas afectadas
			int filas = ps.executeUpdate();
			
			// 7️⃣ Comprobar si se insertó alguna fila
			if(filas != 0) {
				System.out.println("Planta insertada correctamente.");
			}else {
				System.out.println("No se ha insertado ninguna planta.");
			}
			
		}catch(SQLException e) {
			
			// 8️⃣ Si ocurre un error SQL se muestra el stacktrace
			e.printStackTrace();
			
		}finally {
		
			// 9️⃣ Cerrar el PreparedStatement si está abierto
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar Statement: " + e.getMessage());
                }
            }
            
            // 🔟 Cerrar la conexión con la base de datos
            if (conexion != null) {
                try {
                    conexion.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar conexión: " + e.getMessage());
                }
            }
		}
	}
}

class Frutal {
	
	// Atributos que representan las columnas de la tabla plantas
	private String nombre;
	private String variedad;
	private double precio;
	private int stock;
	private int categoria;
	
	// Constructor para crear objetos Frutal
	public Frutal(String nombre, String variedad, double precio, int stock, int categoria) {
		this.nombre = nombre;
		this.variedad = variedad;
		this.precio = precio;
		this.stock = stock;
		this.categoria = categoria;
	}

	// Getters y setters para acceder y modificar los atributos
	
	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public String getVariedad() {
		return variedad;
	}

	public void setVariedad(String variedad) {
		this.variedad = variedad;
	}

	public double getPrecio() {
		return precio;
	}

	public void setPrecio(double precio) {
		this.precio = precio;
	}

	public int getStock() {
		return stock;
	}

	public void setStock(int stock) {
		this.stock = stock;
	}

	public int getCategoria() {
		return categoria;
	}

	public void setCategoria(int categoria) {
		this.categoria = categoria;
	}

	// Método toString para mostrar el objeto de forma legible
	@Override
	public String toString() {
		return "Planta [nombre=" + nombre + ", variedad=" + variedad + ", precio=" + precio + ", stock=" + stock
				+ ", categoria=" + categoria + "]";
	}
}

Ejercicio 29

Crea un programa en Java que se conecte a la base de datos vivero usando JDBC. El programa debe insertar una nueva planta en la tabla plantas, pero con estas condiciones: Datos base para insertar: nombre variedad precio stock categoria_id Ciruelo Stanley 12.75 8 3 Requisitos: Conectarse a la base de datos vivero. Antes de insertar, comprobar si ya existe una planta con el mismo nombre y variedad. Si existe, sumar al stock existente en lugar de insertar un nuevo registro. Si no existe, insertar como nuevo registro. Usar PreparedStatement para todas las consultas. Mostrar un mensaje indicando si se ha insertado un nuevo registro o si se ha actualizado el stock existente.

package jdbc;

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

public class Ejercicio29 {

    public static void main(String[] args) {

        Connection conexion = null;

        try {

            // 1️⃣ Conectar con la base de datos
            conexion = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/vivero",
                    "root",
                    "*prueba2024*"
            );

            // 2️⃣ Crear el objeto con los datos de la planta
            Fruta fruta = new Fruta("Ciruelo", "Stanley", 12.75, 8, 3);

            // 3️⃣ Consulta para comprobar si ya existe la planta
            String sql = "SELECT id, stock FROM plantas WHERE nombre=? AND variedad=?";

            try (PreparedStatement psSelect = conexion.prepareStatement(sql)) {

                // Asignamos los parámetros del SELECT
                psSelect.setString(1, fruta.getNombre());
                psSelect.setString(2, fruta.getVariedad());

                // Ejecutamos la consulta
                try (ResultSet rs = psSelect.executeQuery()) {

                    // 4️⃣ Si la planta existe
                    if (rs.next()) {

                        String sqlUpdate = "UPDATE plantas SET stock = stock + ? WHERE id=?";

                        try (PreparedStatement psUpdate = conexion.prepareStatement(sqlUpdate)) {

                            // Sumamos el stock nuevo al existente
                            psUpdate.setInt(1, fruta.getStock());
                            psUpdate.setInt(2, rs.getInt("id"));

                            psUpdate.executeUpdate();

                            // Mostramos el nuevo stock calculado
                            System.out.println(
                                    "Producto actualizado correctamente, nuevo stock "
                                            + (fruta.getStock() + rs.getInt("stock")) + " unidades"
                            );
                        }

                    } else {

                        // 5️⃣ Si no existe la planta, la insertamos
                        String sqlInsert = "INSERT INTO plantas(nombre,variedad,precio,stock,categoria_id) VALUES(?,?,?,?,?)";

                        try (PreparedStatement psInsert = conexion.prepareStatement(sqlInsert)) {

                            psInsert.setString(1, fruta.getNombre());
                            psInsert.setString(2, fruta.getVariedad());
                            psInsert.setDouble(3, fruta.getPrecio());
                            psInsert.setInt(4, fruta.getStock());
                            psInsert.setInt(5, fruta.getCategoria());

                            psInsert.executeUpdate();

                            System.out.println("Producto insertado correctamente");
                        }
                    }
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {

            // 6️⃣ Cerramos la conexión
            if (conexion != null) {
                try {
                    conexion.close();
                } catch (SQLException e) {
                    System.err.println("Error al cerrar conexión: " + e.getMessage());
                }
            }
        }
    }
}


/* Clase que representa una planta de la tabla plantas */
class Fruta {

    private String nombre;
    private String variedad;
    private double precio;
    private int stock;
    private int categoria;

    // Constructor
    public Fruta(String nombre, String variedad, double precio, int stock, int categoria) {
        this.nombre = nombre;
        this.variedad = variedad;
        this.precio = precio;
        this.stock = stock;
        this.categoria = categoria;
    }

    // Getters
    public String getNombre() {
        return nombre;
    }

    public String getVariedad() {
        return variedad;
    }

    public double getPrecio() {
        return precio;
    }

    public int getStock() {
        return stock;
    }

    public int getCategoria() {
        return categoria;
    }

    // Setters
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public void setVariedad(String variedad) {
        this.variedad = variedad;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }

    public void setStock(int stock) {
        this.stock = stock;
    }

    public void setCategoria(int categoria) {
        this.categoria = categoria;
    }

    // toString para mostrar el objeto
    @Override
    public String toString() {
        return "Planta [nombre=" + nombre + ", variedad=" + variedad +
                ", precio=" + precio + ", stock=" + stock +
                ", categoria=" + categoria + "]";
    }
}

Ejercicio 30

Crea un programa en Java que: 1️⃣ Se conecte a la base de datos vivero. 2️⃣ Pida por consola los datos de una nueva planta: nombre variedad precio stock categoría (nombre) 3️⃣ Antes de insertar: Comprobar si la categoría existe en la tabla categorias. Si no existe, insertarla automáticamente y usar su id. Si existe, obtener su id. 4️⃣ Insertar la planta en la tabla plantas usando PreparedStatement. 5️⃣ Mostrar por consola: Planta "Golden Apple" insertada correctamente en la categoría "Frutales". 6️⃣ Usar transacciones: Si falla cualquier paso, hacer rollback. Si todo va bien, commit.


package jdbc;

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.Scanner;

public class Ejercicio30 {

    public static void main(String[] args) {
        Connection conexion = null;
        try {
            // 1️⃣ Conexión a la base de datos
            conexion = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/vivero",
                    "root",
                    "*prueba2024*"
            );

            // 6️⃣ Desactivar autocommit para poder controlar la transacción
            conexion.setAutoCommit(false);

            // 2️⃣ Llamamos a la función que pide datos y añade el árbol
            Arbol arbol = addArbol(conexion);

            // 6️⃣ Si todo ha ido bien, hacemos commit
            if (arbol != null) {
                conexion.commit();
            }

        } catch (SQLException e) {
            System.err.println("Error en la base de datos: " + e.getMessage());
            // 6️⃣ Si algo falla, hacemos rollback
            if (conexion != null) {
                try {
                    conexion.rollback();
                    System.out.println("Transacción revertida.");
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
        } finally {
            // Cerramos la conexión
            try {
                if (conexion != null) {
                    conexion.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    // 2️⃣ Función que pide datos por consola y añade un árbol
    static Arbol addArbol(Connection conexion) {

        try (Scanner in = new Scanner(System.in)) {
            String nombre, variedad, categoria;
            double precio;
            int stock;

            System.out.println("Introduce el nombre de la planta:");
            nombre = devuelvoFormato(in.nextLine());

            System.out.println("Introduce la variedad de la planta:");
            variedad = devuelvoFormato(in.nextLine());

            System.out.println("Introduce el P.V.P de la planta:");
            precio = Double.parseDouble(in.nextLine());

            System.out.println("Introduce el stock de la planta:");
            stock = Integer.parseInt(in.nextLine());

            System.out.println("Introduce la categoria de la planta:");
            categoria = devuelvoFormato(in.nextLine());

            // 3️⃣ Añadimos la categoría si no existe y obtenemos su id
            int id = addCategoria(categoria, in, conexion);

            // Creamos el objeto Arbol
            Arbol arbol = new Arbol(nombre, variedad, precio, stock, id);

            // 4️⃣ Insertamos el árbol en la tabla plantas
            insertarArbol(arbol, conexion);

            return arbol;

        } catch (NumberFormatException e) {
            System.err.println("Formato de número incorrecto.");
        }

        return null;
    }

    // Función que da formato a cadenas (Primera letra en mayúscula)
    static String devuelvoFormato(String cadena) {
        if (cadena.isEmpty()) return cadena;
        String letra = cadena.substring(0, 1).toUpperCase();
        String resto = cadena.substring(1);
        return letra + resto;
    }

    // 4️⃣ Insertar un árbol en la tabla plantas
    static void insertarArbol(Arbol arbol, Connection conexion) {

        String sqlInsert = "INSERT INTO plantas(nombre,variedad,precio,stock,categoria_id) VALUES(?,?,?,?,?)";

        try (PreparedStatement psInsert = conexion.prepareStatement(sqlInsert)) {

            psInsert.setString(1, arbol.getNombre());
            psInsert.setString(2, arbol.getVariedad());
            psInsert.setDouble(3, arbol.getPrecio());
            psInsert.setInt(4, arbol.getStock());
            psInsert.setInt(5, arbol.getCategoria());

            psInsert.executeUpdate();

            // Mostramos mensaje confirmando inserción
            String nombreCategoria = selectCategoria(arbol.getCategoria(), conexion);
            System.out.println("Planta \"" + arbol.getNombre() + "\" insertada correctamente en la categoría \"" + nombreCategoria + "\"");

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // Obtener el nombre de la categoría por id
    static String selectCategoria(int id, Connection conexion) {

        String sql = "SELECT nombre FROM categorias WHERE id=?";
        try (PreparedStatement psSelect = conexion.prepareStatement(sql)) {

            psSelect.setInt(1, id);
            try (ResultSet rs = psSelect.executeQuery()) {
                if (rs.next()) {
                    return rs.getString("nombre");
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }

        return null;
    }

    // 3️⃣ Añadir categoría si no existe y devolver id
    static int addCategoria(String categoria, Scanner in, Connection conexion) {

        String sql = "SELECT id FROM categorias WHERE nombre=?";
        int id = 0;

        try (PreparedStatement psSelect = conexion.prepareStatement(sql)) {

            psSelect.setString(1, categoria);
            try (ResultSet rs = psSelect.executeQuery()) {
                if (rs.next()) {
                    // La categoría ya existe
                    id = rs.getInt("id");
                } else {
                    // Nueva categoría
                    System.out.println("Se trata de una nueva categoría, introduce la descripción:");
                    String descripcion = devuelvoFormato(in.nextLine());

                    sql = "INSERT INTO categorias(nombre,descripcion) VALUES(?,?)";

                    try (PreparedStatement psInsert = conexion.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
                        psInsert.setString(1, categoria);
                        psInsert.setString(2, descripcion);
                        psInsert.executeUpdate();

                        // Obtenemos el id generado
                        try (ResultSet rsKeys = psInsert.getGeneratedKeys()) {
                            if (rsKeys.next()) {
                                id = rsKeys.getInt(1);
                            }
                        }
                    }
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }

        return id;
    }
}

// Clase Arbol
class Arbol {

    private String nombre;
    private String variedad;
    private double precio;
    private int stock;
    private int categoria;

    public Arbol(String nombre, String variedad, double precio, int stock, int categoria) {
        this.nombre = nombre;
        this.variedad = variedad;
        this.precio = precio;
        this.stock = stock;
        this.categoria = categoria;
    }

    public String getNombre() { return nombre; }
    public String getVariedad() { return variedad; }
    public double getPrecio() { return precio; }
    public int getStock() { return stock; }
    public int getCategoria() { return categoria; }

    public void setNombre(String nombre) { this.nombre = nombre; }
    public void setVariedad(String variedad) { this.variedad = variedad; }
    public void setPrecio(double precio) { this.precio = precio; }
    public void setStock(int stock) { this.stock = stock; }
    public void setCategoria(int categoria) { this.categoria = categoria; }

    @Override
    public String toString() {
        return "Planta [nombre=" + nombre + ", variedad=" + variedad +
                ", precio=" + precio + ", stock=" + stock +
                ", categoria=" + categoria + "]";
    }
}

Ejercicio 31

Crea un programa en Java usando JDBC que se conecte a la base de datos vivero. El programa debe: 1️⃣ Conectarse a la base de datos vivero en MySQL. 2️⃣ No debe pedir datos al usuario. 3️⃣ Ejecutar una consulta SELECT que obtenga las 5 plantas más baratas del vivero. 4️⃣ La consulta debe: Usar JOIN entre plantas y categorias Ordenar los resultados por precio de menor a mayor usando ORDER BY Limitar los resultados a 5 registros usando LIMIT 5️⃣ Mostrar los resultados con el siguiente formato: Nombre: Manzano Variedad: Golden Precio: 12.50 Stock: 8 Categoría: Frutales ---------------------- 6️⃣ Si no existen plantas en la base de datos, mostrar: No hay plantas registradas en el vivero. 7️⃣ Recorrer los resultados usando ResultSet.

package jdbc;

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

public class Ejercicio31 {

	public static void main(String[] args) {
		
		// Variables para manejar la conexión y los resultados de la consulta
		Connection cn = null;
		Statement st = null;
		ResultSet rs = null;
		
		try {
			
			// Establecer conexión con la base de datos MySQL
			cn = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);
			
			// Consulta SQL:
			// - Selecciona datos de la tabla plantas
			// - Hace JOIN con categorias para obtener el nombre de la categoría
			// - Ordena por precio ascendente (de menor a mayor)
			// - Limita el resultado a las 5 plantas más baratas
			String sql="SELECT "
					+ " p.nombre AS nombre,"
				+ " p.variedad AS variedad,"
				+ " p.precio AS precio,"
				+ " p.stock AS stock,"
				+ " c.nombre AS categoria"
				+ " FROM plantas AS p"
				+ " INNER JOIN categorias AS c"
				+ " ON p.categoria_id=c.id"
				+ " ORDER BY p.precio ASC"
				+ " LIMIT 5";
			
			// Crear el Statement para ejecutar la consulta
			st = cn.createStatement();
			
			// Ejecutar la consulta SELECT
			rs = st.executeQuery(sql);
			
			// Comprobar si la consulta no devuelve resultados
			if(!rs.next()) {
				System.out.println("No hay plantas registradas en el vivero.");
			}else {
				
				// Si hay resultados, recorrerlos
				do {
					System.out.println("Nombre: " + rs.getString("nombre")
					+ "\nVariedad: " + rs.getString("variedad")
					+ "\nP.V.P: " + String.format("%.2f€", rs.getDouble("precio"))
					+ "\nStock: " + rs.getInt("stock") + " unidades" 
					+ "\nCategoria: " + rs.getString("categoria")
					+ "\n----------------------\n");
					
				// Continuar recorriendo mientras existan más registros
				}while(rs.next());
			}
			
		} catch (SQLException e) {
			
			// Captura errores de conexión o ejecución de SQL
			System.err.println("Error conectando con la BBDD " + e.getMessage());
			
		} finally {
			
			// Cerrar los recursos para liberar memoria y conexiones
			try {
				if(rs!=null) rs.close();
				if(st!=null) st.close();
				if(cn!=null) cn.close();
			} catch (SQLException e) {
				
				// Error al cerrar recursos
				System.err.println("Error trabajando con la BBDD");
			}
		}

	}

}

Ejercicio 32

Crea un programa en Java usando JDBC que se conecte a la base de datos vivero. El programa debe: 1️⃣ Conectarse a la base de datos vivero en MySQL. 2️⃣ Pedir por consola el nombre de una categoría (por ejemplo: Frutales, Cítricos, etc.). 3️⃣ Ejecutar una consulta SELECT que obtenga todas las plantas pertenecientes a esa categoría. 4️⃣ La consulta debe usar JOIN entre las tablas plantas y categorias. 5️⃣ Mostrar por consola los resultados con el siguiente formato: Nombre: Manzano Variedad: Golden Precio: 15.50 Stock: 10 Categoría: Frutales ---------------------- 6️⃣ Si no existen plantas en esa categoría, mostrar: No hay plantas en esta categoría. 7️⃣ Usar PreparedStatement para pasar el nombre de la categoría como parámetro en la consulta.


package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio32 {

	public static void main(String[] args) {

		// Declaración de objetos JDBC
		Connection conexion = null;
		PreparedStatement ps = null;
		ResultSet rs = null;

		// Pedimos la categoría al usuario
		String categoria = pedirCategoria();

		// Pasamos el texto a minúsculas para compararlo con LOWER() en SQL
		categoria = categoria.toLowerCase();

		try {

			// 1️⃣ Conexión a la base de datos MySQL
			conexion = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);

			// Consulta SQL con JOIN entre plantas y categorias
			String sql = "SELECT "
					+ " p.nombre AS nombre,"
					+ " p.variedad AS variedad,"
					+ " p.precio AS precio,"
					+ " p.stock AS stock,"
					+ " c.nombre AS categoria"
					+ " FROM plantas AS p"
					+ " INNER JOIN categorias AS c ON p.categoria_id=c.id"
					+ " WHERE LOWER(c.nombre)=?";

			// 7️⃣ Creamos PreparedStatement para evitar SQL Injection
			ps = conexion.prepareStatement(sql);

			// Pasamos el parámetro a la consulta
			ps.setString(1, categoria);

			// Ejecutamos la consulta SELECT
			rs = ps.executeQuery();

			// 6️⃣ Comprobamos si la consulta no devuelve resultados
			if (!rs.next()) {

				System.out.println("No hay plantas en esta categoría.");

			} else {

				// Si hay resultados mostramos el primero y los siguientes
				do {

					System.out.println("******************");

					System.out.println(
							"Nombre: " + rs.getString("nombre")
							+ "\nVariedad: " + rs.getString("variedad")
							+ "\nP.V.P: " + String.format("%.2f€", rs.getDouble("precio"))
							+ "\nStock: " + rs.getInt("stock") + " unidades"
							+ "\nCategoria: " + rs.getString("categoria"));

					System.out.println("******************");
					System.out.println();

				} while (rs.next()); // Recorremos todos los registros del ResultSet
			}

		} catch (SQLException e) {

			// Si ocurre algún error SQL lo mostramos
			e.printStackTrace();

		} finally {

			// Cerramos los recursos JDBC en orden inverso al que se crearon
			try {

				if (rs != null) rs.close();
				if (ps != null) ps.close();
				if (conexion != null) conexion.close();

			} catch (SQLException e) {

				e.printStackTrace();
			}
		}
	}

	// Método que pide al usuario el nombre de una categoría
	static String pedirCategoria() {

		String categoria;

		// Usamos try-with-resources para que Scanner se cierre automáticamente
		try (Scanner in = new Scanner(System.in)) {

			System.out.println("Introduce el nombre de una categoria:");
			categoria = in.nextLine();

			return categoria;
		}
	}
}

Ejercicio 33

Crea un programa en Java usando JDBC que se conecte a la base de datos vivero. El programa debe: 1️⃣ Conectarse a la base de datos vivero en MySQL. 2️⃣ No debe pedir datos al usuario. 3️⃣ Ejecutar una consulta SELECT que obtenga, para cada categoría: - El nombre de la categoría. - El número total de plantas disponibles en esa categoría (stock > 0). - El precio medio de las plantas en esa categoría. 4️⃣ La consulta debe usar: - JOIN entre plantas y categorias. - WHERE para filtrar solo las plantas con stock > 0. - GROUP BY para agrupar por categoría. - HAVING para mostrar solo las categorías que tengan al menos 2 plantas disponibles. 5️⃣ Mostrar los resultados con el siguiente formato: Categoría: Frutales Número de plantas disponibles: 5 Precio medio: 17.45€ ---------------------- Categoría: Cítricos Número de plantas disponibles: 3 Precio medio: 18.30€ ---------------------- 6️⃣ Si no existen categorías que cumplan estas condiciones, mostrar: No hay categorías con suficientes plantas disponibles. 7️⃣ Recorrer los resultados usando ResultSet.

package jdbc;

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

public class Ejercicio33 {

    public static void main(String[] args) {

        Connection cn = null;   // Objeto para la conexión a la base de datos
        Statement st = null;    // Objeto para ejecutar la consulta SQL
        ResultSet rs = null;    // Objeto para recorrer los resultados

        try {
            // 1️⃣ Conectarse a la BBDD
            cn = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/vivero", // URL de la base de datos
                    "root",                                // Usuario
                    "*prueba2024*"                         // Contraseña
            );

            // 2️⃣ Consulta SQL:
            // Selecciona el nombre de la categoría, la suma del stock de plantas y el precio medio
            // Filtra solo plantas con stock > 0
            // Agrupa por categoría
            // Muestra solo categorías con al menos 2 plantas disponibles
            String sql = "SELECT "
                    + " c.nombre AS categoria, "
                    + " SUM(p.stock) AS total, "
                    + " AVG(p.precio) AS precio_medio "
                    + " FROM plantas AS p "
                    + " INNER JOIN categorias AS c "
                    + " ON p.categoria_id=c.id "
                    + " WHERE p.stock>0 "
                    + " GROUP BY c.nombre "
                    + " HAVING SUM(p.stock)>=2";

            st = cn.createStatement();           // Crear statement para ejecutar la consulta

            rs = st.executeQuery(sql);           // Ejecutar la consulta y obtener resultados

            // 3️⃣ Comprobar si hay resultados
            if (!rs.next()) {
                System.out.println("No hay categorías con suficientes plantas disponibles.");
            } else {
                // 4️⃣ Recorrer el ResultSet y mostrar resultados
                do {
                    System.out.println("Categoria: " + rs.getString("categoria")
                            + "\nNúmero de plantas disponibles: " + rs.getInt("total")
                            + "\nP.V.P medio: " + String.format("%.2f€", rs.getDouble("precio_medio"))
                            + "\n----------------------\n");
                } while (rs.next());
            }

        } catch (SQLException e) {
            // Captura cualquier error de conexión o ejecución de SQL
            System.err.println("Error conectando con la BBDD: " + e.getMessage());
        } finally {
            // 5️⃣ Cerrar recursos siempre en el bloque finally para evitar fugas de memoria
            try {
                if (rs != null) rs.close();
                if (st != null) st.close();
                if (cn != null) cn.close();
            } catch (SQLException e) {
                System.err.println("Error trabajando con la BBDD: " + e.getMessage());
            }
        }
    }
}

Ejercicio 34

Crea un programa en Java usando JDBC que se conecte a la base de datos vivero. El programa debe: 1️⃣ Conectarse a la base de datos vivero en MySQL. 2️⃣ Pedir por consola dos valores: precio mínimo precio máximo 3️⃣ Ejecutar una consulta SELECT que obtenga todas las plantas cuyo precio esté entre esos dos valores. 4️⃣ La consulta debe usar JOIN entre las tablas plantas y categorias para mostrar también la categoría de cada planta. 5️⃣ Mostrar los resultados con el siguiente formato: Nombre: Peral Variedad: Conferencia Precio: 19.95 Stock: 6 Categoría: Frutales ---------------------- 6️⃣ Si no existen plantas dentro de ese rango de precios, mostrar: No hay plantas en ese rango de precios. 7️⃣ Usar PreparedStatement para pasar los dos valores del rango de precio a la consulta SQL.


package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio34 {

	public static void main(String[] args) {
		
		// Variables para manejar la conexión con la base de datos
		Connection cn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		
		// Variables para guardar el rango de precios introducido por el usuario
		double precioMin = 0.0, precioMax = 0.0;
		
		// Scanner para leer datos por consola
		Scanner in = new Scanner(System.in);
		
		// Bucle para pedir los precios hasta que el usuario introduzca valores válidos
		while(true)
		{
			try {
				// Pedir precio mínimo
				System.out.println("Introduce el P.V.P minimo:");
				precioMin = Double.parseDouble(in.nextLine());
				
				// Pedir precio máximo y validar que sea mayor o igual que el mínimo
				do {
					System.out.println("Introduce el P.V.P maximo:");
					precioMax = Double.parseDouble(in.nextLine());
					
					if(precioMax < precioMin) {
						System.err.println("El precio maximo tiene que ser mayor o igual que el precio minimo, introducelo de nuevo");
					}
				}while(precioMax < precioMin);
				
				// Si todo es correcto se sale del bucle
				break;
				
			}catch(NumberFormatException e) {
				// Si el usuario introduce algo que no es un número
				System.err.println("Error de formato de precio , introducelo de nuevo.");
			}
		}
		
		// Cerramos el Scanner porque ya no se va a utilizar más
		in.close();
			
		
		try {
			// Crear conexión con la base de datos MySQL
			cn = DriverManager.getConnection(
			        "jdbc:mysql://localhost:3306/vivero",
			        "root",
			        "*prueba2024*"
			);
			
			// Consulta SQL:
			// - Selecciona datos de la tabla plantas
			// - Hace un JOIN con categorias para obtener el nombre de la categoría
			// - Filtra por rango de precio usando BETWEEN
			String sql="SELECT "
					+ " p.nombre AS nombre,"
					+ " p.variedad AS variedad,"
					+ " p.precio AS precio,"
					+ " p.stock AS stock,"
					+ " c.nombre AS categoria"
					+ " FROM plantas AS p"
					+ " INNER JOIN categorias AS c"
					+ " ON p.categoria_id=c.id"
					+ " where p.precio BETWEEN ? AND ?";
			
			// Crear PreparedStatement a partir del SQL
			ps = cn.prepareStatement(sql);
			
			// Asignar valores a los parámetros ? de la consulta
			ps.setDouble(1, precioMin);
			ps.setDouble(2, precioMax);
			
			// Ejecutar la consulta SELECT
			rs = ps.executeQuery();
			
			// Comprobar si no hay resultados
			if(!rs.next()) {
				System.out.println("Ninguna planta se encuentra entre "
						+ String.format("%.2f€", precioMin)
						+ " y "
						+ String.format("%.2f€", precioMax));
			}else {
				
				// Si hay resultados, recorrerlos con un bucle
				do {
					System.out.println("Nombre: " + rs.getString("nombre")
					+ "\nVariedad: " + rs.getString("variedad")
					+ "\nP.V.P: " + String.format("%.2f€", rs.getDouble("precio"))
					+ "\nStock: " + rs.getInt("stock") + " unidades"
					+ "\nCategoria: " + rs.getString("categoria"));
					
					// Separador entre registros
					System.out.println("----------------------");
					System.out.println();
					
				}while(rs.next());
			}
			
			
		} catch (SQLException e) {
			
			// Mensaje si ocurre un error al trabajar con la base de datos
			System.err.println("Error trabajando con la BBDD");
			
		} finally {
			
			// Cerrar recursos en orden para liberar memoria
			try {
				if(rs != null) rs.close();
				if(ps != null) ps.close();
				if(cn != null) cn.close();
				
			}catch(SQLException e) {
				e.printStackTrace();
			}
			
		}

	}

}

Ejercicio 35

Crea un programa en Java usando JDBC que se conecte a la base de datos vivero. El programa debe: 1️⃣ Conectarse a la base de datos vivero en MySQL. 2️⃣ Pedir por consola el nombre de una categoría. 3️⃣ Ejecutar una consulta SELECT que obtenga las plantas de esa categoría que tengan stock mayor que 0. 4️⃣ La consulta debe usar: JOIN entre plantas y categorias WHERE para filtrar por nombre de categoría AND para exigir stock > 0 ORDER BY para ordenar por precio de mayor a menor 5️⃣ La consulta debe mostrar solo las 10 plantas más caras de esa categoría usando LIMIT. 6️⃣ Mostrar los resultados con el siguiente formato: Nombre: Naranjo Variedad: Valencia Precio: 18.50 Stock: 12 Categoría: Cítricos ---------------------- 7️⃣ Si no existen plantas que cumplan esas condiciones, mostrar: No hay plantas disponibles en esa categoría. 8️⃣ Usar PreparedStatement para pasar el nombre de la categoría como parámetro.

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio35 {

    public static void main(String[] args) {

        // Declaramos las variables para la conexión, el PreparedStatement y el ResultSet
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        String categoria = "";

        // Pedimos al usuario el nombre de la categoría
        try (Scanner in = new Scanner(System.in)) {
            System.out.println("Introduce el nombre de una categoria:");
            categoria = in.nextLine();
        }

        // Convertimos la categoría a minúsculas para evitar problemas de mayúsculas/minúsculas
        categoria = categoria.toLowerCase();

        try {
            // Creamos la conexión a la base de datos MySQL
            cn = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/vivero", // URL de la BBDD
                    "root", // usuario
                    "*prueba2024*" // contraseña
            );

            // Consulta SQL con JOIN, WHERE, AND, ORDER BY y LIMIT
            String sql = "SELECT "
                    + " p.nombre AS nombre,"          // Selecciona el nombre de la planta
                    + " p.variedad AS variedad,"      // Selecciona la variedad
                    + " p.precio AS precio,"          // Selecciona el precio
                    + " p.stock AS stock,"            // Selecciona el stock
                    + " c.nombre AS categoria"        // Selecciona el nombre de la categoría
                    + " FROM plantas AS p"
                    + " INNER JOIN categorias AS c"
                    + " ON p.categoria_id = c.id"     // Relación entre plantas y categorías
                    + " WHERE LOWER(c.nombre)=? AND p.stock>0" // Filtramos por categoría y stock > 0
                    + " ORDER BY p.precio DESC"       // Ordenamos por precio de mayor a menor
                    + " LIMIT 10";                     // Limitamos los resultados a 10 registros

            // Preparamos la sentencia con parámetro
            ps = cn.prepareStatement(sql);
            ps.setString(1, categoria); // Pasamos el valor de la categoría

            // Ejecutamos la consulta
            rs = ps.executeQuery();

            // Comprobamos si hay resultados
            if (!rs.next()) {
                System.out.println("No hay plantas disponibles en esa categoría.");
            } else {
                // Recorremos el ResultSet mostrando los resultados
                do {
                    System.out.println("Nombre: " + rs.getString("nombre")
                            + "\nVariedad: " + rs.getString("variedad")
                            + "\nP.V.P: " + String.format("%.2f€", rs.getDouble("precio"))
                            + "\nStock: " + rs.getInt("stock") + " unidades"
                            + "\nCategoria: " + rs.getString("categoria")
                            + "\n----------------------\n");
                } while (rs.next());
            }
        } catch (SQLException e) {
            System.err.println("Error conectando con la BBDD, " + e.getMessage());
        } finally {
            // Cerramos recursos en el bloque finally para asegurar que se liberen aunque haya errores
            try {
                if (rs != null) rs.close();
                if (ps != null) ps.close();
                if (cn != null) cn.close();
            } catch (SQLException e) {
                System.err.println("Error trabajando con la BBDD, " + e.getMessage());
            }
        }

    }

}

Ejercicio 36

Crea un programa en Java que: 1️⃣ Se conecte a la base de datos vivero. 2️⃣ Pida por consola los datos de un nuevo cliente: nombre, email, telefono, ciudad 3️⃣ Inserte el cliente en la tabla clientes usando PreparedStatement. 4️⃣ Muestre por consola: Cliente "Juan Pérez" insertado correctamente. 5️⃣ Controlar errores con try-catch. 6️⃣ Cerrar todos los recursos correctamente.

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio36 {

    public static void main(String[] args) {
        // Llamada al método que gestiona la creación de un nuevo cliente
        addCliente();
    }
    
    // Método que recibe un objeto Cliente y lo inserta en la base de datos
    static void insertarCliente(Cliente cliente) {
        
        // Consulta SQL con parámetros ? para PreparedStatement
        String sql = "INSERT INTO clientes(nombre,telefono,email,ciudad) VALUES(?,?,?,?)";
        
        // try-with-resources para cerrar automáticamente la conexión y el PreparedStatement
        try (Connection cn = DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/vivero", // URL de la BBDD
                "root",                                // usuario
                "*prueba2024*"                          // contraseña
            );
             PreparedStatement ps = cn.prepareStatement(sql)) {
            
            // Asignamos los valores del cliente a los parámetros de la consulta
            ps.setString(1, cliente.getNombre());
            ps.setString(2, cliente.getTelefono());
            ps.setString(3, cliente.getEmail());
            ps.setString(4, cliente.getCiudad());
            
            // Ejecutamos la inserción en la base de datos
            ps.executeUpdate();
            
            // Mensaje de confirmación en consola
            System.out.println("Cliente \"" + cliente.getNombre() + "\" insertado correctamente");

        } catch (SQLException e) {
            // Captura de errores SQL
            System.err.println("Error al trabajar con la BBDD, " + e.getMessage());
        }
    }

    // Método que pide los datos del cliente por consola y llama a insertarCliente
    static void addCliente() {
        
        String nombre;
        String email;
        String telefono;
        String ciudad;
        
        try (Scanner in = new Scanner(System.in)) {
            // Se pide cada campo al usuario
            nombre = addString("nombre", in);
            telefono = addString("telefono", in);
            email = addString("email", in);
            ciudad = addString("ciudad", in);
        }
        
        // Creamos un objeto Cliente con los datos introducidos
        Cliente cliente = new Cliente(nombre, telefono, email, ciudad);
        
        // Insertamos el cliente en la base de datos
        insertarCliente(cliente);
    }
    
    // Método auxiliar que pide un campo por consola y valida que no esté vacío
    static String addString(String nombreCampo, Scanner in) {
        
        while (true) {
            System.out.println("Introduce el " + nombreCampo + " del cliente:");
            String campo = in.nextLine();
            
            if (!campo.isEmpty()) {
                // Capitalizamos la primera letra si el campo no es email
                if (!nombreCampo.equalsIgnoreCase("email")) {
                    campo = campo.substring(0,1).toUpperCase() + campo.substring(1);
                }
                return campo; // devolvemos el valor válido
            }
            
            System.out.println("El " + nombreCampo + " del cliente no puede quedar vacio");
        }
    }
}

// Clase Cliente para almacenar los datos de un cliente
class Cliente {
    
    private String nombre;
    private String telefono;
    private String email;
    private String ciudad;
    
    // Constructor
    public Cliente(String nombre, String telefono, String email, String ciudad) {
        this.nombre = nombre;
        this.telefono = telefono;
        this.email = email;
        this.ciudad = ciudad;
    }

    // Getters y setters
    public String getNombre() { return nombre; }
    public void setNombre(String nombre) { this.nombre = nombre; }

    public String getTelefono() { return telefono; }
    public void setTelefono(String telefono) { this.telefono = telefono; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    public String getCiudad() { return ciudad; }
    public void setCiudad(String ciudad) { this.ciudad = ciudad; }

    // Método toString para mostrar el objeto Cliente de forma legible
    @Override
    public String toString() {
        return "Cliente\n Nombre -> " + nombre +
               "\nTelefono ->" + telefono +
               "\nEmail ->" + email +
               "\nCiudad ->" + ciudad;
    }
}

Ejercicio 37

Crea un programa en Java que: 1️⃣ Se conecte a la base de datos vivero. 2️⃣ Solicite al usuario seleccionar un cliente existente por su ID o buscarlo por nombre. 3️⃣ Inserte un nuevo pedido en la tabla pedidos, incluyendo la fecha actual y el cliente_id. 4️⃣ Inserte uno o varios productos en la tabla detalle_pedido asociados al pedido_id generado automáticamente. Para cada producto se pedirá: producto_id (o nombre del producto) cantidad 5️⃣ Use transacciones: Si falla algún paso (cliente no existe, producto no válido, error en la inserción) se hará rollback. Si todo va bien, se hace commit. 6️⃣ Mostrar por consola un resumen del pedido insertado, incluyendo el nombre del cliente y los productos agregados. 7️⃣ Controlar errores con try-catch y cerrar todos los recursos correctamente (Connection, PreparedStatement, ResultSet).

package jdbc;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio37 {

	public static void main(String[] args) {
		
		// 🔹 Conexión a la base de datos + Scanner (auto-close)
		try(Connection cn = DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/vivero",
                "root",
                "*prueba2024*"
        );Scanner in =new Scanner(System.in);
        ){
			
			// 🔹 Selección del cliente
			Client cliente=seleccionarCliente(cn,in);
			
			// 🔹 Validación de cliente
			if(cliente==null) {
				System.out.println("No se ha seleccionado bien el cliente");
			}else {
				// 🔹 Inserción del pedido
				insertarPedido(cn,in,cliente);
			}
		} catch (SQLException e) {
			System.err.println("Error al trabajar con la BBDD," + e.getMessage());
		}
	}
	
	static void insertarPedido(Connection cn, Scanner in, Client cliente) {

	    // 🔹 Fecha actual del pedido
	    LocalDate fecha = LocalDate.now();
	    
	    // 🔹 Lista de productos del pedido
	    ArrayList<DetallePedido> listaPedido = new ArrayList<>();
	    
	    // 🔹 Control acumulado de stock
	    int sumaStock = 0;

	    String sql = "INSERT INTO pedidos(fecha,cliente_id) VALUES(?,?)";
	    ResultSet rsIdPedido;
	    int idPedido = 0;

	    try {
	        // 🔴 INICIO TRANSACCIÓN
	        cn.setAutoCommit(false);

	        // 🔹 Insertar pedido
	        try (PreparedStatement psInserto = cn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {

	            psInserto.setDate(1, Date.valueOf(fecha));
	            psInserto.setInt(2, cliente.getId());

	            psInserto.executeUpdate();

	            // 🔹 Obtener ID generado automáticamente
	            rsIdPedido = psInserto.getGeneratedKeys();
	            rsIdPedido.next();
	            idPedido = rsIdPedido.getInt(1);

	            System.out.println("Numero pedido " + idPedido);
	        }

	        // 🔹 Consulta de plantas disponibles
	        sql = "SELECT id,nombre,variedad,precio,stock FROM plantas WHERE stock>0";

	        try (Statement st = cn.createStatement();
	             ResultSet rs = st.executeQuery(sql)) {

	            while (true) {

	                // 🔹 Mostrar plantas
	                while (rs.next()) {
	                    System.out.println(rs.getInt("id")
	                            + " | " + rs.getString("nombre")
	                            + " | " + rs.getString("variedad")
	                            + " | " + rs.getDouble("precio")
	                            + " | " + rs.getInt("stock"));
	                }

	                int id;

	                while (true) {

	                    // 🔹 Pedir ID de planta
	                    while (true) {
	                        try {
	                            System.out.println("Selecciona ID (0 salir):");
	                            id = Integer.parseInt(in.nextLine());
	                            break;
	                        } catch (NumberFormatException e) {
	                            System.err.println("Formato incorrecto");
	                        }
	                    }

	                    // 🔴 Si 0 → guardar pedido
	                    if (id == 0) {

	                        sql = "INSERT INTO detalle_Pedido(pedido_id,planta_id,cantidad,precio_unitario) VALUES(?,?,?,?)";

	                        try (PreparedStatement psInsertoDetalle = cn.prepareStatement(sql)) {

	                            // 🔹 Insert batch
	                            for (DetallePedido d : listaPedido) {
	                                psInsertoDetalle.setInt(1, d.getPedidoId());
	                                psInsertoDetalle.setInt(2, d.getPlantaId());
	                                psInsertoDetalle.setInt(3, d.getCantidad());
	                                psInsertoDetalle.setDouble(4, d.getPrecio());
	                                psInsertoDetalle.addBatch();
	                            }

	                            psInsertoDetalle.executeBatch();
	                        }

	                        // 🔴 Commit final
	                        cn.commit();
	                        System.out.println("Pedido realizado correctamente");
	                        break;
	                    }

	                    int stock;

	                    // 🔹 Pedir cantidad
	                    while (true) {
	                        try {
	                            System.out.println("Cantidad:");
	                            stock = Integer.parseInt(in.nextLine());
	                            break;
	                        } catch (NumberFormatException e) {
	                            System.err.println("Formato incorrecto");
	                        }
	                    }

	                    // 🔹 Buscar planta por ID
	                    sql = "SELECT id,nombre,variedad,precio,stock FROM plantas WHERE id=?";

	                    try (PreparedStatement psPedido = cn.prepareStatement(sql)) {

	                        psPedido.setInt(1, id);
	                        ResultSet rsPedido = psPedido.executeQuery();

	                        if (!rsPedido.next()) {
	                            System.out.println("Planta no existe");
	                        } else {

	                            boolean existe = false;

	                            // 🔹 Ver si ya está en el pedido
	                            for (DetallePedido d : listaPedido) {
	                                if (d.getPlantaId() == id) {
	                                    existe = true;
	                                    sumaStock += stock;
	                                }
	                            }

	                            // 🔹 Si no existe, reiniciar acumulado
	                            if (!existe) {
	                                sumaStock = stock;
	                            }

	                            // 🔹 Crear objeto planta
	                            Plant planta = new Plant(
	                                    rsPedido.getInt("id"),
	                                    rsPedido.getString("nombre"),
	                                    rsPedido.getString("variedad"),
	                                    rsPedido.getDouble("precio"),
	                                    rsPedido.getInt("stock")
	                            );

	                            // 🔹 Validar stock
	                            if (planta.getStock() < sumaStock) {
	                                System.out.println("Stock insuficiente");
	                            } else {

	                                if (existe) {
	                                    // 🔹 Actualizar cantidad
	                                    for (DetallePedido d : listaPedido) {
	                                        if (d.getPlantaId() == id) {
	                                            d.setCantidad(sumaStock);
	                                        }
	                                    }
	                                } else {
	                                    // 🔹 Añadir nuevo producto
	                                    listaPedido.add(new DetallePedido(idPedido, id, sumaStock, planta.getPrecio()));
	                                }
	                            }
	                        }
	                    }
	                }

	                // 🔹 Mostrar resumen
	                System.out.println("Id pedido: " + idPedido);
	                System.out.println(cliente);

	                double total = 0;

	                for (DetallePedido d : listaPedido) {
	                    System.out.println(d.getPlantaId() + " | " + d.getCantidad() + " | " + d.getPrecio());
	                    total += d.getCantidad() * d.getPrecio();
	                }

	                System.out.println("Total: " + String.format("%.2f€", total));
	                break;
	            }
	        }

	    } catch (SQLException e) {

	        // 🔴 Rollback en caso de error
	        try {
	            cn.rollback();
	            System.err.println("Rollback realizado");
	        } catch (SQLException ex) {
	            System.err.println("Error en rollback: " + ex.getMessage());
	        }

	        System.err.println("Error BBDD: " + e.getMessage());
	    }
	}

	static Client seleccionarCliente(Connection cn,Scanner in) {
		
		try{
			// 🔹 Obtener todos los clientes
			String sql="SELECT id,nombre,telefono,email,ciudad FROM clientes";
			
			try(Statement psMuestro=cn.createStatement();
					ResultSet rsMuestro=psMuestro.executeQuery(sql)){
			
				if(!rsMuestro.next()) {
					System.out.println("No hay clientes en la BBDD");
				}else {
					
					// 🔹 Mostrar clientes
					do {
						Client cliente=new Client(rsMuestro.getInt("id"),
								rsMuestro.getString("nombre"),
								rsMuestro.getString("telefono"),
								rsMuestro.getString("email"),
								rsMuestro.getString("ciudad"));
					
						System.out.println(cliente);
					}while(rsMuestro.next());
					
					int id;
					
					// 🔹 Selección válida de cliente
					while(true) {
						sql="SELECT id,nombre,telefono,email,ciudad FROM clientes WHERE id=?";
						
						try(PreparedStatement psSelecciono=cn.prepareStatement(sql)){
							
							System.out.println("Selecciona el ID del cliente:");
							id=Integer.parseInt(in.nextLine());
														
							psSelecciono.setInt(1, id);
								
							try(ResultSet rsSelecciono=psSelecciono.executeQuery()){
								if(!rsSelecciono.next()) {
									System.out.println("ID no válido");
								}else {
									
									// 🔹 Cliente seleccionado
									Client cliente=new Client(rsSelecciono.getInt("id"),
											rsSelecciono.getString("nombre"),
											rsSelecciono.getString("telefono"),
											rsSelecciono.getString("email"),
											rsSelecciono.getString("ciudad"));
								
									System.out.println("Cliente seleccionado");
									System.out.println(cliente);
									
									return cliente;
								}
							}
						}catch(NumberFormatException e) {
							System.err.println("Formato incorrecto");
						}
					}
				}
			}
		} catch (SQLException e) {
			System.err.println("Error BBDD, " + e.getMessage());
		}
		return null;
	}
}

// 🔹 Clase Cliente → representa un registro de la tabla clientes
class Client{
	private int id;
	private String nombre;
	private String telefono;
	private String email;
	private String ciudad;
	
	// 🔹 Constructor
	public Client(int id, String nombre, String telefono, String email, String ciudad) {
		this.id = id;
		this.nombre = nombre;
		this.telefono = telefono;
		this.email = email;
		this.ciudad = ciudad;
	}

	// 🔹 Getters y setters
	public int getId() { return id; }
	public void setId(int id) { this.id = id; }

	public String getNombre() { return nombre; }
	public void setNombre(String nombre) { this.nombre = nombre; }

	public String getTelefono() { return telefono; }
	public void setTelefono(String telefono) { this.telefono = telefono; }

	public String getEmail() { return email; }
	public void setEmail(String email) { this.email = email; }

	public String getCiudad() { return ciudad; }
	public void setCiudad(String ciudad) { this.ciudad = ciudad; }

	// 🔹 Representación en consola
	@Override
	public String toString() {
		return "Id -> " + id + " | Nombre -> " + nombre + " | Telefono -> " + telefono + " | Email ->" + email + " | Ciudad ->"
				+ ciudad;
	}
}

// 🔹 Clase Planta → representa tabla plantas
class Plant{
	private int id;
	private String nombre;
	private String variedad;
	private double precio;
	private int stock;
	
	public Plant(int id, String nombre, String variedad, double precio, int stock) {
		this.id = id;
		this.nombre = nombre;
		this.variedad = variedad;
		this.precio = precio;
		this.stock = stock;
	}

	// 🔹 Getters y setters
	public int getId() { return id; }
	public void setId(int id) { this.id = id; }

	public String getNombre() { return nombre; }
	public void setNombre(String nombre) { this.nombre = nombre; }

	public String getVariedad() { return variedad; }
	public void setVariedad(String variedad) { this.variedad = variedad; }

	public double getPrecio() { return precio; }
	public void setPrecio(double precio) { this.precio = precio; }

	public int getStock() { return stock; }
	public void setStock(int stock) { this.stock = stock; }

	@Override
	public String toString() {
		return "Id=" + id + " | Nombre=" + nombre + " | Variedad=" + variedad + " | P.V.P=" + String.format("%.2f€", precio) + " | Stock=" + stock;
	}
}

// 🔹 Clase DetallePedido → representa cada línea del pedido
class DetallePedido{
	private int id;
	private int pedidoId;
	private int plantaId;
	private int cantidad;
	private double precio;
	
	public DetallePedido(int pedidoId, int plantaId, int cantidad, double precio) {
		this.pedidoId = pedidoId;
		this.plantaId = plantaId;
		this.cantidad = cantidad;
		this.precio = precio;
	}

	// 🔹 Getters y setters
	public int getId() { return id; }
	public void setId(int id) { this.id = id; }

	public int getPedidoId() { return pedidoId; }
	public void setPedidoId(int pedidoId) { this.pedidoId = pedidoId; }

	public int getPlantaId() { return plantaId; }
	public void setPlantaId(int plantaId) { this.plantaId = plantaId; }

	public int getCantidad() { return cantidad; }
	public void setCantidad(int cantidad) { this.cantidad = cantidad; }

	public double getPrecio() { return precio; }
	public void setPrecio(double precio) { this.precio = precio; }

	@Override
	public String toString() {
		return "Id=" + id + " | IDPedido=" + pedidoId + " | IdPlanta=" + plantaId + " | Cantidad=" + cantidad + " | P.V.P=" + String.format("%.2f€", precio);
	}
}

// 🔹 Clase Pedido → representa tabla pedidos
class Pedido{
	private int id;
	private LocalDate fecha;
	private int clienteId;
	
	public Pedido(int id, LocalDate fecha, int clienteId) {
		this.id = id;
		this.fecha = fecha;
		this.clienteId = clienteId;
	}

	// 🔹 Getters y setters
	public int getId() { return id; }
	public void setId(int id) { this.id = id; }

	public LocalDate getFecha() { return fecha; }
	public void setFecha(LocalDate fecha) { this.fecha = fecha; }

	public int getClienteId() { return clienteId; }
	public void setLienteId(int clienteId) { this.clienteId = clienteId; }

	@Override
	public String toString() {
		return "Id=" + id + " | Fecha=" + fecha + " | IDCliente=" + clienteId;
	}
}

Ejercicio 38

Crea un programa en Java que realice lo siguiente: 1️⃣ Se conecte a la base de datos vivero. 2️⃣ Desactive el autoCommit para trabajar con transacciones. 3️⃣ Inserte un nuevo cliente en la tabla clientes con los siguientes datos: nombre teléfono email ciudad 4️⃣ Obtenga el id generado automáticamente del cliente insertado. 5️⃣ Inserte un nuevo pedido en la tabla pedidos usando: la fecha actual el cliente_id obtenido en el paso anterior 6️⃣ Use transacciones: Si todo se inserta correctamente → hacer commit Si ocurre cualquier error en cualquiera de los inserts → hacer rollback 7️⃣ Mostrar por consola: ID del cliente creado ID del pedido creado Mensaje final de éxito o error 8️⃣ Cerrar correctamente todos los recursos.

package jdbc;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.LocalDate;
import java.util.Scanner;

public class Ejercicio38 {

	public static void main(String[] args) {
		
		Connection cn = null;
		
		try (Scanner in = new Scanner(System.in)) {
			
			// Conexión a la base de datos
			cn = DriverManager.getConnection(
				"jdbc:mysql://localhost:3306/vivero",
				"root",
				"*prueba2024*"
			);
			
			// Desactivar autoCommit para manejar transacción manual
			cn.setAutoCommit(false);
			
			// Cargar datos del cliente y ejecutar flujo completo
			cargarCliente(cn, in);
			
			// Confirmar transacción si todo ha ido bien
			cn.commit();
			System.out.println("Transacción completada correctamente.");
			
		} catch (SQLException e) {
			
			// Si ocurre un error, hacer rollback
			try {
				if (cn != null && !cn.isClosed()) {
					cn.rollback();
					System.err.println("Rollback ejecutado por error: " + e.getMessage());
				}
			} catch (SQLException e1) {
				e1.printStackTrace();
			} finally {
				
				// Cerrar conexión
				if (cn != null) {
					try {
						cn.close();
					} catch (SQLException e1) {
						e1.printStackTrace();
					}
				}
			}
		}
	}
	
	// Método para pedir datos por consola con validación básica
	static String campoTexto(Scanner in, String campo, String nombre) {
		
		while (true) {
			System.out.println("Introduce " + nombre + " para el nuevo cliente:");
			campo = in.nextLine();
			
			// Validar que no esté vacío
			if (campo.isEmpty()) {
				System.out.println("El campo " + nombre + " no puede quedar vacío.");
			} else {
				// Normalizar primera letra
				return campo.substring(0, 1) + campo.substring(1);
			}
		}
	}
	
	// Inserta el pedido asociado al cliente
	static void insertoPedido(Connection cn, int idCliente) throws SQLException {
		
		// Fecha actual
		LocalDate fecha = LocalDate.now();
		
		String sql = "INSERT INTO pedidos(fecha, cliente_id) VALUES(?, ?)";
		
		try (PreparedStatement ps = cn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
			
			// Asignar parámetros
			ps.setDate(1, Date.valueOf(fecha));
			ps.setInt(2, idCliente);
			
			// Ejecutar insert
			ps.executeUpdate();
			
			// Obtener ID generado del pedido
			int idPedido = 0;
			try (ResultSet rs = ps.getGeneratedKeys()) {
				if (rs.next()) {
					idPedido = rs.getInt(1);
				}
			}
			
			// Mostrar resultados
			System.out.println("ID cliente creado -> " + idCliente);
			System.out.println("ID pedido creado -> " + idPedido);
			System.out.println("Pedido insertado correctamente");
		}
	}
	
	// Inserta cliente en la base de datos
	static void insertarCliente(Connection cn, Cliente cliente) throws SQLException {
		
		String sql = "INSERT INTO clientes(nombre, telefono, email, ciudad) VALUES(?, ?, ?, ?)";
		
		try (PreparedStatement ps = cn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
			
			// Asignar valores
			ps.setString(1, cliente.getNombre());
			ps.setString(2, cliente.getTelefono());
			ps.setString(3, cliente.getEmail());
			ps.setString(4, cliente.getCiudad());
			
			// Ejecutar insert
			ps.executeUpdate();
			
			// Obtener ID cliente generado
			int idCliente = 0;
			try (ResultSet rs = ps.getGeneratedKeys()) {
				if (rs.next()) {
					idCliente = rs.getInt(1);
				}
			}
			
			// Insertar pedido asociado
			insertoPedido(cn, idCliente);
		}
	}
	
	// Recoge datos del cliente por consola
	static void cargarCliente(Connection cn, Scanner in) throws SQLException {
		
		String nombre;
		String telefono;
		String email;
		String ciudad;
		
		// Entrada de datos
		nombre = campoTexto(in, "", "nombre");
		telefono = campoTexto(in, "", "telefono");
		email = campoTexto(in, "", "email");
		ciudad = campoTexto(in, "", "ciudad");
		
		// Crear objeto cliente
		Cliente cliente = new Cliente(nombre, telefono, email, ciudad);
		
		// Insertar en BD
		insertarCliente(cn, cliente);
	}
	
	// Clase modelo Cliente
	static class Cliente {
		
		private int id;
		private String nombre;
		private String telefono;
		private String email;
		private String ciudad;
		
		public Cliente(int id, String nombre, String telefono, String email, String ciudad) {
			this.id = id;
			this.nombre = nombre;
			this.telefono = telefono;
			this.email = email;
			this.ciudad = ciudad;
		}

		public Cliente(String nombre, String telefono, String email, String ciudad) {
			this.nombre = nombre;
			this.telefono = telefono;
			this.email = email;
			this.ciudad = ciudad;
		}

		public int getId() { return id; }
		public void setId(int id) { this.id = id; }
		public String getNombre() { return nombre; }
		public void setNombre(String nombre) { this.nombre = nombre; }
		public String getTelefono() { return telefono; }
		public void setTelefono(String telefono) { this.telefono = telefono; }
		public String getEmail() { return email; }
		public void setEmail(String email) { this.email = email; }
		public String getCiudad() { return ciudad; }
		public void setCiudad(String ciudad) { this.ciudad = ciudad; }
		
		@Override
		public String toString() {
			return "Cliente{ id=" + id + ", nombre=" + nombre + ", telefono=" + telefono + ", email=" + email + ", ciudad=" + ciudad + " }";
		}
	}
}

Ejercicio 39

Crea un programa en Java que: 1️⃣ Se conecte a la base de datos vivero. 2️⃣ Pida al usuario: ID de un cliente ID de una planta Cantidad a comprar 3️⃣ Realice todo dentro de una transacción: Insertar un nuevo registro en la tabla pedido con: fecha actual id del cliente Insertar un registro en detalle_pedido con: id del pedido creado id de la planta cantidad Restar la cantidad al stock de la planta en la tabla plantas. 4️⃣ Condición importante: Si el stock queda negativo, hacer rollback y cancelar todo. Si todo es correcto, hacer commit. 5️⃣ Desactivar el autocommit para controlar la transacción manualmente. 🎯 Objetivo Manejar varias operaciones en una sola transacción Usar setAutoCommit(false) Aplicar commit() y rollback() correctamente

package jdbc;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.LocalDate;
import java.util.Scanner;

public class Ejercicio39 {

	public static void main(String[] args) {
		
		// Conexión a la base de datos + Scanner para entrada por consola
		try(Connection cn = DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/vivero",
                "root",
                "*prueba2024*"
        );Scanner in = new Scanner(System.in)){
			
			// Desactivamos autocommit para controlar la transacción manualmente
			cn.setAutoCommit(false);
			
			// Flujo principal del programa
			datosIniciales(cn,in);
			
		} catch (SQLException e) {
			System.err.println("Error al conectar con la BBDD, " + e.getMessage());
		}
	}
	
	static void datosIniciales(Connection cn, Scanner in) {
		
		// Seleccionamos cliente desde la BD
		Cli cliente=seleccionoCliente(cn,in);
		
		// Seleccionamos planta desde la BD
		Pla planta=seleccionaPlanta(cn,in);
		
		// Pedimos cantidad a comprar validando con el stock leído
		int cantidad=cantidadComprar(in,planta.getStock());
		
		// Ejecutamos la operación completa (transacción)
		inserto(cn,cliente,planta,cantidad);
	}
	
	static void inserto(Connection cn,Cli cliente,Pla planta,int cantidad) {
		
		// Insertamos pedido y obtenemos su ID generado
		int numPedido=insertoPedido(cn,cliente);
		
		// Insertamos detalle + actualizamos stock (todo dentro de la transacción)
		insertoDetalle(cn,planta,numPedido,cantidad);
	}
	
	static void insertoDetalle(Connection cn,Pla planta, int numPedido, int cantidad) {
		
		// Insert del detalle del pedido
		String sql="INSERT INTO detalle_pedido(pedido_id,planta_id,cantidad,precio_unitario)"
				+ " VALUES(?,?,?,?)";
			
		try (PreparedStatement psInserto=cn.prepareStatement(sql)){
			psInserto.setInt(1, numPedido);
			psInserto.setInt(2, planta.getId());
			psInserto.setInt(3, cantidad);
			psInserto.setDouble(4, planta.getPrecio());
				
			// Mostramos el total de la compra
			System.out.println("Total compra -> " + String.format("%.2f€", (cantidad*planta.getPrecio())));
				
			psInserto.executeUpdate();
				
			// Actualización de stock con control de concurrencia (stock >= cantidad)
			sql="UPDATE plantas"
					+ " set stock=stock-?"
					+ " where id=? AND stock>=?";
				
			try (PreparedStatement psActualizo=cn.prepareStatement(sql)){
				psActualizo.setInt(1, cantidad);
				psActualizo.setInt(2, planta.getId());
				psActualizo.setInt(3, cantidad);
				
				// Ejecutamos update y comprobamos si se ha modificado alguna fila
				int filas=psActualizo.executeUpdate();
					
				// Si no se actualiza ninguna fila → no hay stock suficiente
				if(filas==0) {
					System.out.println("Stock insuficiente, operacion de venta cancelada");
					cn.rollback(); // deshacemos toda la transacción
					return;
				}
				
				// Si todo va bien → confirmamos cambios
				cn.commit();
				
			} catch (SQLException e2) {
				try {
					cn.rollback(); // rollback si falla el update
				} catch (SQLException e) {
					e.printStackTrace();
				}
				e2.printStackTrace();
			}
				
		} catch (SQLException e2) {
			try {
				cn.rollback(); // rollback si falla el insert
			} catch (SQLException e) {
				e.printStackTrace();
			}
			e2.printStackTrace();
		}
	}
	
	static int insertoPedido(Connection cn,Cli cliente) {
		
		// Obtenemos la fecha actual
		LocalDate fecha=LocalDate.now();
		
		String sql="INSERT INTO pedidos(fecha,cliente_id)"
				+ " VALUES(?,?)";
		
		try(PreparedStatement stPedido=cn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS)){
			
			// Insertamos pedido
			stPedido.setDate(1, Date.valueOf(fecha));
			stPedido.setInt(2, cliente.getId());
			
			stPedido.executeUpdate();
			
			// Recuperamos el ID generado automáticamente
			ResultSet rsNum=stPedido.getGeneratedKeys();
			rsNum.next();
			int numPedido=rsNum.getInt(1);
			
			return numPedido;
			
		} catch (SQLException e) {
			System.err.println("Error al trabajar con la BBDD," + e.getMessage());
		}
		
		return 0;
	}
	
	static int cantidadComprar(Scanner in, int stock) {
		
		int cantidad=0;
		
		// Bucle hasta introducir una cantidad válida
		while(true)
			try {
				System.out.println("Introduce la cantidad de planta a comprar:");
				cantidad=Integer.parseInt(in.nextLine());
				
				// Validación simple con stock leído (solo UX)
				if(cantidad>stock) {
					System.out.println("No hay stock suficiente, introduce la cantidad de nuevo ");
				}else {
					return cantidad;
				}
				
			}catch(NumberFormatException e) {
				System.err.println("Formato de cantidad incorrecto, introducelo de nuevo.");
			}
	}
	
	static Pla seleccionaPlanta(Connection cn,Scanner in) {
		
		String sql="Select id,nombre,precio,stock"
				+ " FROM plantas";
		int id=0;
		
		try(Statement stPlanta=cn.createStatement();ResultSet rsPlanta=stPlanta.executeQuery(sql)){
			
			// Mostramos listado de plantas
			System.out.println(" ********* Listado de plantas ********* ");
			System.out.println("ID         NOMBRE        P.V.P      STOCK");
			
			while(rsPlanta.next()) {
				System.out.println(rsPlanta.getInt("id") 
				 + " |        " + rsPlanta.getString("nombre")
				 + "        " + String.format("%.2f€",rsPlanta.getDouble("precio"))
				 + "      " + rsPlanta.getInt("stock"));
			}
			
			// Selección de planta por ID
			while(true) {
				try {
					System.out.println("Selecciona un id de planta");
					id=Integer.parseInt(in.nextLine());
					
					sql="SELECT id,nombre,variedad,precio,stock,categoria_id"
							+ " FROM plantas"
							+ " WHERE id=?";
					
					ResultSet rsPla=null;
					
					try(PreparedStatement psPlanta=cn.prepareStatement(sql)){
						psPlanta.setInt(1, id);
						rsPla=psPlanta.executeQuery();
						
						if(!rsPla.next()) {
							System.out.println("EL ID introducido no corresponde con ninguna planta actual");
						}else {
							// Creamos objeto Planta a partir del ResultSet
							Pla planta=new Pla(rsPla.getInt("id"),
									rsPla.getString("nombre"),
									rsPla.getString("variedad"),
									rsPla.getDouble("precio"),
									rsPla.getInt("stock"),
									rsPla.getInt("categoria_id"));
							return planta;
						}
					}catch(SQLException e) {
						System.err.println("Error al trabajar con la BBDD, " + e.getMessage());
					}finally {
						if(rsPla!=null) rsPla.close();
					}
					
				}catch(NumberFormatException e) {
					System.err.println("Formato de id incorrecto, introducelo de nuevo");
				}
			}
			
		} catch (SQLException e) {
			System.err.println("Error al trabajar con la BBDD," + e.getMessage());
		}
	
		return null;
	}
	
	static Cli seleccionoCliente(Connection cn,Scanner in) {
		
		String sql="Select id,nombre"
				+ " FROM clientes";
		int id=0;
		
		try(Statement stCliente=cn.createStatement();ResultSet rsCliente=stCliente.executeQuery(sql)){
			
			// Mostramos listado de clientes
			System.out.println(" ********* Listado de clientes ********* ");
			System.out.println("ID   NOMBRE");
			
			while(rsCliente.next()) {
				System.out.println(rsCliente.getInt("id") + " | " + rsCliente.getString("nombre"));
			}
			
			// Selección de cliente por ID
			while(true) {
				try {
					System.out.println("Selecciona un id de cliente:");
					id=Integer.parseInt(in.nextLine());
					
					sql="SELECT id,nombre,telefono,email,ciudad"
							+ " FROM clientes"
							+ " WHERE id=?";
					
					ResultSet rsCli=null;
					
					try(PreparedStatement psCliente=cn.prepareStatement(sql)){
						psCliente.setInt(1, id);
						rsCli=psCliente.executeQuery();
						
						if(!rsCli.next()) {
							System.out.println("EL ID introducido no corresponde con ningun cliente actual");
						}else {
							// Creamos objeto Cliente a partir del ResultSet
							Cli cliente=new Cli(rsCli.getInt("id"),
									rsCli.getString("nombre"),
									rsCli.getString("telefono"),
									rsCli.getString("email"),
									rsCli.getString("ciudad"));
							return cliente;
						}
					}catch(SQLException e) {
						System.err.println("Error al trabajar con la BBDD, " + e.getMessage());
					}finally {
						if(rsCli!=null) rsCli.close();
					}
					
				}catch(NumberFormatException e) {
					System.err.println("Formato de id incorrecto, introducelo de nuevo");
				}
			}
			
		} catch (SQLException e) {
			System.err.println("Error al trabajar con la BBDD," + e.getMessage());
		}
	
		return null;
	}
	
	static class Cli{
		
		private int id;
		private String nombre;
		private String telefono;
		private String email;
		private String ciudad;
		
		public Cli(int id, String nombre, String telefono, String email, String ciudad) {
			this.id = id;
			this.nombre = nombre;
			this.telefono = telefono;
			this.email = email;
			this.ciudad = ciudad;
		}

		public Cli(String nombre, String telefono, String email, String ciudad) {
			this.nombre = nombre;
			this.telefono = telefono;
			this.email = email;
			this.ciudad = ciudad;
		}

		public int getId() { return id; }

		public void setId(int id) { this.id = id; }

		public String getNombre() { return nombre; }

		public void setNombre(String nombre) { this.nombre = nombre; }

		public String getTelefono() { return telefono; }

		public void setTelefono(String telefono) { this.telefono = telefono; }

		public String getEmail() { return email; }

		public void setEmail(String email) { this.email = email; }

		public String getCiudad() { return ciudad; }

		public void setCiudad(String ciudad) { this.ciudad = ciudad; }

		@Override
		public String toString() {
			return "ID= " + id + " | Nombre= " + nombre + " | Tlf.= " + telefono + " | Email= " + email + " | Ciudad= " + ciudad;
		}
	}
}

//=========================
//MODELO PEDIDO
//=========================
class Pedid{
	
	private int id;
	private Date fecha;
	private int clienteId;
	
	public Pedid(int id, Date fecha, int clienteId) {
		this.id = id;
		this.fecha = fecha;
		this.clienteId = clienteId;
	}
	
	public Pedid(Date fecha, int clienteId) {
		this.fecha = fecha;
		this.clienteId = clienteId;
	}

	public int getId() { return id; }

	public void setId(int id) { this.id = id; }

	public Date getFecha() { return fecha; }

	public void setFecha(Date fecha) { this.fecha = fecha; }

	public int getClienteId() { return clienteId; }

	public void setClienteId(int clienteId) { this.clienteId = clienteId; }

	@Override
	public String toString() {
		return "Id= " + id + " | Fecha= " + fecha + " |IDCliente= " + clienteId;
	}
}

//=========================
//MODELO CLIENTE
//=========================


//=========================
//MODELO PLANTA
//=========================
class Pla{
	
	private int id;
	private String nombre;
	private String variedad;
	private double precio;
	private int stock;
	private int idCategoria;
	
	public Pla(int id, String nombre, String variedad, double precio,int stock, int idCategoria) {
		this.id = id;
		this.nombre = nombre;
		this.variedad = variedad;
		this.precio = precio;
		this.stock = stock;
		this.idCategoria = idCategoria;
	}

	public Pla(String nombre, String variedad, double precio,int stock, int idCategoria) {
		this.nombre = nombre;
		this.variedad = variedad;
		this.precio = precio;
		this.stock = stock;
		this.idCategoria = idCategoria;
	}

	public int getId() { return id; }

	public void setId(int id) { this.id = id; }

	public String getNombre() { return nombre; }

	public void setNombre(String nombre) { this.nombre = nombre; }

	public String getVariedad() { return variedad; }

	public void setVariedad(String variedad) { this.variedad = variedad; }

	public double getPrecio() { return precio; }

	public void setPrecio(double precio) { this.precio = precio; }

	public int getStock() { return stock; }

	public void setStock(int stock) { this.stock = stock; }

	public int getIdCategoria() { return idCategoria; }

	public void setIdCategoria(int idCategoria) { this.idCategoria = idCategoria; }

	@Override
	public String toString() {
		return "Id= " + id + " | Nombre= " + nombre + " | Variedad= " + variedad +
		       " | P.V.P= " + String.format("%.2f€", precio) +
		       " | Stock= " + stock + " | Categoria= " + idCategoria;
	}
}

Ejercicio 40

Crea un programa en Java que: 1️⃣ Se conecte a la base de datos vivero. 2️⃣ Pida al usuario: - Nombre de un nuevo cliente - Teléfono - Email - Ciudad 3️⃣ Realice todo dentro de una transacción: - Desactivar autocommit (setAutoCommit(false)) - Comprobar mediante SELECT si ya existe un cliente con ese email - Si existe → rollback y cancelar operación - Insertar un nuevo cliente en la tabla clientes con los datos introducidos 4️⃣ Si todo es correcto → commit 5️⃣ Si ocurre cualquier error → rollback

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio40 {

	public static void main(String[] args) {

		// Conexión a la base de datos + Scanner para entrada de datos
		try (Connection cn = DriverManager.getConnection(
				"jdbc:mysql://localhost:3306/vivero",
				"root",
				"*prueba2024*"
		);
		Scanner in = new Scanner(System.in)) {

			// 🔴 Activamos control manual de transacciones
			cn.setAutoCommit(false);

			// Pedimos datos del cliente
			Cliente cliente = addClient(cn, in);

			// Comprobamos si el cliente ya existe por email
			boolean existe = comprobarCliente(cn, cliente);

			// Si existe, cancelamos operación con rollback
			if (existe) {
				System.out.println("El cliente ya existe, se revertirán los cambios");
				cn.rollback();
			} else {

				// Si no existe, intentamos insertar dentro de transacción
				try {
					insertCliente(cn, cliente);

					// Si todo ha ido bien, confirmamos cambios
					cn.commit();

				} catch (SQLException e) {

					// Si falla el insert, revertimos todo
					System.err.println("Error al insertar el nuevo cliente \"" 
							+ cliente.getNombre() + "\", se revertirán los cambios. (" 
							+ e.getMessage() + ")");

					cn.rollback();
				}
			}

		} catch (SQLException e) {
			System.err.println("Error al conectar con la BBDD, " + e.getMessage());
		}
	}

	// INSERT de cliente en la base de datos
	static void insertCliente(Connection cn, Cliente cliente) throws SQLException {

		String sql = "INSERT INTO clientes(nombre,telefono,email,ciudad) VALUES(?,?,?,?)";

		try (PreparedStatement psInserto = cn.prepareStatement(sql)) {

			// Asignación de parámetros
			psInserto.setString(1, cliente.getNombre());
			psInserto.setString(2, cliente.getTelefono());
			psInserto.setString(3, cliente.getEmail());
			psInserto.setString(4, cliente.getCiudad());

			// Ejecutamos inserción
			psInserto.executeUpdate();
		}
	}

	// Comprobamos si existe cliente por email
	static boolean comprobarCliente(Connection cn, Cliente cliente) {

		String sql = "SELECT id FROM clientes WHERE email = ?";

		try (PreparedStatement psSelect = cn.prepareStatement(sql)) {

			psSelect.setString(1, cliente.getEmail());

			ResultSet rs = psSelect.executeQuery();

			// Si hay resultado, el cliente ya existe
			return rs.next();

		} catch (SQLException e) {
			System.err.println("Error al consultar la BBDD: " + e.getMessage());

			// Por seguridad, asumimos que existe para evitar duplicados
			return true;
		}
	}

	// Entrada de texto con validación básica y formateo
	static String campoTexto(String campo, String nombre, Scanner in) {

		while (true) {

			System.out.println("Introduce " + nombre + " del cliente:");
			campo = in.nextLine().trim();

			// Validación de vacío
			if (campo.isEmpty()) {
				System.err.println(nombre + " no puede quedar vacío, introdúcelo de nuevo");
			} else {
				// Capitaliza primera letra
				return campo.substring(0, 1).toUpperCase()
						+ campo.substring(1).toLowerCase();
			}
		}
	}

	// Construcción del objeto Cliente
	static Cliente addClient(Connection cn, Scanner in) {

		String nombre;
		String telefono;
		String email;
		String ciudad;

		// Pedimos datos
		nombre = campoTexto("", "nombre", in);
		telefono = campoTexto("", "telefono", in);
		email = campoTexto("", "email", in);
		ciudad = campoTexto("", "ciudad", in);

		// Creamos objeto cliente
		return new Cliente(nombre, telefono, email, ciudad);
	}

	// Clase cliente (modelo de datos)
	static class Cliente {

		private int id;
		private String nombre;
		private String telefono;
		private String email;
		private String ciudad;

		public Cliente(int id, String nombre, String telefono, String email, String ciudad) {
			this.id = id;
			this.nombre = nombre;
			this.telefono = telefono;
			this.email = email;
			this.ciudad = ciudad;
		}

		public Cliente(String nombre, String telefono, String email, String ciudad) {
			this.nombre = nombre;
			this.telefono = telefono;
			this.email = email;
			this.ciudad = ciudad;
		}

		public String getNombre() { return nombre; }
		public String getTelefono() { return telefono; }
		public String getEmail() { return email; }
		public String getCiudad() { return ciudad; }
		public int getId() { return id; }

		@Override
		public String toString() {
			return "Id= " + id + " | Nombre= " + nombre + " | Tlf.= " + telefono
					+ " | Email= " + email + " | Ciudad= " + ciudad;
		}
	}
}

Ejercicio 41

Crea un programa en Java que realice lo siguiente: 1️⃣ Conectarse a la base de datos vivero. 2️⃣ Pedir por consola: ID de un cliente existente Nuevo teléfono 3️⃣ Actualizar en la tabla clientes: El campo telefono del cliente con ese ID 4️⃣ Usar una consulta UPDATE con PreparedStatement. 5️⃣ Mostrar por consola: Número de filas afectadas Mensaje de éxito o error 6️⃣ Cerrar correctamente todos los recursos y manejar excepciones.

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio41 {

	public static void main(String[] args) {
		
		// Conexión a la base de datos + Scanner en try-with-resources
		try (Connection cn = DriverManager.getConnection(
				"jdbc:mysql://localhost:3306/vivero",
				"root",
				"*prueba2024*"
		);
		Scanner in = new Scanner(System.in)) {
			
			// Pedir ID del cliente
			int idCliente = addIdCliente(in);
			
			// Pedir nuevo teléfono
			String telefono = addTelefono(in);
			
			// Actualizar teléfono en BD
			actualizarTelefono(cn, idCliente, telefono);
			
		} catch (SQLException e) {
			
			// Error general de base de datos
			System.err.println("Error al trabajar con la BBDD, " + e.getMessage());
		}

	}
	
	// Método que realiza el UPDATE del teléfono del cliente
	static void actualizarTelefono(Connection cn, int idCliente, String telefono) {
		
		String sql = "UPDATE clientes" 
				+ " SET telefono=?" 
				+ " WHERE id=?";
		
		try (PreparedStatement psActualizo = cn.prepareStatement(sql)) {
			
			// Asignar parámetros
			psActualizo.setString(1, telefono);
			psActualizo.setInt(2, idCliente);
			
			// Ejecutar UPDATE
			int filas = psActualizo.executeUpdate();
			
			// Mostrar resultado
			if (filas == 0) {
				System.out.println("El id de cliente no existe.");
			} else {
				System.out.println("Teléfono actualizado correctamente");
				System.out.println("Filas afectadas: " + filas);
			}
			
		} catch (SQLException e) {
			System.err.println("Error al actualizar el teléfono del cliente");
		}
	}
	
	// Pedir y validar teléfono (solo números y 9 dígitos)
	static String addTelefono(Scanner in) {
		
		String telefono = "";
		
		while (true) {
			System.out.println("Introduce el nuevo teléfono (9 cifras):");
			telefono = in.nextLine();
			
			boolean error = false;
			
			// Comprobar que todos los caracteres sean números
			for (int i = 0; i < telefono.length(); i++) {
				if (telefono.charAt(i) < '0' || telefono.charAt(i) > '9') {
					error = true;
				}
			}
			
			if (error) {
				System.err.println("Solo se permiten números.");
			} else if (telefono.length() != 9) {
				System.err.println("Debe tener exactamente 9 dígitos.");
			} else {
				return telefono;
			}
		}
	}
	
	// Pedir ID del cliente con validación básica
	static int addIdCliente(Scanner in) {
		
		while (true) {
			try {
				System.out.println("Introduce el ID del cliente:");
				return Integer.parseInt(in.nextLine());
			} catch (NumberFormatException e) {
				System.err.println("ID inválido, inténtalo de nuevo");
			}
		}
	}

}

Ejercicio 42

Crea un programa en Java que haga lo siguiente: 1️⃣ Conectarse a la base de datos vivero. 2️⃣ Pedir por consola: ID de un cliente Nueva ciudad 3️⃣ Actualizar en la tabla clientes: El campo ciudad del cliente con ese ID 4️⃣ Usar PreparedStatement con UPDATE. 5️⃣ Mostrar por consola: Número de filas afectadas Mensaje: Si no existe el cliente → avisar Si se actualiza → confirmar cambio 6️⃣ Validar que la ciudad: No esté vacía 7️⃣ Cerrar correctamente recursos y manejar excepciones.

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio42 {

	public static void main(String[] args) {
		
		// Conexión a la base de datos + Scanner (se cierran automáticamente)
		try (Connection cn = DriverManager.getConnection(
				"jdbc:mysql://localhost:3306/vivero",
				"root",
				"*prueba2024*"
		);
		Scanner in = new Scanner(System.in)){
					
			// Pedir datos del cliente (ID + nueva ciudad)
			Cliente cliente = datosCliente(in);
			
			// Ejecutar UPDATE y obtener número de filas afectadas
			int filas = updateCliente(cn, cliente);
			
			// Comprobar resultado
			if(filas == 0) {
				// No existe cliente con ese ID
				System.out.println("El cliente no existe");
				
			} else {
				// Cliente actualizado correctamente
				System.out.println("La ciudad del cliente ha sido actualizada con éxito");
				System.out.println("Filas afectadas: " + filas);
			}
			
		} catch (SQLException e) {
			
			// Error general de base de datos
			System.err.println("Error trabajando con la BBDD, " + e.getMessage());
		}
	}
	
	// Método que realiza el UPDATE en la base de datos
	static int updateCliente(Connection cn, Cliente cliente) throws SQLException {
		
		// Consulta SQL para actualizar la ciudad
		String sql = "UPDATE clientes"
				+ " SET ciudad=?"
				+ " WHERE id=?";
		
		// PreparedStatement para evitar SQL Injection
		try(PreparedStatement psActualizo = cn.prepareStatement(sql)){
			
			// Asignar valores a los parámetros
			psActualizo.setString(1, cliente.getCiudad());
			psActualizo.setInt(2, cliente.getId());
			
			// Ejecutar UPDATE y devolver filas afectadas
			return psActualizo.executeUpdate();
		}
	}
	
	// Método para pedir datos por consola
	static Cliente datosCliente(Scanner in) {
		int id = 0;
		
		// Validar ID (solo números)
		while(true) {
			try {
				System.out.println("Introduce el ID de cliente:");
				id = Integer.parseInt(in.nextLine());
				break;
			
			} catch(NumberFormatException e) {
				System.err.println("Formato de id incorrecto, introdúcelo de nuevo");
			}
		}
		
		String ciudad;
		
		// Validar ciudad (no vacía)
		while(true) {
			System.out.println("Introduce la nueva ciudad del cliente:");
			ciudad = in.nextLine();
			
			if(ciudad.isEmpty()) {
				System.out.println("La nueva ciudad no puede quedar en blanco, introdúcela de nuevo");
			} else {
				// Formatear primera letra en mayúscula
				ciudad = ciudad.substring(0,1).toUpperCase() + ciudad.substring(1);
				break;
			}
		}
		
		// Crear objeto Cliente con los datos introducidos
		return new Cliente(id, ciudad);
	}

	// Clase modelo Cliente
	static class Cliente{
		
		private int id;
		private String nombre;
		private String telefono;
		private String email;
		private String ciudad;
		
		// Constructor completo
		public Cliente(int id, String nombre, String telefono, String email, String ciudad) {
			this.id = id;
			this.nombre = nombre;
			this.telefono = telefono;
			this.email = email;
			this.ciudad = ciudad;
		}

		// Constructor simplificado (solo id + ciudad)
		public Cliente(int id, String ciudad) {
			this.id = id;
			this.ciudad = ciudad;
		}

		public int getId() { return id; }
		public void setId(int id) { this.id = id; }
		public String getNombre() { return nombre; }
		public void setNombre(String nombre) { this.nombre = nombre; }
		public String getTelefono() { return telefono; }
		public void setTelefono(String telefono) { this.telefono = telefono; }
		public String getEmail() { return email; }
		public void setEmail(String email) { this.email = email; }
		public String getCiudad() { return ciudad; }
		public void setCiudad(String ciudad) { this.ciudad = ciudad; }
		
		@Override
		public String toString() {
			return "Cliente [id=" + id + ", nombre=" + nombre + ", telefono=" + telefono + ", email=" + email
					+ ", ciudad=" + ciudad + "]";
		}
	}
}

Ejercicio 43

Crea un programa en Java que haga lo siguiente: 1️⃣ Conectarse a la base de datos vivero. 2️⃣ Mostrar un pequeño menú por consola: 1 → Actualizar teléfono 2 → Actualizar ciudad 3️⃣ Pedir: ID del cliente Según la opción elegida: nuevo teléfono o nueva ciudad 4️⃣ Validar: Teléfono → 9 dígitos numéricos Ciudad → no vacía 5️⃣ Ejecutar un UPDATE con PreparedStatement: Solo actualizar el campo elegido 6️⃣ Mostrar por consola: Si no existe el cliente → avisar Si se actualiza → mostrar filas afectadas y mensaje de éxito 7️⃣ Cerrar recursos correctamente.

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio43 {

	public static void main(String[] args) {
		
		// Try-with-resources para cerrar automáticamente conexión y Scanner
		try (Connection cn = DriverManager.getConnection(
				"jdbc:mysql://localhost:3306/vivero", // URL de la BBDD
				"root",                                // Usuario
				"*prueba2024*"                         // Contraseña
		);
		Scanner in = new Scanner(System.in)){
			
			// Mostrar menú y obtener opción
			int menu = menu(in);
			
			// Pedir ID del cliente
			int idCliente = idCliente(in);
			
			// Pedir y validar el dato a actualizar (teléfono o ciudad)
			String campoTexto = campoTexto(in, menu);
			
			// Ejecutar el UPDATE y mostrar número de filas afectadas
			System.out.println("Se han actualizado " 
					+ updateDatos(cn, menu, campoTexto, idCliente) 
					+ " filas de la BBDD");
			
			
		} catch (SQLException e) {
			
			// Control de errores de base de datos
			System.err.println("Error al trabajar con la BBDD, " + e.getMessage());
		}

	}
	
	// Método que construye y ejecuta el UPDATE según la opción elegida
	static int updateDatos(Connection cn, int menu, String campoTexto, int id) throws SQLException {
		
		String sql = "";
		
		// Selección del campo a actualizar
		switch(menu){
		
		case 1 -> sql = "UPDATE clientes"
				+ " SET telefono=?"
				+ " WHERE id=?";
		
		case 2 -> sql = "UPDATE clientes"
				+ " SET ciudad=?"
				+ " WHERE id=?";
		
		// Si la opción no es válida, lanzar error
		default -> throw new IllegalArgumentException("Opcion invalida");
		}
		
		// Preparar la sentencia SQL
		try(PreparedStatement psActualizo = cn.prepareStatement(sql)){
			
			// Asignar valores a los parámetros
			psActualizo.setString(1, campoTexto);
			psActualizo.setInt(2, id);
			
			// Ejecutar UPDATE y devolver filas afectadas
			return psActualizo.executeUpdate();
			
		} 
		
		
	}
	
	// Método que pide y valida el dato a actualizar
	static String campoTexto(Scanner in, int menu) {
		
		String campo;
		
		while(true) {
			
			// Si se eligió actualizar teléfono
			if(menu == 1) {
				System.out.println("Introduce el nuevo telefono del cliente:(9 cifras)");
				campo = in.nextLine();
				
				// Validación: exactamente 9 dígitos
				if (!campo.matches("\\d{9}")) {
				    System.err.println("Debe tener exactamente 9 números.");
				} else {
				    return campo;
				}
				
			}else {
				
				// Si se eligió actualizar ciudad
				System.out.println("Introduce la nueva ciudad del cliente:");
				campo = in.nextLine();
				
				// Validación: no vacío
				if (campo.isEmpty()) {
				    System.err.println("La ciudad del cliente no puede quedar vacia, introducela de nuevo");
				} else {
				    return campo;
				}
			}
		}
		
	}
	
	// Método para pedir y validar el ID del cliente
	static int idCliente(Scanner in) {
		
		int id = 0;
		
		while(true) {
			try {
				System.out.println("Introduce el ID del cliente:");
				
				// Convertir entrada a entero
				id = Integer.parseInt(in.nextLine());
				return id;
				
			}catch(NumberFormatException e) {
				
				// Error si no es un número válido
				System.err.println("Formato de id incorrecto, introducelo de nuevo");
			}
		}
		
	}
	
	// Método que muestra el menú y valida la opción
	static int menu(Scanner in) {
		
		int menu = 0;
		
		do {
			
			System.out.println("1.Actualizar Telefono.");
			System.out.println("2.Actualizar Ciudad.");
			
			System.out.println("Escoge opcion:");
			
			try {
				menu = Integer.parseInt(in.nextLine());
			
			}catch(NumberFormatException e) {
				
				// Error si no es número
				System.err.println("Formato de menu incorrecto, introducelo de nuevo");
			}
			
		// Repetir hasta que sea opción válida
		}while(menu != 1 && menu != 2);
		
		return menu;
	}

}

Ejercicio 44

1) Conectarse a la base de datos "vivero" 2) Pedir al usuario por consola: - ID de la planta - Nuevo precio - Nuevo stock 3) Validar: - Precio → debe ser mayor que 0 - Stock → debe ser 0 o mayor 4) Comprobar con un SELECT si la planta existe: - Si NO existe: "La planta no existe" y terminar el programa - Si SÍ existe: continuar 5) Ejecutar un UPDATE con PreparedStatement: UPDATE plantas SET precio = ?, stock = ? WHERE id = ? 6) Mostrar por consola: - "Planta actualizada correctamente" - "Filas afectadas: X" 7) Cerrar todos los recursos correctamente

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio44 {

	public static void main(String[] args) {

		// Conexión a la base de datos + Scanner en try-with-resources
		try (Connection cn = DriverManager.getConnection(
				"jdbc:mysql://localhost:3306/vivero",
				"root",
				"*prueba2024*"
		);
		Scanner in = new Scanner(System.in)) {

			// Pedir ID de la planta
			int idPlanta = pedirId(in);

			// Pedir nuevo precio validado
			double nuevoPrecio = nuevoPrecio(in);

			// Pedir nuevo stock validado
			int pedirStock = pedirStock(in);

			// Comprobar si la planta existe antes de actualizar
			if (existePlanta(cn, idPlanta)) {

				// Si existe, se realiza el UPDATE
				actualizarPlanta(cn, idPlanta, nuevoPrecio, pedirStock);

			} else {

				// Si no existe, se informa y se finaliza el flujo
				System.out.println("El ID de la planta no existe, fin del programa...");
			}

		} catch (SQLException e) {

			// Error general de conexión o SQL
			System.err.println("Error al trabajar con la BBDD, " + e.getMessage());
		}
	}

	// Método que actualiza precio y stock de una planta
	static void actualizarPlanta(Connection cn, int idPlanta, double precio, int stock) {

		// SQL UPDATE con parámetros
		String sql = "UPDATE plantas"
				+ " SET precio=?,stock=?"
				+ " WHERE id=?";

		try (PreparedStatement psActualizo = cn.prepareStatement(sql)) {

			// Asignación de parámetros
			psActualizo.setDouble(1, precio);
			psActualizo.setInt(2, stock);
			psActualizo.setInt(3, idPlanta);

			// Ejecución del UPDATE
			int filas = psActualizo.executeUpdate();

			// Mensaje de éxito
			System.out.println("Planta actualizada correctamente");
			System.out.println("Filas afectadas: " + filas);

		} catch (SQLException e) {

			// Error en el UPDATE
			System.err.println("Error al actualizar la BBDD, " + e.getMessage());
		}
	}

	// Método que comprueba si existe la planta en la base de datos
	static boolean existePlanta(Connection cn, int idPlanta) {

		// Consulta mínima para comprobar existencia
		String sql = "SELECT 1 FROM plantas WHERE id=?";

		try (PreparedStatement ps = cn.prepareStatement(sql)) {

			ps.setInt(1, idPlanta);

			try (ResultSet rs = ps.executeQuery()) {

				// Si hay fila → existe
				return rs.next();
			}

		} catch (SQLException e) {

			// Error en la consulta SELECT
			System.err.println("Error al consultar la BBDD, " + e.getMessage());
		}

		// Si falla la consulta, se asume que no existe
		return false;
	}

	// Método para pedir stock con validación (>= 0)
	static int pedirStock(Scanner in) {

		int stock = 0;

		while (true) {
			try {
				System.out.println("Introduce el stock de la planta:");
				stock = Integer.parseInt(in.nextLine());

				// Validación stock válido
				if (stock >= 0) {
					return stock;
				} else {
					System.out.println("El stock debe ser 0 o superior, introdúcelo de nuevo");
				}

			} catch (NumberFormatException e) {

				// Error de formato numérico
				System.err.println("No es un formato de stock válido, introdúcelo de nuevo");
			}
		}
	}

	// Método para pedir precio válido (> 0)
	static double nuevoPrecio(Scanner in) {

		double precio = 0.0;

		while (true) {
			try {
				System.out.println("Introduce el nuevo P.V.P de la planta:");
				precio = Double.parseDouble(in.nextLine());

				// Validación precio válido
				if (precio > 0) {
					return precio;
				} else {
					System.out.println("El P.V.P debe ser mayor de 0, introdúcelo de nuevo");
				}

			} catch (NumberFormatException e) {

				// Error de formato numérico
				System.err.println("No es un formato válido de P.V.P, introdúcelo de nuevo");
			}
		}
	}

	// Método para pedir ID válido
	static int pedirId(Scanner in) {

		int id = 0;

		while (true) {
			try {
				System.out.println("Introduce el ID de la planta:");
				id = Integer.parseInt(in.nextLine());
				return id;

			} catch (NumberFormatException e) {

				// Error si no es número entero
				System.err.println("No es un formato de ID válido, introdúcelo de nuevo");
			}
		}
	}
}

Ejercicio 45

1) Conectarse a la base de datos "vivero" 2) Pedir al usuario por consola: - ID del pedido - Nueva fecha del pedido (YYYY-MM-DD) - Nueva cantidad total del pedido 3) Validar: - Fecha → no puede estar vacía - Cantidad → debe ser mayor que 0 4) Comprobar si el pedido existe: SELECT 1 FROM pedidos WHERE id=? - Si NO existe: "El pedido no existe" terminar programa 5) Ejecutar UPDATE con PreparedStatement: UPDATE pedidos SET fecha = ?, total = ? WHERE id = ? 6) Mostrar por consola: - "Pedido actualizado correctamente" - "Filas afectadas: X" 7) Cerrar todos los recursos correctamente

package jdbc;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.LocalDate;
import java.util.Scanner;

public class Ejercicio45 {

	public static void main(String[] args) {

		// Conexión a la base de datos + Scanner en try-with-resources
		try (Connection cn = DriverManager.getConnection(
				"jdbc:mysql://localhost:3306/vivero",
				"root",
				"*prueba2024*"
		);
		Scanner in = new Scanner(System.in)) {

			// Pedir ID del pedido
			int idPedido = pedirId(in);

			// Pedir fecha del pedido (formato validado)
			Date fecha = pedirFecha(in);

			// Pedir ID del cliente asociado al pedido
			int idCliente = idCliente(in);

			// Comprobar si existe el pedido en la base de datos
			if (existePedido(cn, idPedido)) {

				// Si el pedido existe, comprobar si el cliente existe
				if (existeCliente(cn, idCliente)) {

					// Si ambos existen, se realiza el UPDATE
					int filas = actualizoPedido(cn, idPedido, fecha, idCliente);

					// Comprobar resultado de la actualización
					if (filas == 0) {
						System.out.println("No se realizo la actualizacion de pedido");
					} else {
						System.out.println("Pedido actualizado correctamente");
						System.out.println("Filas afectadas: " + filas);
					}

				} else {
					// Cliente no existe
					System.out.println("El cliente no existe fin del programa...");
				}

			} else {
				// Pedido no existe
				System.out.println("El pedido no existe fin del programa...");
			}

		} catch (SQLException e) {

			// Error general de base de datos
			System.err.println("Error al trabajar con la BBDD, " + e.getMessage());
		}
	}

	// Método que ejecuta el UPDATE del pedido
	static int actualizoPedido(Connection cn, int idPedido, Date fecha, int idCliente) throws SQLException {

		// SQL de actualización del pedido
		String sql = "UPDATE pedidos"
				+ " SET fecha=?,cliente_id=?"
				+ " WHERE id=?";

		try (PreparedStatement psActualizo = cn.prepareStatement(sql)) {

			// Asignación de parámetros
			psActualizo.setDate(1, fecha);
			psActualizo.setInt(2, idCliente);
			psActualizo.setInt(3, idPedido);

			// Ejecución del UPDATE
			return psActualizo.executeUpdate();
		}
	}

	// Comprueba si existe el cliente en la BBDD
	static boolean existeCliente(Connection cn, int idCliente) {

		String sql = "SELECT 1 FROM clientes WHERE id=?";

		try (PreparedStatement psBusco = cn.prepareStatement(sql)) {

			psBusco.setInt(1, idCliente);

			try (ResultSet rsBusco = psBusco.executeQuery()) {

				// Si hay resultado → existe
				return rsBusco.next();
			}

		} catch (SQLException e) {

			System.err.println("Error al trabajar con la tabla clientes, " + e.getMessage());
		}

		return false;
	}

	// Comprueba si existe el pedido en la BBDD
	static boolean existePedido(Connection cn, int idPedido) {

		String sql = "SELECT 1 FROM pedidos WHERE id=?";

		try (PreparedStatement psBusco = cn.prepareStatement(sql)) {

			psBusco.setInt(1, idPedido);

			try (ResultSet rsBusco = psBusco.executeQuery()) {

				// Si hay resultado → existe
				return rsBusco.next();
			}

		} catch (SQLException e) {

			System.err.println("Error al trabajar con la tabla Pedidos, " + e.getMessage());
		}

		return false;
	}

	// Pide y valida ID del cliente
	static int idCliente(Scanner in) {

		int id = 0;

		while (true) {
			try {
				System.out.println("Introduce el ID del cliente:");
				id = Integer.parseInt(in.nextLine());

				if (id < 0) {
					System.out.println("El ID no puede ser menor que 0, introducelo de nuevo");
				} else {
					return id;
				}

			} catch (NumberFormatException e) {

				System.err.println("Formato de Id de cliente no valido, introducelo de nuevo");
			}
		}
	}

	// Pide fecha usando LocalDate (validación automática)
	static Date pedirFecha(Scanner in) {

		while (true) {
			try {
				System.out.println("Introduce la fecha (YYYY-MM-DD):");

				String texto = in.nextLine();

				// Convierte String a LocalDate (valida automáticamente formato y fecha real)
				LocalDate localDate = LocalDate.parse(texto);

				// Conversión a java.sql.Date para JDBC
				return Date.valueOf(localDate);

			} catch (Exception e) {

				System.err.println("Fecha inválida, formato correcto: YYYY-MM-DD");
			}
		}
	}

	// Pide y valida ID del pedido
	static int pedirId(Scanner in) {

		int idPedido = 0;

		while (true) {
			try {
				System.out.println("Introduce el ID del pedido:");
				idPedido = Integer.parseInt(in.nextLine());

				if (idPedido < 0) {
					System.out.println("El ID de pedido no puede ser menor que 0, introducelo de nuevo.");
				} else {
					return idPedido;
				}

			} catch (NumberFormatException e) {

				System.err.println("Formato de id no valido, introducelo de nuevo.");
			}
		}
	}
}

Ejercicio 46

Crea un programa en Java que haga lo siguiente: 1️⃣ Se conecte a la base de datos vivero. 2️⃣ Pida al usuario por consola: ID de la categoría a eliminar 3️⃣ Ejecute un DELETE sobre la tabla categorias: Eliminar la categoría cuyo id_categoria coincida 4️⃣ Muestre por pantalla: "Categoría eliminada correctamente" → si se ha borrado alguna fila "No existe una categoría con ese ID" → si no se ha borrado ninguna 🔧 Condiciones Usa PreparedStatement Usa executeUpdate() No hace falta validar nada más (ni comprobar antes con SELECT)

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio46 {

    public static void main(String[] args) {
        // Abrimos conexión con la base de datos y Scanner para leer por consola
        try (Connection cn = DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/vivero", // URL de conexión
                "root",                              // Usuario
                "*prueba2024*"                        // Contraseña
        );
             Scanner in = new Scanner(System.in)) {

            // Pedimos al usuario el ID de la categoría a eliminar
            int idCategoria = pedirId(in);

            // Llamamos al método que intenta borrar la categoría
            // Si devuelve != 0 → se borró al menos una fila
            if (borrarCategoria(cn, idCategoria) != 0) {
                System.out.println("Categoría eliminada correctamente");
            } else {
                System.out.println("No existe una categoría con ese ID");
            }

        } catch (SQLException e) {
            // Captura errores de conexión o SQL
            System.err.println("Error al trabajar con la BBDD, " + e.getMessage());
        }
    }

    // Método que ejecuta el DELETE en la tabla categorias
    static int borrarCategoria(Connection cn, int idCategoria) {
        // Sentencia SQL con parámetro para PreparedStatement
        String sql = "DELETE FROM categorias WHERE id=?";

        int filas = 0; // Guardará el número de filas afectadas

        try (PreparedStatement psBorro = cn.prepareStatement(sql)) {

            // Sustituimos el parámetro "?" por el idCategoria recibido
            psBorro.setInt(1, idCategoria);

            // Ejecutamos el DELETE y obtenemos el número de filas afectadas
            filas = psBorro.executeUpdate();

            return filas;

        } catch (SQLException e) {
            // Captura errores específicos al intentar borrar
            System.err.println("Error al borrar de la tabla categorias.(" + e.getMessage() + ")");
        }

        return filas; // Si hay error, devuelve 0 filas borradas
    }

    // Método que pide al usuario un ID válido por consola
    static int pedirId(Scanner in) {
        int idCategoria = 0;

        while (true) {
            try {
                System.out.println("Introduce el ID de la categoria a borrar:");
                idCategoria = Integer.parseInt(in.nextLine());

                // Validación simple: el ID no puede ser negativo
                if (idCategoria < 0) {
                    System.out.println("El ID de categoria tiene que ser al menos mayor que 0, introducelo de nuevo.");
                } else {
                    return idCategoria; // ID válido, lo devolvemos
                }
            } catch (NumberFormatException e) {
                // Captura errores si no se introduce un número entero
                System.err.println("Formato de ID no valido, introducelo de nuevo.(" + e.getMessage() + ")");
            }
        }
    }

}

Ejercicio 47

Crea un programa en Java que haga lo siguiente: 1️⃣ Conectarse a la base de datos "vivero". 2️⃣ Pedir al usuario por consola: - ID de la categoría a eliminar 3️⃣ Comprobar si existen plantas asociadas a esa categoría: - Ejecutar un SELECT en la tabla "plantas" usando "categoria_id" - Si existen plantas → mostrar: "No se puede eliminar la categoría porque tiene plantas asociadas" - Si no existen → continuar 4️⃣ Ejecutar un DELETE en la tabla "categorias" para eliminar la categoría cuyo id coincida 5️⃣ Mostrar por pantalla: - "Categoría eliminada correctamente" → si se borró alguna fila - "No existe una categoría con ese ID" → si no se borró ninguna 🔧 Condiciones: - Usar PreparedStatement - Usar executeQuery() para la comprobación - Usar executeUpdate() para el DELETE - Validar que el ID introducido sea un número entero positivo

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio47 {

    public static void main(String[] args) {

        // 1️⃣ Conexión a la base de datos y Scanner para leer por consola
        try (Connection cn = DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/vivero", // URL de conexión
                "root",                               // Usuario
                "*prueba2024*"                        // Contraseña
        );
             Scanner in = new Scanner(System.in)) {

            // 2️⃣ Pedir al usuario el ID de la categoría a eliminar
            int idCategoria = pedirCategoria(in);

            // 3️⃣ Comprobar si existen plantas asociadas a esa categoría
            if (comprobarIntegridad(cn, idCategoria)) {
                System.out.println("No se puede eliminar la categoría porque tiene plantas asociadas");
            } else {
                // 4️⃣ Intentar borrar la categoría si no hay plantas asociadas
                if (borrarCategoria(cn, idCategoria) == 0) {
                    System.out.println("No existe una categoría con ese ID");
                } else {
                    System.out.println("Categoría eliminada correctamente");
                }
            }

        } catch (SQLException e) {
            System.err.println("Error al conectar a la BBDD, (" + e.getMessage() + ")");
        }
    }

    // Método para borrar la categoría por ID
    static int borrarCategoria(Connection cn, int idCategoria) {
        String sql = "DELETE FROM categorias WHERE id=?"; // SQL DELETE
        int filas = 0;

        try (PreparedStatement psBorro = cn.prepareStatement(sql)) {
            psBorro.setInt(1, idCategoria);   // Sustituir '?' por el ID
            filas = psBorro.executeUpdate();   // Ejecutar el DELETE y obtener número de filas afectadas
            return filas;

        } catch (SQLException e) {
            System.err.println("Error al borrar categoría de la BBDD, (" + e.getMessage() + ")");
        }

        return filas;
    }

    // Método para comprobar si existen plantas asociadas a la categoría
    static boolean comprobarIntegridad(Connection cn, int idCategoria) {
        String sql = "SELECT 1 FROM plantas WHERE categoria_id=?";

        try (PreparedStatement psBusco = cn.prepareStatement(sql)) {
            psBusco.setInt(1, idCategoria);   // Sustituir '?' por el ID

            try (ResultSet rsBusco = psBusco.executeQuery()) {
                return rsBusco.next();        // True si hay al menos una planta
            }

        } catch (SQLException e) {
            System.err.println("Error al trabajar con la tabla plantas de la BBDD, (" + e.getMessage() + ")");
        }

        return false; // Si hay error, asumimos que no hay plantas
    }

    // Método para pedir al usuario un ID válido (entero positivo)
    static int pedirCategoria(Scanner in) {
        int idCategoria;

        while (true) {
            try {
                System.out.println("Introduce el ID de la categoria a borrar:");
                idCategoria = Integer.parseInt(in.nextLine());

                if (idCategoria < 0) {
                    System.out.println("El ID de la categoria debe ser mayor que 0, introducelo de nuevo");
                } else {
                    return idCategoria;
                }

            } catch (NumberFormatException e) {
                System.err.println("Formato de Id incorrecto, introducelo de nuevo.");
            }
        }
    }

}

Ejercicio 48

Perfecto, siguiente paso 👇 subimos un poco más pero sin meternos aún en transacciones. 🟠 Ejercicio JDBC — DELETE con confirmación + datos previos Crea un programa en Java que haga lo siguiente: 1️⃣ Conectarse a la base de datos "vivero". 2️⃣ Pedir al usuario por consola: - ID de la planta a eliminar 3️⃣ Comprobar si la planta existe: - Hacer un SELECT en la tabla "plantas" - Si no existe → mostrar: "No existe una planta con ese ID" y terminar el programa 4️⃣ Si existe, mostrar sus datos: - nombre - precio - stock 5️⃣ Pedir confirmación al usuario: - "¿Seguro que quieres eliminar esta planta? (s/n)" 6️⃣ Si el usuario responde "s": - Ejecutar un DELETE en la tabla "plantas" 7️⃣ Mostrar por pantalla: - "Planta eliminada correctamente" → si se borró - "Operación cancelada" → si el usuario dijo que no

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio48 {

    public static void main(String[] args) {

        // Abrimos conexión con la BBDD y Scanner para entrada por consola
        try (Connection cn = DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/vivero",
                "root",
                "*prueba2024*"
        );
        Scanner in = new Scanner(System.in)) {

            // Pedimos el ID de la planta al usuario
            int idPlanta = pedirIdPlanta(in);

            // Comprobamos si la planta existe (y mostramos sus datos)
            if (!comprobarPlanta(cn, idPlanta)) {
                System.out.println("No existe una planta con ese ID. Finalizando programa...");
            } else {

                // Pedimos confirmación antes de borrar
                if (pedirConfirmacion(in)) {
                    borrarPlanta(cn, idPlanta);
                } else {
                    System.out.println("Operacion cancelada. Fin del programa...");
                }
            }

        } catch (SQLException e) {
            // Error general de conexión o SQL
            System.err.println("Error al trabajar con la BBDD, (" + e.getMessage() + ")");
        }
    }

    // Método que elimina una planta por su ID
    static void borrarPlanta(Connection cn, int idPlanta) {

        // Sentencia DELETE parametrizada
        String sql = "DELETE FROM plantas WHERE id=?";
        int filas = 0;

        try (PreparedStatement psBorro = cn.prepareStatement(sql)) {

            // Sustituimos el parámetro "?" por el ID de la planta
            psBorro.setInt(1, idPlanta);

            // Ejecutamos el DELETE y obtenemos el número de filas afectadas
            filas = psBorro.executeUpdate();

            // Si se ha borrado alguna fila → OK
            if (filas != 0) {
                System.out.println("Planta eliminada correctamente");
            } else {
                // En teoría no debería pasar porque ya comprobamos antes
                System.out.println("Error al eliminar la planta");
            }

        } catch (SQLException e) {
            // Puede fallar por claves foráneas (por ejemplo, si está en pedidos)
            System.err.println("Error al eliminar la planta. (" + e.getMessage() + ")");
        }
    }

    // Método para pedir confirmación al usuario (s/n)
    static boolean pedirConfirmacion(Scanner in) {

        char confirmacion = ' ';

        while (true) {
            System.out.println("¿Estas seguro que quieres eliminar esta planta?(s/n)");

            // Leemos la respuesta y nos quedamos con el primer carácter en minúscula
            confirmacion = in.next().toLowerCase().charAt(0);

            // Validamos que sea 's' o 'n'
            if (confirmacion != 's' && confirmacion != 'n') {
                System.out.println("La respuesta debe de ser (s)i ó (n)o, introducela de nuevo");
            } else {
                // Devolvemos true si es 's', false si es 'n'
                if (confirmacion == 's') {
                    return true;
                } else {
                    return false;
                }
            }
        }
    }

    // Método que comprueba si la planta existe y muestra sus datos
    static boolean comprobarPlanta(Connection cn, int idPlanta) {

        // SELECT para obtener datos de la planta
        String sql = "SELECT nombre,precio,stock FROM plantas WHERE id=?";

        try (PreparedStatement psBusco = cn.prepareStatement(sql)) {

            // Sustituimos el parámetro "?" por el ID
            psBusco.setInt(1, idPlanta);

            try (ResultSet rsBusco = psBusco.executeQuery()) {

                // Si existe la planta (hay al menos una fila)
                if (rsBusco.next()) {

                    // Mostramos sus datos por pantalla
                    System.out.println("Nombre -> " + rsBusco.getString("nombre"));
                    System.out.println("P.V.P -> " + String.format("%.2f€", rsBusco.getDouble("precio")));
                    System.out.println("Stock -> " + rsBusco.getInt("stock") + " unidades");

                    return true;
                }
            }

        } catch (SQLException e) {
            System.err.println("Error al trabajar con la tabla plantas de la BBDD, (" + e.getMessage() + ")");
        }

        // Si no hay resultados → la planta no existe
        return false;
    }

    // Método que pide un ID válido al usuario (entero positivo)
    static int pedirIdPlanta(Scanner in) {
        int idPlanta = 0;

        while (true) {
            try {
                System.out.println("Introduce el ID de la planta a eliminar:");
                idPlanta = Integer.parseInt(in.nextLine());

                // Validamos que el ID sea mayor que 0
                if (idPlanta < 1) {
                    System.out.println("El ID de la planta debe ser mayor que 0");
                } else {
                    return idPlanta;
                }

            } catch (NumberFormatException e) {
                // Error si el usuario no introduce un número
                System.out.println("Formato de ID no valido, introducelo de nuevo");
            }
        }
    }
}

Ejercicio 49

Ejercicio: Gestión de eliminación de plantas y pedidos asociados en la base de datos vivero. Conéctate a la base de datos vivero con usuario root y contraseña *prueba2024*. Desactiva el autoCommit para controlar manualmente las transacciones. Solicita al usuario el ID de la planta que desea eliminar. Comprueba si la planta existe en la tabla plantas. Si no existe, muestra un mensaje y finaliza el programa. Comprueba si la planta está asociada a algún pedido en la tabla detalle_pedido. Si no hay detalles asociados, borra directamente la planta. Si hay detalles asociados: Muestra un mensaje indicando que la planta está asociada a pedidos. Pregunta al usuario si desea eliminar también los pedidos asociados que solo contengan esa planta. Si el usuario responde que no, cancela la operación. Si el usuario confirma: Borra de detalle_pedido todos los registros asociados a la planta. Borra los pedidos completos que solo contengan esa planta. Borra finalmente la planta de la tabla plantas. Confirma la transacción (commit). En caso de cualquier error durante el proceso, realiza un rollback para deshacer todos los cambios. Cierra correctamente la conexión con la base de datos. Cada método que puede producir un error (SQLException) lanza la excepción, dejando que la transacción y el manejo de errores se gestionen desde main. Notas adicionales: Se deben usar métodos auxiliares para: Comprobar la existencia de la planta (comprobarPlanta). Comprobar si hay detalles asociados (comprobarDetalle). Borrar detalles y pedidos asociados (borrarDetalle, borroPedido). Borrar la planta (borrarPlanta). Se debe validar la entrada del usuario, asegurándose de que el ID sea un número entero mayor que 0. Se debe mantener interacción con el usuario mediante mensajes claros en consola.

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Scanner;

public class Ejercicio49 {

	public static void main(String[] args) {

	    Connection cn = null;
	    try {
	        cn = DriverManager.getConnection(
	            "jdbc:mysql://localhost:3306/vivero",
	            "root",
	            "*prueba2024*"
	        );
	        cn.setAutoCommit(false); // desactivamos autoCommit para control manual de la transacción

	        try (Scanner in = new Scanner(System.in)) {
	            int idPlanta = pedirIdPlanta(in);

	            if (!comprobarPlanta(cn, idPlanta)) {
	                System.out.println("No existe una planta con ese ID. Finalizando programa...");
	            } else {
	                if (comprobarDetalle(cn, idPlanta)) {
	                    System.out.println("La planta está asociada a pedidos");
	                    if (!confirmacionBorrado(in)) {
	                        System.out.println("Operación cancelada");
	                    } else {
	                        // Borra detalles y pedidos asociados
	                        int filasDetalle = borrarDetalle(cn, idPlanta);
	                        if (filasDetalle == 0) {
	                            System.out.println("No había detalles de pedido sobre esa planta");
	                        }
	                        // Borra la planta
	                        borrarPlanta(cn, idPlanta);
	                    }
	                } else {
	                    // Si no hay detalles asociados, borramos la planta directamente
	                    borrarPlanta(cn, idPlanta);
	                }
	            }

	            cn.commit(); // confirmamos todos los cambios
	        }

	    } catch (SQLException e) {
	        // Si ocurre cualquier error, hacemos rollback
	        if (cn != null) {
	            try {
	                cn.rollback();
	                System.err.println("Transacción deshecha debido a un error.");
	            } catch (SQLException ex) {
	                System.err.println("Error al hacer rollback: " + ex.getMessage());
	            }
	        }
	        System.err.println("Error al trabajar con la BBDD: " + e.getMessage());
	    } finally {
	        if (cn != null) {
	            try {
	                cn.close();
	            } catch (SQLException e) {
	                System.err.println("Error al cerrar la conexión: " + e.getMessage());
	            }
	        }
	    }

	}

	// Devuelve los pedidos que solo contienen la planta a borrar
	static ArrayList<Integer> listaPedidosBorrar(Connection cn, int plantaId) throws SQLException {
		ArrayList<Integer> listaPedidos = new ArrayList<>();
		
		String sql = "SELECT pedido_id, COUNT(pedido_id) AS filas "
				+ "FROM detalle_pedido "
				+ "WHERE planta_id=? "
				+ "GROUP BY pedido_id "
				+ "HAVING COUNT(pedido_id) = ?";
		
		try (PreparedStatement psLista = cn.prepareStatement(sql)) {
			psLista.setInt(1, plantaId);
			psLista.setInt(2, 1);
			
			try (ResultSet rsLista = psLista.executeQuery()) {
				while (rsLista.next()) {
					listaPedidos.add(rsLista.getInt("pedido_id"));
				}
			}
		}
		
		return listaPedidos;
	}

	// Borra pedidos de la lista
	static void borroPedido(Connection cn, ArrayList<Integer> listaPedidos, int idPlanta) throws SQLException {
		String sql = "DELETE FROM pedidos WHERE id=?";
		
		try (PreparedStatement psBorro = cn.prepareStatement(sql)) {
			for (Integer idPedido : listaPedidos) {
				psBorro.setInt(1, idPedido);
				psBorro.addBatch();
			}
			psBorro.executeBatch();
		}
		
		System.out.println("Pedidos que solo tenían el código de planta " + idPlanta + " eliminados");
	}

	// Borra los detalles y pedidos asociados
	static int borrarDetalle(Connection cn, int idPlanta) throws SQLException {
		ArrayList<Integer> listaPedidos = listaPedidosBorrar(cn, idPlanta);
		
		String sql = "DELETE FROM detalle_pedido WHERE planta_id=?";
		int filas;
		
		try (PreparedStatement psBorro = cn.prepareStatement(sql)) {
			psBorro.setInt(1, idPlanta);
			filas = psBorro.executeUpdate();
		}
		
		if (!listaPedidos.isEmpty()) {
			borroPedido(cn, listaPedidos, idPlanta);
		}
		
		return filas;
	}

	// Pide confirmación al usuario
	static boolean confirmacionBorrado(Scanner in) {
		char respuesta;
		while (true) {
			System.out.println("¿Quieres eliminar también los registros asociados? (s/n)");
			respuesta = in.next().toLowerCase().charAt(0);
			if (respuesta == 's') return true;
			if (respuesta == 'n') return false;
			System.out.println("La respuesta tiene que ser (s)i ó (n)o, introdúcela de nuevo");
		}
	}

	// Borra la planta
	static void borrarPlanta(Connection cn, int idPlanta) throws SQLException {
		String sql = "DELETE FROM plantas WHERE id=?";
		
		try (PreparedStatement psBorro = cn.prepareStatement(sql)) {
			psBorro.setInt(1, idPlanta);
			int filas = psBorro.executeUpdate();
			if (filas != 0) System.out.println("Planta eliminada correctamente");
			else System.out.println("Error al intentar borrar la planta por ID");
		}
	}

	// Comprueba si hay detalles asociados
	static boolean comprobarDetalle(Connection cn, int idPlanta) throws SQLException {
		String sql = "SELECT 1 FROM detalle_pedido WHERE planta_id=?";
		try (PreparedStatement psBusco = cn.prepareStatement(sql)) {
			psBusco.setInt(1, idPlanta);
			try (ResultSet rsBusco = psBusco.executeQuery()) {
				return rsBusco.next();
			}
		}
	}

	// Comprueba si la planta existe
	static boolean comprobarPlanta(Connection cn, int idPlanta) throws SQLException {
		String sql = "SELECT 1 FROM plantas WHERE id=?";
		try (PreparedStatement psBusco = cn.prepareStatement(sql)) {
			psBusco.setInt(1, idPlanta);
			try (ResultSet rsBusco = psBusco.executeQuery()) {
				return rsBusco.next();
			}
		}
	}

	// Pide el ID de la planta al usuario
	static int pedirIdPlanta(Scanner in) {
		int idPlanta;
		while (true) {
			try {
				System.out.println("Introduce el ID de la planta a eliminar:");
				idPlanta = Integer.parseInt(in.nextLine());
				if (idPlanta > 0) return idPlanta;
				System.out.println("No es un ID válido, debe ser mayor que 0.");
			} catch (NumberFormatException e) {
				System.out.println("Formato de ID no válido, introdúcelo de nuevo");
			}
		}
	}
}

Ejercicio 50

Crea un programa en Java con JDBC que haga lo siguiente: 1️⃣ Conectarse a la base de datos vivero. 2️⃣ Desactivar el autocommit de la conexión para poder controlar la transacción manualmente. 3️⃣ Pedir al usuario por consola: Cuántos pedidos desea eliminar. 4️⃣ Para cada pedido pedir: ID del pedido a eliminar 5️⃣ Antes de añadir el borrado al lote (batch): Validar que el ID sea mayor que 0. 6️⃣ Preparar una sentencia SQL: DELETE FROM pedidos WHERE id = ? 7️⃣ Usar PreparedStatement y añadir cada eliminación al batch con: addBatch() 8️⃣ Ejecutar todas las eliminaciones juntas usando: executeBatch() 9️⃣ Mostrar por pantalla: Cuántos pedidos fueron eliminados. 10️⃣ Después de ejecutar el batch preguntar al usuario: ¿Desea confirmar los cambios? (S/N) Si responde S → hacer commit() Si responde N → hacer rollback() 11️⃣ Si ocurre cualquier error durante el proceso: Capturar la excepción Hacer rollback() Mostrar un mensaje indicando que la operación fue cancelada. 12️⃣ Cerrar correctamente: ResultSet (si se usa) PreparedStatement Connection

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Scanner;

public class Ejercicio50 {

	public static void main(String[] args) {
		
		// Objeto Connection para conectarse a la base de datos
		Connection cn=null;
		try {
			
			// Se establece la conexión con la base de datos MySQL
	        cn = DriverManager.getConnection(
	            "jdbc:mysql://localhost:3306/vivero",
	            "root",
	            "*prueba2024*"
	        );
	        
	        // Se desactiva el autocommit para controlar manualmente la transacción
	        cn.setAutoCommit(false); 

	        // Scanner para leer datos introducidos por el usuario
	        try (Scanner in = new Scanner(System.in)){
	        	
	        	// Se pide al usuario cuántos pedidos quiere borrar
	        	int numPedidos=pedirCantidadPedidos(in);
	        	
	        	// Si el usuario introduce 0 se cancela la operación
	        	if(numPedidos!=0) {
	        		
	        		// Se crea un array para almacenar los IDs de pedidos a borrar
	        		int[] listaPedidosId=new int [numPedidos];
	        		
	        		// Se rellenan los IDs introducidos por el usuario
	        		listaPedidosId=pedirIdPedido(in,numPedidos);
	        		
	        		// Se llama al método que realiza los borrados en la base de datos
	        		int[] pedidosBorrados=borrarPedidos(cn,listaPedidosId);
	        		
	        		// Variable para contar cuántos pedidos realmente fueron eliminados
	        		int count=0;
	        		
	        		// El array devuelto por executeBatch indica cuántas filas afectó cada DELETE
	        		for (int i : pedidosBorrados) {
						if(i!=0) {
							count++;
						}
					}
	        		
	        		// Mensaje dependiendo de cuántos pedidos se eliminaron
	        		if(count==0) {
	        			System.out.println("Ningun pedido ha sido borrado.");
	        			cn.rollback();
	        		}else if(count == 1) {
	        			System.out.println("Un pedido será borrado.");
	        			
	        		}else {
	        			System.out.println(count + " pedidos serán borrados.");
	        			
	        		}
	        		
	        		// Se pide confirmación al usuario antes de confirmar la transacción
	        		if(confirmacionBorrado(in)) {
	        			
	        			// Si el usuario confirma se guarda definitivamente en la base de datos
	        			cn.commit();
	        			System.out.println("La operacion de borrado se ha realizado con exito");
	        			
	        		}else {
	        			
	        			// Si el usuario cancela se deshacen todos los cambios
	        			cn.rollback();
	        			System.out.println("Operacion de borrado cancelada.");
	        		}
	        	
	        	}else {
	        		// Si el usuario introduce 0 se cancela el proceso
	        		System.out.println("Operacion de borrado de pedidos cancelada. Finalizando programa..");
	        	}
	        	
	        	
	        }
	        
		// Captura de errores relacionados con la base de datos
		}catch(SQLException e){
			
			// Si ocurre un error se intenta deshacer la transacción
			if (cn != null) {
	            try {
	                cn.rollback();
	                System.err.println("Transacción deshecha debido a un error.");
	            } catch (SQLException ex) {
	                System.err.println("Error al hacer rollback: " + ex.getMessage());
	            }
	        }
			
			// Mensaje del error producido
	        System.err.println("Error al trabajar con la BBDD: " + e.getMessage());
	        
		// Bloque finally para cerrar siempre la conexión
		}finally {
			if (cn != null) {
	            try {
	                cn.close();
	            } catch (SQLException e) {
	                System.err.println("Error al cerrar la conexión: " + e.getMessage());
	            }
	        }
		}

	}
	
	// Método que pide confirmación al usuario antes de realizar el borrado definitivo
	static boolean confirmacionBorrado(Scanner in) {
		char respuesta=' ';
		
		while(true) {
			
			// Se solicita al usuario confirmar la operación
			System.out.print("¿Esta seguro que desea eliminar los pedidos (s)i/(n)o?");
			respuesta=in.nextLine().toLowerCase().charAt(0);
			
			// Si responde 's' se confirma la operación
			if(respuesta=='s') return true;
			
			// Si responde 'n' se cancela
			if(respuesta=='n') return false;
			
			// Si introduce otro valor se vuelve a pedir
			System.out.println("La respuesta debe ser (s)i ó (n)o, introducela de nuevo.");
		}
	}
	
	// Método que realiza el borrado en la base de datos usando batch
	static int[] borrarPedidos(Connection cn,int[] listaPedidosId) throws SQLException {
		
		// SQL para borrar primero los detalles del pedido (tabla dependiente)
		String sql="DELETE"
				+ " FROM detalle_pedido"
				+ " WHERE pedido_id=?";
		
		// Array que almacenará el resultado del batch de borrado de pedidos
		int[] pedidosBorrados;
		
		// PreparedStatement para borrar los registros de detalle_pedido
		try(PreparedStatement psBorroDetalle=cn.prepareStatement(sql)){
			
			// Se añade cada ID al batch
			for (int id : listaPedidosId) {
				psBorroDetalle.setInt(1, id);
				psBorroDetalle.addBatch();
			}
			
			// Se ejecutan todos los DELETE de detalle_pedido
			psBorroDetalle.executeBatch();
			
		}
		
			// SQL para borrar ahora los pedidos
			sql="DELETE"
				+ " FROM pedidos"
				+ " WHERE id=?";
		
		// PreparedStatement para borrar los pedidos
		try(PreparedStatement psBorroPedido=cn.prepareStatement(sql)){
			
			// Se añaden los DELETE al batch
			for (int id : listaPedidosId) {
				psBorroPedido.setInt(1, id);
				psBorroPedido.addBatch();
			}
			
			// Se ejecuta el batch y se guarda el resultado
			pedidosBorrados=psBorroPedido.executeBatch();
			
		}
		
		// Se devuelve el resultado del batch
		return pedidosBorrados;
	}
	
	// Método que pide al usuario los IDs de los pedidos que quiere eliminar
	static int[] pedirIdPedido(Scanner in, int numPedidos) {
		
		// Array para almacenar los IDs introducidos
		int[] listaPedidosId=new int [numPedidos];
		int numPedido=0;
		
		// Bucle para pedir todos los IDs necesarios
		for (int i=0;i<listaPedidosId.length;i++) {
			while(true) {
				try {
					
					// Se solicita el ID del pedido
					System.out.print("Introduce el ID del pedido:(" + (i+1) + "/" + listaPedidosId.length +")");
					numPedido=Integer.parseInt(in.nextLine());
					
					// Validación: el ID debe ser mayor que 0
					if(numPedido<1) {
						System.out.println("No es un valor valido para ID, debe ser mayor que 0, introducelo de nuevo");
					}else {
						
						// Se guarda el ID en el array
						listaPedidosId[i]=numPedido;
						break;
					}
					
				}catch(NumberFormatException e) {
					
					// Si el usuario introduce algo que no es número
					System.err.println("Formato de valor de ID no valido, introducelo de nuevo.");
				}
			}
		}
		
		return listaPedidosId;
	}
	
	// Método que pide al usuario cuántos pedidos desea borrar
	static int pedirCantidadPedidos(Scanner in) {
		
		int numPedidos=0;
		
		while(true) {
			try {
				
				// Se solicita el número de pedidos a eliminar
				System.out.print("Introduce el numero de pedidos que quieres borrar:");
				numPedidos=Integer.parseInt(in.nextLine());
				
				// Validación: no puede ser negativo
				if(numPedidos<0) {
					System.out.println("El numero de pedidos no puede ser menor que 1, 0 para abortar ó un numero positivo para borrar, introducelo de nuevo");
				}else {
					return numPedidos;
				}
					
			}catch(NumberFormatException e) {
				
				// Si el usuario introduce texto u otro formato inválido
				System.out.println("Formato de cantidad de pedidos no valido, introducelo de nuevo.");
			}
		}
	}

}