Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- import java.io.InputStreamReader;
- import java.sql.*;
- import java.util.ArrayList;
- import java.util.LinkedList;
- import java.io.BufferedReader;
- import java.io.FileReader;
- import java.util.Scanner;
- public class Diagnostico {
- private final String DATAFILE = "data/disease_data.data";
- private Connection connection = null;
- private void showMenu() {
- int option = -1;
- do {
- System.out.println("Bienvenido a sistema de diagnóstico\n");
- System.out.println("Selecciona una opción:\n");
- System.out.println("\t1. Creación de base de datos y carga de datos.");
- System.out.println("\t2. Realizar diagnóstico.");
- System.out.println("\t3. Listar síntomas de una enfermedad.");
- System.out.println("\t4. Listar enfermedades y sus códigos asociados.");
- System.out.println("\t5. Listar síntomas existentes en la BD y su tipo semántico.");
- System.out.println("\t6. Mostrar estadísticas de la base de datos.");
- System.out.println("\t7. Salir.");
- try {
- option = readInt();
- switch (option) {
- case 1:
- crearBD();
- break;
- case 2:
- realizarDiagnostico();
- break;
- case 3:
- listarSintomasEnfermedad();
- break;
- case 4:
- listarEnfermedadesYCodigosAsociados();
- break;
- case 5:
- listarSintomasYTiposSemanticos();
- break;
- case 6:
- mostrarEstadisticasBD();
- break;
- case 7:
- exit();
- break;
- }
- } catch (Exception e) {
- System.err.println("Opción introducida no válida!");
- e.printStackTrace();
- }
- } while (option != 7);
- exit();
- }
- private void exit() {
- try {
- connection.close();
- System.out.println("Saliendo... ¡hasta otra!");
- } catch (SQLException e) {
- e.printStackTrace();
- }
- System.exit(0);
- }
- /**
- * Método para establecer conexión con la base de datos.
- *
- * @throws Exception Puede lanzar excepción.
- */
- private void conectar(String database) throws Exception {
- if (connection == null) {
- try {
- Class.forName("com.mysql.jdbc.Driver");
- connection = DriverManager.getConnection(
- "jdbc:mysql://localhost:3306/" + database,
- "root",
- "");
- } catch (Exception e) {
- System.out.println("Error al conectarse a la base de datos: ");
- e.printStackTrace();
- }
- }
- }
- /**
- * Método para comprobar si la base de datos "diagnostico" existe.
- *
- * @throws Exception Puede lanzar excepción.
- */
- private boolean existeDB() throws Exception {
- boolean ret = false;
- ResultSet r = connection.getMetaData().getCatalogs();
- while (r.next()) {
- if (r.getString(1).equalsIgnoreCase("diagnostico")) {
- ret = true;
- }
- }
- return ret;
- }
- /**
- * Método para crear la base de datos, tablas e importar datos.
- *
- * @throws Exception Puede lanzar alguna excepción, en cuyo caso,
- * hace ROLLBACK y elimina las tablas y base de datos creadas.
- */
- private void crearBD() {
- /*
- * Se conecta con JDBC a través del método conectar(). Acto seguido,
- * se procede a crear la base de datos y las tablas para dejar paso
- * a importación de datos posteriormente.
- */
- try {
- conectar("");
- if (!existeDB()) {
- LinkedList<String> archivo = readData();
- ArrayList<String> sentenciasSQL = new ArrayList<>();
- sentenciasSQL.add("CREATE DATABASE diagnostico;");
- sentenciasSQL.add("USE diagnostico;");
- sentenciasSQL.add("CREATE TABLE disease (" +
- "disease_id INT AUTO_INCREMENT, " +
- "name VARCHAR(255), " +
- "PRIMARY KEY (disease_id)" +
- ");");
- sentenciasSQL.add("CREATE TABLE source (" +
- "source_id INT AUTO_INCREMENT, " +
- "name VARCHAR(255) UNIQUE, " +
- "PRIMARY KEY (source_id)" +
- ");");
- sentenciasSQL.add("CREATE TABLE symptom (" +
- "cui VARCHAR(25), " +
- "name VARCHAR(255), " +
- "st VARCHAR(45), " +
- "PRIMARY KEY (cui)" +
- ");");
- sentenciasSQL.add("CREATE TABLE disease_symptom (" +
- "disease_id INT, " +
- "cui VARCHAR(25), " +
- "FOREIGN KEY (disease_id) REFERENCES disease(disease_id), " +
- "FOREIGN KEY (cui) REFERENCES symptom(cui)" +
- ");");
- sentenciasSQL.add("CREATE TABLE code (" +
- "code VARCHAR(255) UNIQUE, " +
- "source_id INT, " +
- "PRIMARY KEY (code), " +
- "FOREIGN KEY (source_id) REFERENCES source(source_id)" +
- ");");
- sentenciasSQL.add("CREATE TABLE disease_has_code (" +
- "disease_id INT, " +
- "code VARCHAR(255), " +
- "source_id INT, " +
- "FOREIGN KEY (disease_id) REFERENCES disease(disease_id), " +
- "FOREIGN KEY (code) REFERENCES code(code), " +
- "FOREIGN KEY (source_id) REFERENCES `source`(source_id)" +
- ");");
- /*
- * Dado que las sentencias CREATE implican un COMMIT automático, comenzaremos la
- * transacción antes de las sentencias INSERT. Ahora se interpretan y segmentan los
- * datos de disease_data.data y se crean las sentencias de importación.
- */
- sentenciasSQL.add("START TRANSACTION;");
- for (String linea : archivo) {
- String[] d1 = linea.split("=");
- String[] e1 = d1[0].split(":");
- String nombreEnfermedad = e1[0];
- sentenciasSQL.add("INSERT INTO disease (name) VALUES ('" + nombreEnfermedad.replaceAll("'", "''") + "');");
- String[] datosEnfermedad = e1[1].split(";");
- for (String dato : datosEnfermedad) {
- String[] e2 = dato.split("@");
- String codigoE = e2[0];
- String sourceE = e2[1];
- sentenciasSQL.add("INSERT IGNORE INTO source (name) VALUES ('" + sourceE + "');");
- sentenciasSQL.add("INSERT IGNORE INTO code VALUES ('" + codigoE.replaceAll("'", "''") + "', " +
- "(SELECT source_id FROM source WHERE `name`='" + sourceE + "'));");
- sentenciasSQL.add("INSERT INTO disease_has_code VALUES (" +
- "(SELECT disease_id FROM disease WHERE `name`='" + nombreEnfermedad.replaceAll("'", "''") + "'), " +
- "'" + codigoE.replaceAll("'", "''") + "', " +
- "(SELECT source_id FROM code WHERE `code`='" + codigoE.replaceAll("'", "''") + "')" +
- ");");
- }
- String[] s1 = d1[1].split(";");
- for (String dato : s1) {
- String[] datosSintoma = dato.split(":");
- String nombreSintoma = datosSintoma[0];
- String codigoSintoma = datosSintoma[1];
- String semanticaSintoma = datosSintoma[2];
- sentenciasSQL.add("INSERT IGNORE INTO symptom VALUES (" +
- "'" + codigoSintoma.replaceAll("'", "''") + "', " +
- "'" + nombreSintoma.replaceAll("'", "''") + "', " +
- "'" + semanticaSintoma + "'" +
- ");");
- sentenciasSQL.add("INSERT INTO disease_symptom VALUES (" +
- "(SELECT disease_id FROM disease WHERE `name` = '" + nombreEnfermedad.replaceAll("'", "''") + "'), " +
- "'" + codigoSintoma.replaceAll("'", "''") + "')" +
- ";");
- }
- }
- /*
- * Una vez termino el proceso de segmentar e interpretar los datos de disease_data.data, y
- * colectar todas las sentencias de importación correspondientes, se añade al final de esta
- * colección la sentencia COMMIT. Finalmente se procede a ejecutar en orden las sentencias.
- */
- sentenciasSQL.add("COMMIT;");
- for (String sentencia : sentenciasSQL) {
- PreparedStatement ps = connection.prepareStatement(sentencia);
- ps.execute();
- }
- System.out.println("¡Proceso terminado con éxito!\n");
- } else {
- System.out.println("¡La base de datos diagnóstico ya existe!\n");
- }
- connection.setCatalog("diagnostico");
- } catch (Exception e) {
- e.printStackTrace();
- /*
- * En caso de un error en el proceso anterior, se parará el progreso y se optará por eliminar totalmente
- * la base de datos, deshaciendo así todos los cambios. Esto ocurre porque se presume que siempre que se
- * ejecute el método crearDB(), no existe la base de datos.
- */
- try {
- PreparedStatement ps = connection.prepareStatement("DROP DATABASE IF EXISTS diagnostico;");
- ps.execute();
- } catch (SQLException ex) {
- System.out.println("No pudo borrarse la base de datos.");
- }
- }
- }
- /**
- * Método para diagnosticar una enfermedad seleccionando una serie de síntomas.
- *
- * @throws Exception Puede lanzar alguna excepción.
- */
- private void realizarDiagnostico() {
- /*
- * Se conecta a la base de datos e imprime el código de los síntomas.
- */
- try {
- conectar("diagnostico");
- PreparedStatement ps = connection.prepareStatement("SELECT cui,name FROM symptom ORDER BY cui ");
- ResultSet lista = ps.executeQuery();
- while (lista.next()) {
- System.out.println(lista.getString("cui") + " | " + lista.getString("name"));
- }
- /*
- * Se limpia de espacios y se hace split de los códigos introducidos. Posteriormente,
- * se consulta en la base de datos qué enfermedades tienen los síntomas introducidos,
- * y se imprime.
- */
- System.out.println("Introduzca el código de los síntomas separados por comas:");
- String conjuntoEspacios = readString().replaceAll("\\s+", "");
- String[] conjunto = conjuntoEspacios.split(",");
- for (int i = 0; i < conjunto.length; i++) {
- conjunto[i] = "cui= '" + conjunto[i] + "'";
- }
- String query = "SELECT disease_symptom.disease_id,name FROM disease_symptom " +
- "INNER JOIN disease ON (disease_symptom.disease_id=disease.disease_id) " +
- "WHERE " + String.join(" OR ", conjunto) +
- " GROUP BY disease_id HAVING count(*)=" + Integer.toString(conjunto.length) + ";";
- ps = connection.prepareStatement(query);
- ResultSet result = ps.executeQuery(query);
- if (!result.next()) {
- System.out.println("No hay enfermendades asociadas.");
- } else {
- result.beforeFirst();
- System.out.println("Enfermedades para los códigos solicitados: (" + conjuntoEspacios + ")");
- while (result.next())
- System.out.println("- " + result.getString("name"));
- }
- System.out.println();
- } catch (Exception e) {
- System.out.println("Ha ocurrido un error:");
- e.printStackTrace();
- }
- }
- /**
- * Método para crear imprimir la lista de síntomas de una enfermedad y sus datos.
- *
- * @throws Exception Puede lanzar excepción si el proceso de consulta en
- * SQL ha fallado o la ID de enfermedad introducida es inválida.
- */
- private void listarSintomasEnfermedad() {
- System.out.println("Escoge una de las siguientes enfermedades introduciendo su ID:");
- /*
- * Se consulta a la base de datos las enfermedades almacenadas y sus IDs correspondientes.
- */
- try {
- conectar("diagnostico");
- PreparedStatement ps = connection.prepareStatement("SELECT disease_id,name FROM disease;");
- ResultSet listadoEnfermedades = ps.executeQuery();
- while (listadoEnfermedades.next()) {
- System.out.println(listadoEnfermedades.getInt("disease_id") + " | " +
- listadoEnfermedades.getString("name"));
- }
- /*
- * A través de un Scanner, se pide al usuario que introduzca una
- * ID. Acto seguido, se consulta y lista los síntomas de la enfermedad correspondiente.
- */
- Scanner sc = new Scanner(System.in);
- int ID = sc.nextInt();
- PreparedStatement ps2 = connection.prepareStatement(
- "SELECT cui FROM disease_symptom WHERE `disease_id`='" + ID + "';");
- ResultSet codigosSintomas = ps2.executeQuery();
- while (codigosSintomas.next()) {
- PreparedStatement ps3 = connection.prepareStatement(
- "SELECT name FROM symptom WHERE `cui`='" + codigosSintomas.getString("cui") + "'");
- ResultSet sintomas = ps3.executeQuery();
- sintomas.next();
- System.out.println("* " + sintomas.getString("name"));
- }
- System.out.println();
- } catch (Exception e) {
- System.out.println("Error al ejecutar la opción 4.");
- e.printStackTrace();
- }
- }
- /**
- * Método para crear imprimir las enfermedades con sus códigos y vocabularios.
- *
- * @throws Exception Puede lanzar excepción si el proceso de consulta en SQL ha fallado.
- */
- private void listarEnfermedadesYCodigosAsociados() {
- System.out.println("Las enfermedades guardadas en la base de datos y sus códigos asociados son:\n");
- /*
- * Se realiza una consulta a través de la cual se diseña un ResultSet cuya primera columna posee
- * el nombre de la enfermedad, segunda columna el código y tercera columna el vocabulario del código.
- */
- try {
- PreparedStatement ps = connection.prepareStatement(
- "SELECT disease.name,disease_has_code.code,source.name FROM disease_has_code " +
- "INNER JOIN disease ON disease_has_code.disease_id=disease.disease_id " +
- "INNER JOIN source ON disease_has_code.source_id=source.source_id;");
- ResultSet resultados = ps.executeQuery();
- while (resultados.next()) {
- System.out.println(resultados.getString(1) +
- " | " + resultados.getString(2) +
- " - " + resultados.getString(3));
- }
- System.out.println();
- } catch (Exception e) {
- System.out.println("Ha ocurrido un error al listar las enfermedades y sus códigos.");
- e.printStackTrace();
- }
- }
- /**
- * Método para crear imprimir los síntomas y sus tipos semánticos.
- *
- * @throws Exception Puede lanzar excepción si el proceso de consulta en SQL ha fallado.
- */
- private void listarSintomasYTiposSemanticos() {
- System.out.println("Los síntomas guardados en la base de datos y sus tipos semanticos son:");
- /*
- * Se realiza una consulta para obtener todos los síntomas y sus tipos semánticos.
- */
- try {
- PreparedStatement ps = connection.prepareStatement("SELECT name,st FROM symptom;");
- ResultSet resultados = ps.executeQuery();
- while (resultados.next()) {
- System.out.println(resultados.getString("name") +
- " - " + resultados.getString("st"));
- }
- System.out.println();
- } catch (SQLException e) {
- System.out.println("Ha ocurrido un error al listar los síntomas y sus tipos semánticos.");
- e.printStackTrace();
- }
- }
- /**
- * Método para crear imprimir estadísticas.
- *
- * @throws Exception Puede lanzar excepción si el proceso de consulta en SQL ha fallado.
- */
- private void mostrarEstadisticasBD() {
- /*
- * Se diseñan las consultas específicas para cada datos solicitado en el
- * enunciado. Se ejecutan, y se imprimen los datos pertinentes.
- */
- try {
- conectar("diagnostico");
- PreparedStatement a = connection.prepareStatement("SELECT COUNT(name) FROM disease;");
- PreparedStatement b = connection.prepareStatement("SELECT COUNT(name) FROM symptom;");
- PreparedStatement c1 = connection.prepareStatement("SELECT tabla.enfermedad FROM " +
- "(SELECT disease.name AS enfermedad, symptom.name AS sintoma FROM disease_symptom " +
- "INNER JOIN symptom ON disease_symptom.cui = symptom.cui " +
- "INNER JOIN disease ON disease_symptom.disease_id = disease.disease_id) " +
- "AS tabla GROUP BY tabla.enfermedad ORDER BY COUNT(tabla.enfermedad) ASC LIMIT 1;");
- PreparedStatement c2 = connection.prepareStatement("SELECT tabla.enfermedad FROM " +
- "(SELECT disease.name AS enfermedad, symptom.name AS sintoma FROM disease_symptom " +
- "INNER JOIN symptom ON disease_symptom.cui = symptom.cui " +
- "INNER JOIN disease ON disease_symptom.disease_id = disease.disease_id) " +
- "AS tabla GROUP BY tabla.enfermedad ORDER BY COUNT(tabla.enfermedad) DESC LIMIT 1;");
- PreparedStatement c3 = connection.prepareStatement("SELECT AVG(final.sintomas) FROM " +
- "(SELECT tabla.enfermedad, COUNT(tabla.sintoma) AS sintomas FROM " +
- "(SELECT disease.name AS enfermedad, symptom.name AS sintoma FROM disease_symptom " +
- "INNER JOIN symptom ON disease_symptom.cui = symptom.cui " +
- "INNER JOIN disease ON disease_symptom.disease_id = disease.disease_id) AS tabla " +
- "GROUP BY tabla.enfermedad) AS final;");
- PreparedStatement d = connection.prepareStatement("SELECT st,COUNT(name) AS numero " +
- "FROM symptom GROUP BY st ORDER BY numero DESC;");
- ResultSet res1 = a.executeQuery();
- res1.next();
- ResultSet res2 = b.executeQuery();
- res2.next();
- ResultSet res3 = c2.executeQuery();
- res3.next();
- ResultSet res4 = c1.executeQuery();
- res4.next();
- ResultSet res5 = c3.executeQuery();
- res5.next();
- ResultSet res6 = d.executeQuery();
- System.out.println("- Número enfermedades: " + res1.getString(1));
- System.out.println("- Número de síntomas: " + res2.getString(1));
- System.out.println("- Enfermedad con más síntomas: " + res3.getString(1) +
- "\n- Enfermedad con menos síntomas: " + res4.getString(1) +
- "\n- Número medio de síntomas: " + res5.getString(1));
- System.out.println("- Tipos semánticos de síntomas y cantidades: ");
- while (res6.next()) {
- System.out.println(res6.getString(1) + " · " + res6.getString(2));
- }
- System.out.println("\n");
- } catch (Exception e) {
- System.out.println("Ha ocurrido un error al mostrar las estadísticas.");
- e.printStackTrace();
- }
- }
- /**
- * Método para leer números enteros de teclado.
- *
- * @return Devuelve el número leído.
- * @throws Exception Puede lanzar excepción.
- */
- private int readInt() throws Exception {
- try {
- System.out.print("> ");
- return Integer.parseInt(new BufferedReader(new InputStreamReader(System.in)).readLine());
- } catch (Exception e) {
- throw new Exception("No es un número.");
- }
- }
- /**
- * Método para leer cadenas de teclado.
- *
- * @return Devuelve la cadena leída.
- * @throws Exception Puede lanzar excepción.
- */
- private String readString() throws Exception {
- try {
- System.out.print("> ");
- return new BufferedReader(new InputStreamReader(System.in)).readLine();
- } catch (Exception e) {
- throw new Exception("Error leyendo línea.");
- }
- }
- /**
- * Método para leer el fichero que contiene los datos.
- *
- * @return Devuelve una lista de String con el contenido.
- * @throws Exception Puede lanzar excepción.
- */
- private LinkedList<String> readData() throws Exception {
- LinkedList<String> data = new LinkedList<String>();
- BufferedReader bL = new BufferedReader(new FileReader(DATAFILE));
- while (bL.ready()) {
- data.add(bL.readLine());
- }
- bL.close();
- return data;
- }
- public static void main(String args[]) {
- new Diagnostico().showMenu();
- }
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement