JDBCPreparedStatementUtilities.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it).
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */
  20. package org.openspcoop2.generic_project.dao.jdbc.utils;

  22. import java.sql.Connection;
  23. import java.sql.PreparedStatement;
  24. import java.sql.ResultSet;
  25. import java.sql.SQLException;
  26. import java.sql.Statement;
  27. import java.util.ArrayList;
  28. import java.util.List;

  30. import org.slf4j.Logger;
  31. import org.openspcoop2.generic_project.beans.IModel;
  32. import org.openspcoop2.generic_project.exception.MultipleResultException;
  33. import org.openspcoop2.generic_project.exception.NotFoundException;
  34. import org.openspcoop2.generic_project.exception.ServiceException;
  35. import org.openspcoop2.utils.TipiDatabase;
  36. import org.openspcoop2.utils.jdbc.IKeyGenerator;
  37. import org.openspcoop2.utils.jdbc.IKeyGeneratorObject;
  38. import org.openspcoop2.utils.jdbc.JDBCAdapterException;
  39. import org.openspcoop2.utils.jdbc.KeyGeneratorException;
  40. import org.openspcoop2.utils.jdbc.KeyGeneratorFactory;
  41. import org.openspcoop2.utils.sql.ISQLQueryObject;
  42. import org.openspcoop2.utils.sql.SQLQueryObjectException;

  44. /**
  45.  * JDBCPreparedStatementUtilities
  46.  * 
  47.  * @author Poli Andrea (apoli@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */
  51. public class JDBCPreparedStatementUtilities {

  53.     private Logger log;
  54.     private Connection connection;
  55.     private JDBCSqlLogger sqlLogger;
  56.     private TipiDatabase tipoDatabase = null;
  57.     private GenericJDBCParameterUtilities jdbcParameterUtilities = null;
  58.     private Integer queryTimeout = null;
  59.     
  60.     public JDBCPreparedStatementUtilities(TipiDatabase tipoDatabase,Logger log,Connection connection) throws SQLQueryObjectException, JDBCAdapterException{
  61.         this(tipoDatabase, log, connection, null);
  62.     }
  63.     public JDBCPreparedStatementUtilities(TipiDatabase tipoDatabase,Logger log,Connection connection,Integer queryTimeout) throws SQLQueryObjectException, JDBCAdapterException{
  64.         this.log = log;
  65.         this.connection = connection;
  66.         this.sqlLogger = new JDBCSqlLogger(this.log);
  67.         this.tipoDatabase = tipoDatabase;
  68.         this.jdbcParameterUtilities = new GenericJDBCParameterUtilities(this.tipoDatabase);
  69.         this.queryTimeout = queryTimeout;
  70.     }
  71.     
  72.     private PreparedStatement _createPreparedStatement(String sql) throws SQLException {
  73.         return this._createPreparedStatement(sql, null);
  74.     }
  75.     private PreparedStatement _createPreparedStatement(String sql, Integer params) throws SQLException {
  76.         PreparedStatement p = null;
  77.         if(params!=null) {
  78.             p = this.connection.prepareStatement(sql,params);
  79.         }
  80.         else {
  81.             p = this.connection.prepareStatement(sql);
  82.         }
  83.         if(this.queryTimeout!=null && this.queryTimeout>0) {
  84.             p.setQueryTimeout(this.queryTimeout.intValue());
  85.         }
  86.         return p;
  87.     }
  88.     
  89.     public long insertAndReturnGeneratedKey(ISQLQueryObject sqlQueryObject,IKeyGeneratorObject object,boolean showSql,JDBCObject ... params) throws KeyGeneratorException{

  91.         PreparedStatement pstmt = null;
  92.         try{
  93.             
  94.             // KeyGenerator
  95.             IKeyGenerator keyGenerator = KeyGeneratorFactory.createKeyGeneratorFactory(this.tipoDatabase.getNome(), this.connection, object);

  97.             // Parametri di insert
  98.             List<JDBCObject> p = new ArrayList<>();
  99.             if(params!=null){
  100.                 for (int i = 0; i < params.length; i++) {
  101.                     p.add(params[i]);
  102.                 }
  103.             }
  104.             if(keyGenerator.isReturnGeneratedKeySupported()==false){
  105.                 JDBCObject jdbcObject = new JDBCObject(keyGenerator.generateKey(),Long.class);
  106.                 p.add(jdbcObject);
  107.             }
  108.             JDBCObject[]paramsWithId = null;
  109.             if(p.size()>0)
  110.                 paramsWithId = p.toArray(new JDBCObject[1]);
  111.             
  112.             // Query di insert
  113.             sqlQueryObject.addInsertTable(object.getTable());
  114.             if(keyGenerator.isReturnGeneratedKeySupported()==false){
  115.                 sqlQueryObject.addInsertField(keyGenerator.getColunmKeyName(), "?");
  116.             }
  117.             String insertString = sqlQueryObject.createSQLInsert();
  118.             if(showSql){
  119.                 this.sqlLogger.infoSql(insertString, paramsWithId);
  120.             }
  121.             
  122.             // Eseguo Prepared Statement
  123.             if(keyGenerator.isReturnGeneratedKeySupported()){
  124.                 pstmt = _createPreparedStatement(insertString,Statement.RETURN_GENERATED_KEYS);
  125.             }else{
  126.                 pstmt = _createPreparedStatement(insertString);
  127.             }
  128.             this.jdbcParameterUtilities.setParameters(pstmt, paramsWithId);
  129.             pstmt.executeUpdate();

  131.             
  132.             // Ritorno id generato
  133.             return keyGenerator.getReturnGeneratedKey(pstmt);

  135.         }catch(Exception e){
  136.             throw new KeyGeneratorException ("insertAndReturnGeneratedKey failed: "+e.getMessage(),e);
  137.         }finally{
  138.             try{
  139.                 if(pstmt!=null)
  140.                     pstmt.close();
  141.             }catch(Exception eClose){
  142.                 // close
  143.             }
  144.         }
  145.     }
  146.     
  147.     public boolean execute(String sql,boolean showSql,JDBCObject ... params ) throws ServiceException{
  148.         
  149.         PreparedStatement pstmt = null;
  150.         try{
  151.             
  152.             if(showSql)
  153.                 this.sqlLogger.infoSql(sql, params);
  154.             
  155.             pstmt = _createPreparedStatement(sql);
  156.             this.jdbcParameterUtilities.setParameters(pstmt, params);
  157.             
  158.             return pstmt.execute();
  159.             
  160.         }catch(Exception e){
  161.             throw new ServiceException(e.getMessage(),e);
  162.         }
  163.         finally{
  164.             try{
  165.                 if(pstmt!=null){
  166.                     pstmt.close();
  167.                 }
  168.             }catch(Exception eClose){
  169.                 // close
  170.             }
  171.         }
  172.     }
  173.     
  174.     public int executeUpdate(String sql,boolean showSql,JDBCObject ... params ) throws ServiceException{
  175.         
  176.         PreparedStatement pstmt = null;
  177.         try{
  178.             
  179.             if(showSql)
  180.                 this.sqlLogger.infoSql(sql, params);
  181.             
  182.             pstmt = _createPreparedStatement(sql);
  183.             this.jdbcParameterUtilities.setParameters(pstmt, params);
  184.             
  185.             return pstmt.executeUpdate();
  186.             
  187.         }catch(Exception e){
  188.             throw new ServiceException(e.getMessage(),e);
  189.         }
  190.         finally{
  191.             try{
  192.                 if(pstmt!=null){
  193.                     pstmt.close();
  194.                 }
  195.             }catch(Exception eClose){
  196.                 // close
  197.             }
  198.         }
  199.     }
  200.     
  201.     public Object executeQuerySingleResult(String sql,boolean showSql,IModel<?> model, IJDBCFetch fetch, JDBCObject ... params ) throws ServiceException, MultipleResultException, NotFoundException{
  202.         List<Object> list = this.executeQuery(sql, showSql, model, fetch, params);
  203.         if(list.size()==1){
  204.             Object o = list.get(0);
  205.             if(o!=null){
  206.                 return o;
  207.             }
  208.             else{
  209.                 throw new NotFoundException("Not found");
  210.             }
  211.         }
  212.         else if(list.size()<=0){
  213.             throw new NotFoundException("Not found");
  214.         }
  215.         else{
  216.             throw new MultipleResultException("More than one result found (result: "+list.size()+")");
  217.         }
  218.     }
  219.     
  220.     public List<Object> executeQuery(String sql,boolean showSql,IModel<?> model, IJDBCFetch fetch, JDBCObject ... params ) throws ServiceException{
  221.         
  222.         PreparedStatement pstmt = null;
  223.         ResultSet rs = null;
  224.         List<Object> lista = new ArrayList<>();
  225.         try{
  226.             
  227.             if(showSql)
  228.                 this.sqlLogger.infoSql(sql, params);
  229.             
  230.             pstmt = _createPreparedStatement(sql);
  231.             this.jdbcParameterUtilities.setParameters(pstmt, params);
  232.             
  233.             rs =  pstmt.executeQuery();
  234.             while(rs.next()){
  235.                 lista.add(fetch.fetch(this.tipoDatabase,model,rs));
  236.             }
  237.             return lista;
  238.             
  239.         }catch(Exception e){
  240.             throw new ServiceException(e.getMessage(),e);
  241.         }
  242.         finally{
  243.             try{
  244.                 if(rs!=null){
  245.                     rs.close();
  246.                 }
  247.             }catch(Exception eClose){}
  248.             try{
  249.                 if(pstmt!=null){
  250.                     pstmt.close();
  251.                 }
  252.             }catch(Exception eClose){
  253.                 // close
  254.             }
  255.         }
  256.     }
  257.     
  258.     public Object executeQuerySingleResult(String sql,boolean showSql,Class<?> returnType,JDBCObject ... params ) throws NotFoundException, ServiceException, MultipleResultException{
  259.         List<Object> list = this.executeQuery(sql, showSql, returnType, params);
  260.         if(list.size()==1){
  261.             Object o = list.get(0);
  262.             if(o!=null){
  263.                 return o;
  264.             }
  265.             else{
  266.                 throw new NotFoundException("Not found");
  267.             }
  268.         }
  269.         else if(list.size()<=0){
  270.             throw new NotFoundException("Not found");
  271.         }
  272.         else{
  273.             throw new MultipleResultException("More than one result found (result: "+list.size()+")");
  274.         }
  275.     }
  276.     public List<Object> executeQuery(String sql,boolean showSql,Class<?> returnType,JDBCObject ... params ) throws ServiceException{
  277.         
  278.         PreparedStatement pstmt = null;
  279.         ResultSet rs = null;
  280.         List<Object> lista = new ArrayList<>();
  281.         try{
  282.             
  283.             if(showSql)
  284.                 this.sqlLogger.infoSql(sql, params);
  285.             
  286.             pstmt = _createPreparedStatement(sql);
  287.             this.jdbcParameterUtilities.setParameters(pstmt, params);
  288.             
  289.             rs =  pstmt.executeQuery();
  290.             while(rs.next()){
  291.                 lista.add(this.jdbcParameterUtilities.readParameter(rs, 1, returnType));
  292.             }
  293.             return lista;
  294.             
  295.         }catch(Exception e){
  296.             throw new ServiceException(e.getMessage(),e);
  297.         }
  298.         finally{
  299.             try{
  300.                 if(rs!=null){
  301.                     rs.close();
  302.                 }
  303.             }catch(Exception eClose){}
  304.             try{
  305.                 if(pstmt!=null){
  306.                     pstmt.close();
  307.                 }
  308.             }catch(Exception eClose){
  309.                 // close
  310.             }
  311.         }
  312.     }
  313.     
  314.     public List<Object> executeQuerySingleResult(String sql,boolean showSql,List<Class<?>> returnType,JDBCObject ... params ) throws ServiceException, MultipleResultException{
  315.         List<List<Object>> list = this.executeQuery(sql, showSql, returnType, params);
  316.         if(list.size()==1){
  317.             return list.get(0);
  318.         }
  319.         else if(list.size()<=0){
  320.             return new ArrayList<>();
  321.         }
  322.         else{
  323.             throw new MultipleResultException("More than one result found (result: "+list.size()+")");
  324.         }
  325.     }
  326.     public List<List<Object>> executeQuery(String sql,boolean showSql,List<Class<?>> returnType,JDBCObject ... params ) throws ServiceException{
  327.         
  328.         PreparedStatement pstmt = null;
  329.         ResultSet rs = null;
  330.         List<List<Object>> lista = new ArrayList<List<Object>>();
  331.         try{
  332.             
  333.             if(showSql)
  334.                 this.sqlLogger.infoSql(sql, params);
  335.             
  336.             pstmt = _createPreparedStatement(sql);
  337.             this.jdbcParameterUtilities.setParameters(pstmt, params);
  338.             
  339.             rs =  pstmt.executeQuery();
  340.             while(rs.next()){
  341.                 List<Object> result = new ArrayList<>();
  342.                 for (int i = 0; i < returnType.size(); i++) {
  343.                     result.add(this.jdbcParameterUtilities.readParameter(rs, (i+1), returnType.get(i)));    
  344.                 }
  345.                 lista.add(result);
  346.             }
  347.             return lista;
  348.             
  349.         }catch(Exception e){
  350.             throw new ServiceException(e.getMessage(),e);
  351.         }
  352.         finally{
  353.             try{
  354.                 if(rs!=null){
  355.                     rs.close();
  356.                 }
  357.             }catch(Exception eClose){}
  358.             try{
  359.                 if(pstmt!=null){
  360.                     pstmt.close();
  361.                 }
  362.             }catch(Exception eClose){
  363.                 // close
  364.             }
  365.         }
  366.     }
  367.     
  368.     public boolean exists(String sql,boolean showSql,JDBCObject ... params ) throws ServiceException{
  369.         
  370.         PreparedStatement pstmt = null;
  371.         ResultSet rs = null;
  372.         try{
  373.             
  374.             if(showSql)
  375.                 this.sqlLogger.infoSql(sql, params);
  376.             
  377.             pstmt = _createPreparedStatement(sql);
  378.             this.jdbcParameterUtilities.setParameters(pstmt, params);
  379.             
  380.             rs =  pstmt.executeQuery();
  381.             return rs.next();
  382.             
  383.         }catch(Exception e){
  384.             throw new ServiceException(e.getMessage(),e);
  385.         }
  386.         finally{
  387.             try{
  388.                 if(rs!=null){
  389.                     rs.close();
  390.                 }
  391.             }catch(Exception eClose){}
  392.             try{
  393.                 if(pstmt!=null){
  394.                     pstmt.close();
  395.                 }
  396.             }catch(Exception eClose){
  397.                 // close
  398.             }
  399.         }
  400.     }
  401.     
  402.     public boolean deleteById(String sql,boolean showSql,JDBCObject ... params ) throws ServiceException{
  403.         
  404.         PreparedStatement pstmt = null;
  405.         ResultSet rs = null;
  406.         try{
  407.             
  408.             if(showSql)
  409.                 this.sqlLogger.infoSql(sql, params);
  410.             
  411.             pstmt = _createPreparedStatement(sql);
  412.             this.jdbcParameterUtilities.setParameters(pstmt, params);
  413.             
  414.             rs =  pstmt.executeQuery();
  415.             return rs.next();
  416.             
  417.         }catch(Exception e){
  418.             throw new ServiceException(e.getMessage(),e);
  419.         }
  420.         finally{
  421.             try{
  422.                 if(rs!=null){
  423.                     rs.close();
  424.                 }
  425.             }catch(Exception eClose){}
  426.             try{
  427.                 if(pstmt!=null){
  428.                     pstmt.close();
  429.                 }
  430.             }catch(Exception eClose){
  431.                 // close
  432.             }
  433.         }
  434.     }
  435.     
  436.     public long count(String sql,boolean showSql,JDBCObject ... params ) throws ServiceException{
  437.         
  438.         PreparedStatement pstmt = null;
  439.         ResultSet rs = null;
  440.         try{
  441.             
  442.             if(showSql)
  443.                 this.sqlLogger.infoSql(sql, params);
  444.             
  445.             pstmt = _createPreparedStatement(sql);
  446.             this.jdbcParameterUtilities.setParameters(pstmt, params);
  447.             
  448.             rs =  pstmt.executeQuery();
  449.             if(rs.next())
  450.                 return rs.getLong(1);
  451.             else
  452.                 return 0;
  453.             
  454.         }catch(Exception e){
  455.             throw new ServiceException(e.getMessage(),e);
  456.         }
  457.         finally{
  458.             try{
  459.                 if(rs!=null){
  460.                     rs.close();
  461.                 }
  462.             }catch(Exception eClose){}
  463.             try{
  464.                 if(pstmt!=null){
  465.                     pstmt.close();
  466.                 }
  467.             }catch(Exception eClose){
  468.                 // close
  469.             }
  470.         }
  471.     }
  472.     
  473. }
Created with JaCoCo 0.8.8.202204050719