Ver Mensaje Individual
  #3 (permalink)  
Antiguo 09/09/2010, 00:45
ioel10
 
Fecha de Ingreso: julio-2010
Mensajes: 104
Antigüedad: 13 años, 10 meses
Puntos: 2
Respuesta: Optimización de consultas a bbdd

Buenos días,

Gracias por la indicación.

En la clase consulta tengo varios métodos metodoQuery que se diferencian muy poco entre unos y otros como por ejemplo metodoQuery de la primera pregunta y el que viene a continuación:

Código java:
Ver original
  1. public variable metodoQueryParecido(Connection conexion, parametros){
  2.      
  3.        try {
  4.             if (conexion == null || conexion.isClosed()) {
  5.                 conexion = conexionPG.reConectar();
  6.             }
  7.         } catch (SQLException ex) {
  8.             log.error(ex);
  9.         }
  10.  
  11.         //Construyo la query        
  12.         String select = "select distinct campo1,  ";
  13.         consulta = consulta + select;
  14.  
  15.         String campo2 = " campo2, ";
  16.         consulta = consulta + campo2;
  17.  
  18.         //antes campo3, ahora campo4
  19.         String campo4 = " campo4, ";
  20.         consulta = consulta + campo4;
  21.  
  22.         String from = "from tabla";
  23.         consulta = consulta + from;
  24.  
  25.         String whereC1 = "where campo1 like 'parametros.parametro1' ";
  26.         consulta = consulta + whereC1;
  27.  
  28.         //antes campo4, ahora campo2
  29.         String whereC2 = "and campo2 like 'parametros.parametro2'' ";
  30.         consulta = consulta + whereC2;
  31.  
  32.        try {
  33.  
  34.             PreparedStatement ps = conexion.prepareStatement(consulta);
  35.  
  36.             rs = ps.executeQuery();
  37.  
  38.         } catch (SQLException ex) {
  39.             log.error("daoAlertas\n", ex);
  40.         }
  41.  
  42.         if (rs != null) {
  43.             return rs;
  44.         }
  45.  
  46.         return null;
  47.  
  48. }

Lo que estoy probando ahora es a transformar los métodos del siguiente modo:

metodoQuery
Código java:
Ver original
  1. public variable metodoQuery(Connection conexion, parametros){
  2.      
  3.         conexion = conexion();
  4.  
  5.         //Construyo la query        
  6.          consulta += query.select();
  7.  
  8.         consulta += query.distinct();
  9.  
  10.         consulta += query.campo123();
  11.  
  12.         consulta += query.from();
  13.  
  14.         consulta += query.whereC1(parametros.parametro1);
  15.  
  16.         consulta += query.wherec4(parametros.parametro2);
  17.  
  18.        try {
  19.  
  20.             PreparedStatement ps = conexion.prepareStatement(consulta);
  21.  
  22.             rs = ps.executeQuery();
  23.  
  24.         } catch (SQLException ex) {
  25.             log.error("daoAlertas\n", ex);
  26.         }
  27.  
  28.         if (rs != null) {
  29.             return rs;
  30.         }
  31.  
  32.         return null;
  33.  
  34. }


query
Código java:
Ver original
  1. public class query {
  2.  
  3.     public static String select() {
  4.         return "select ";
  5.     }
  6.  
  7.     public static String distinct() {
  8.         return "distinct ";
  9.     }
  10.    
  11.     public static String from() {
  12.         return "from tabla ";
  13.     }
  14.  
  15.      public static String where() {
  16.         return "where ";
  17.     }
  18.  
  19.     public static String campo123() {
  20.         return "campo1, campo2, campo3 ";
  21.     }
  22.  
  23.     public static String campo12() {
  24.         return "campo1, campo2, ";
  25.     }
  26.  
  27.     public static String campo4() {
  28.         return "campo4 ";
  29.     }
  30.  
  31.     public static String fromTabla() {
  32.         return "from tabla";
  33.     }
  34.  
  35.     public static String whereC1(String param) {
  36.         return "C1 = " + param + " ";
  37.     }
  38.  
  39.     public static String whereC1(String param) {
  40.         return "and C2 = " + param + " ";
  41.     }
  42.  
  43.     public static String whereC1(String param) {
  44.         return "and C4 = " + param + " ";
  45.     }
  46.  
  47.     public static String whereC3(String param) {
  48.         return "and C3 = " + param + " ";
  49.     }

Y después de estas tres mil líneas de código mi duda es si lo dejo como estaba, lo cambio a la llamada a métodos o sustituyo los métodos por constantes.

Un saludo y buen día.