Optimización de consultas a bbdd

[ioel10]

Buenos días,

Estoy realizando una aplicación escritorio en la que ejecuto un consulta muy parecida unas cuantas veces, del siguiente modo:

Ventana principal:

Código java:

claseConsulta.metodoQuery(Connection conexion, parametros);
 

claseConsulta:

Código java:

public variable metodoQuery(Connection conexion, parametros){
     
       try {
            if (conexion == null || conexion.isClosed()) {
                conexion = conexionPG.reConectar();
            }
        } catch (SQLException ex) {
            log.error(ex);
        }
 
        //Construyo la query        
        String select = "select distinct campo1,  ";
        consulta = consulta + select;
 
        String campo2 = " campo2, ";
        consulta = consulta + campo2;
 
 
        String campo3 = " campo3, ";
        consulta = consulta + campo3;
 
        String from = "from tabla";
        consulta = consulta + from;
 
        String whereC1 = "where campo1 like 'parametros.parametro1' ";
        consulta = consulta + whereC1;
 
        String whereC4 = "and campo4 like 'parametros.parametro2'' ";
        consulta = consulta + whereC4;
 
       try {
 
            PreparedStatement ps = conexion.prepareStatement(consulta);
 
            rs = ps.executeQuery();
 
        } catch (SQLException ex) {
            log.error("daoAlertas\n", ex);
        }
 
        if (rs != null) {
            return rs;
        }
 
        return null;
 
}
 

Creo que lo más eficiente sería que algunos de los string que forman la consulta se convirtieran en una constante o un valor que me devolviera un método.

¿Cuál de las tres opciones es la óptima?

Un saludo y buen día.

[Xerelo]

No acabo de entender tu pregunta, pero estás desperdiciando el prepareStatement

http://www.forosdelweb.com/f45/difer...tement-612469/

[ioel10]

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:

public variable metodoQueryParecido(Connection conexion, parametros){
     
       try {
            if (conexion == null || conexion.isClosed()) {
                conexion = conexionPG.reConectar();
            }
        } catch (SQLException ex) {
            log.error(ex);
        }
 
        //Construyo la query        
        String select = "select distinct campo1,  ";
        consulta = consulta + select;
 
        String campo2 = " campo2, ";
        consulta = consulta + campo2;
 
        //antes campo3, ahora campo4 
        String campo4 = " campo4, ";
        consulta = consulta + campo4;
 
        String from = "from tabla";
        consulta = consulta + from;
 
        String whereC1 = "where campo1 like 'parametros.parametro1' ";
        consulta = consulta + whereC1;
 
        //antes campo4, ahora campo2
        String whereC2 = "and campo2 like 'parametros.parametro2'' ";
        consulta = consulta + whereC2;
 
       try {
 
            PreparedStatement ps = conexion.prepareStatement(consulta);
 
            rs = ps.executeQuery();
 
        } catch (SQLException ex) {
            log.error("daoAlertas\n", ex);
        }
 
        if (rs != null) {
            return rs;
        }
 
        return null;
 
}
 

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

metodoQuery

Código java:

public variable metodoQuery(Connection conexion, parametros){
     
        conexion = conexion();
 
        //Construyo la query        
         consulta += query.select();
 
        consulta += query.distinct();
 
        consulta += query.campo123();
 
        consulta += query.from();
 
        consulta += query.whereC1(parametros.parametro1);
 
        consulta += query.wherec4(parametros.parametro2);
 
       try {
 
            PreparedStatement ps = conexion.prepareStatement(consulta);
 
            rs = ps.executeQuery();
 
        } catch (SQLException ex) {
            log.error("daoAlertas\n", ex);
        }
 
        if (rs != null) {
            return rs;
        }
 
        return null;
 
}
 

query

Código java:

public class query {
 
    public static String select() {
        return "select ";
    }
 
    public static String distinct() {
        return "distinct ";
    }
    
    public static String from() {
        return "from tabla ";
    }
 
     public static String where() {
        return "where ";
    }
 
    public static String campo123() {
        return "campo1, campo2, campo3 ";
    }
 
    public static String campo12() {
        return "campo1, campo2, ";
    }
 
    public static String campo4() {
        return "campo4 ";
    }
 
    public static String fromTabla() {
        return "from tabla";
    }
 
    public static String whereC1(String param) {
        return "C1 = " + param + " ";
    }
 
    public static String whereC1(String param) {
        return "and C2 = " + param + " ";
    }
 
    public static String whereC1(String param) {
        return "and C4 = " + param + " ";
    }
 
    public static String whereC3(String param) {
        return "and C3 = " + param + " ";
    }
 

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.

[francopai]

No logro entender cual es tu duda, pero te cuento que la idea es simple. Para armar una query "dinamica", osea que en algunos casos se utilicen ciertos parametros y en otros no, la idea es concatenar String hasta lograr la query final y una vez que tenes la query en un String, instancias tus objetos que conectan con la Base de Datos y le pasas la consulta.
Un saludo

[juamd]

Que tal !!!

En la empresa donde trabajo usamos una clase llamada Sql, en la cual vas agregando parametros dependiendo del tipo de consulta que quieras armar, el caso es que siempre la armas igual. La clase puede ser algo como esto:

Código:

package Persistencia;

import java.util.Vector;

public class Sql {

    private Vector colCondiciones = new Vector();
    private Vector colCampos = new Vector();
    private Vector colTablas = new Vector();
    private Vector colValues = new Vector();
    private Vector colJoin = new Vector();
    private Vector colGroup =  new Vector();
    private Vector colOrderBy = new Vector();
    private String funcion = "";


    public void addCondicion(String condicion)
    {
        if(!this.colCondiciones.contains(condicion)){
            this.colCondiciones.add(condicion);
        }
    }
    
    public void addCampo(String campo)
    {
        if(!this.colCampos.contains(campo)){
            this.colCampos.add(campo);
        }
    }

    public Vector getCampos() {
        return this.colCampos;
    }
    
    public void addTabla(String tabla)
    {
        if(!this.colTablas.contains(tabla)){
            this.colTablas.add(tabla);
        }
    }

    public void addValue(String valor)
    {
        //Cuando se pasa un String este valor debe compararse en la base de datos entre comillas simples
        valor = "'"+valor +"'";
        //if(!this.colValues.contains(valor)){
            this.colValues.add(valor);
        //}
    }

    public void addValue(int valor)
    {
        //if(!this.colValues.contains(valor)){
            this.colValues.add(valor);
        //}
    }

    public void addValue(double valor)
    {
        //if(!this.colValues.contains(valor)){
            this.colValues.add(valor);
        //}
    }

    public void addJoin(String valor)
    {
        if(!this.colJoin.contains(valor)){
            this.colJoin.add(valor);
        }
    }

    public void addGroup(int numero)
    {
        this.colGroup.add(String.valueOf(numero));
    }

    public void addOrderBy(int numero)
    {
        this.colOrderBy.add(String.valueOf(numero));
    }

    public void setFuncion(String funcion)
    {
        this.funcion = funcion;
    }

    /**
     * Se recorre cada Vector y se van agregando sus campos a la cadena respectiva separados por ",". Se revisa que
     * el elemento no sea el ultimo, es decir el elemento en la posicion que esta en el tamaño del vector - 1 (en los
     * vectores los elementos van de 0 hasta el tamaño -1) ya que a este no se le puede agregar la ",".
     * */
    public String generar()
    {
        String consulta = "", campos = "", tablas = "", condiciones = "", values = "", 
                joins = "", group = "", order = "";
        int i;

        if(this.colCampos.size() > 0){
            for(i = 0; i < this.colCampos.size(); i++){
                campos = campos + this.colCampos.get(i);
                if(i != (this.colCampos.size() - 1)){
                    campos = campos + ",";
                }
            }
        }
        
        if(this.colTablas.size() > 0){
            for(i = 0; i < this.colTablas.size(); i++){
                tablas = tablas + this.colTablas.get(i);
                if(i != (this.colTablas.size() - 1)){
                    tablas = tablas + ",";
                }
            }
        }

        if(this.colCondiciones.size() > 0){
            for(i = 0; i < this.colCondiciones.size(); i++){
                condiciones = condiciones + this.colCondiciones.get(i);
                if(i != (this.colCondiciones.size() - 1)){
                    condiciones = condiciones + " and ";
                }
            }
            condiciones = " where " + condiciones;
        }

        if(this.colValues.size() > 0){
            for( i = 0; i < this.colValues.size(); i++){
                values = values + this.colValues.get(i);
                if(i != (this.colValues.size() - 1)){
                    values = values + ",";
                }
            }
        }

        if(this.colJoin.size() > 0){
            for( i = 0; i < this.colJoin.size(); i++){
                joins = joins + this.colJoin.get(i) + " ";
            }
            condiciones = " " + joins + " " + condiciones;
        }

        if(this.colGroup.size() > 0) {
            group = "group by ";
            for(i=0; i<this.colGroup.size(); i++){
                group = group + this.colGroup.get(i);
                if( i != (this.colGroup.size() - 1)){
                    group = group + ",";
                }
            }
            condiciones = condiciones + " " +group;
        }

        if(this.colOrderBy.size() > 0){
            order = "order by ";
            for(i=0; i<this.colOrderBy.size(); i++){
                order = order + this.colOrderBy.get(i);
                if( i != (this.colOrderBy.size() - 1)){
                    order = order + ",";
                }
            }
            condiciones = condiciones + " " + order;
        }


        if(this.funcion.equals("insert")){
                consulta = this.funcion + " into " + tablas + "( " + campos + " ) " + " values( " + values + " ) ";
        }else if(this.funcion.equals("update")) {
            consulta = this.funcion + " " + tablas + " set " + campos + condiciones;
        }else if(this.funcion.equals("delete")){
            consulta = this.funcion + " from " + tablas + condiciones;
        }else if(this.funcion.equals("select")){
            if(this.colTablas.size() > 0){
                consulta = "select " + campos + " from " + tablas + condiciones;
            }else{
                consulta = "select " + campos;
            }
        }else if(this.funcion.equals("insert_select")){
            if(this.colGroup.size() > 0){
                consulta = "insert into "+this.colTablas.get(0)+" select "+campos+ " from "+this.colTablas.get(1)+condiciones;
            }else{
                consulta = "insert into "+this.colTablas.get(0)+" select "+campos+ " from "+this.colTablas.get(1);
            }


        }else {
            consulta = this.funcion;
        }
        
        return consulta;
        
    }

    /**
     * Se usa para eliminar lo que tenga el objeto almacenado a fin de realizar una nueva consulta
     */
    public void resetConsulta()
    {
        this.colCampos.clear();
        this.colCondiciones.clear();
        this.colJoin.clear();
        this.colTablas.clear();
        this.colValues.clear();
        this.colGroup.clear();
        this.colOrderBy.clear();
        this.funcion = "";
    }

como se puede ejecutar todo esto ? puede ser algo como esto:

Código:

public static string actualizarEmpleado(double cedula,String centro,String cargo, double basico, String fecha){
        sql.resetConsulta();

        sql.setFuncion("update");
        sql.addTabla("empleados");

        sql.addCampo("seccionEmpleado = '"+centro+"'");
        sql.addCampo("cargoEmpleado = '"+cargo+"'");
        sql.addCampo("basicoMensualEmpleado ="+basico);
        sql.addCampo("fechaTerminoContratoEmpleado ='"+fecha+"'");
        sql.addCondicion("cedulaEmpleado = "+cedula);

        return sql.generar;
    }

Supongamos que el metodo actualizar empleado te retorna la consulta necesaria para realizar esa accion en la base de datos, asi seria la forma de armar la consulta de esa manera.


Saludos.

[ioel10]

Buenos días,

#francopai: Muchas gracias por la indicación. Eso ya lo estoy haciendo, lo que quiero es saber la manera óptima de hacerlo, es decir, la más rápida, legible y manejable.

#juamd: Te agradezco que te hayas tomado el tiempo de mostrarme la clase con la que trabajas, no es lo que busco en estos momentos pero seguro que me vale en un futuro.

Siento no haberme explicado del modo correcto.

Lo que ya tenía hecho: método en el que vas concatenando sentencias a un string y al final con ese string y una connection:

Código java:

Statement st = conexion.createStatement();
 
rs = st.executeQuery(consulta);
 

Lo que estoy probando:método en el que la unica diferencia con el anterior es que en vez de

Código java:

consulta += "select campo from tabla"
 

hago...

Código java:

public class consulta {
     consulta += query.select();
     consulta += query.campo();
     consulta += query.from ();
     consulta += query.tabla();
}
 
public class query {
 
    public static String select() {
        return "select ";
    }
    
    public static String from() {
        return "from ";
    }
 
    public static String campo() {
        return "campo ";
    }
 
    public static String tabla() {
        return "tabla ";
    }
  
}
 

Lo que no se si haré:en vez de llamar a un método de otra clase, llamaré a un properties.

Un saludo y buen día.