JDBCUtilities.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.  */


  22. package org.openspcoop2.utils.jdbc;

  24. import java.sql.Connection;
  25. import java.sql.DatabaseMetaData;
  26. import java.sql.PreparedStatement;
  27. import java.sql.ResultSet;
  28. import java.sql.SQLException;
  29. import java.sql.Statement;
  30. import java.util.ArrayList;
  31. import java.util.Map;

  33. import org.openspcoop2.utils.LoggerWrapperFactory;
  34. import org.openspcoop2.utils.TipiDatabase;
  35. import org.openspcoop2.utils.UtilsException;
  36. import org.slf4j.Logger;

  38. /**
  39.  * JDBC Utilities
  40.  *
  41.  *
  42.  * @author Poli Andrea (apoli@link.it)
  43.  * @author $Author$
  44.  * @version $Rev$, $Date$
  45.  */

  47. public class JDBCUtilities {
  48.     
  49.     private JDBCUtilities() {}

  51.     /**
  52.      * Chiude tutte le PreparedStatement presenti nella tabella hash.
  53.      *
  54.      * @param tablePstmt Tabella Hash contenente PreparedStatement da chiudere.
  55.      * 
  56.      */
  57.     public static void closePreparedStatement(Map<String,PreparedStatement> tablePstmt,Logger log){
  58.         if(tablePstmt!=null && !tablePstmt.isEmpty()){
  59.             java.util.ArrayList<String> listKeys = new ArrayList<>();
  60.             for (String key : tablePstmt.keySet()) {
  61.                 listKeys.add(key);
  62.             }
  63.             java.util.Collections.sort(listKeys);
  64.             for(int i=0; i<listKeys.size(); i++ ) {
  65.                 String key = listKeys.get(i);
  66.                 PreparedStatement pstmt = tablePstmt.get(key);
  67.                 try{
  68.                     pstmt.close();
  69.                 }catch(Exception e){
  70.                     String msg = "Utilities.closePreparedStatement error: Riscontrato errore durante la chiusura della PreparedStatement ["+key+"]: "+e;
  71.                     log.debug(msg, e);
  72.                 }
  73.                 tablePstmt.remove(key);
  74.             }
  75.         }
  76.     }


  79.     /**
  80.      * Esegue e Chiude tutte le PreparedStatement presenti nella tabella hash.
  81.      *
  82.      * @param tablePstmt Tabella Hash contenente PreparedStatement da eseguire e chiudere.
  83.      * 
  84.      */
  85.     public static void executePreparedStatement(Map<String,PreparedStatement> tablePstmt) throws UtilsException{
  86.         if(tablePstmt!=null && !tablePstmt.isEmpty()){
  87.             java.util.ArrayList<String> listKeys = new ArrayList<>();
  88.             for (String key : tablePstmt.keySet()) {
  89.                 listKeys.add(key);
  90.             }
  91.             java.util.Collections.sort(listKeys);

  93.             /**System.out.println("---------- ("+listKeys.size()+") ------------");
  94.             for(int i=0; i<listKeys.size(); i++ ) {
  95.                 String key = listKeys.get(i);
  96.                 System.out.println("Pos["+i+"]: "+key);
  97.             }*/
  98.             
  99.             for(int i=0; i<listKeys.size(); i++ ) {
  100.                 String key = listKeys.get(i);
  101.                 PreparedStatement pstmt = tablePstmt.get(key);
  102.                 /**System.out.println("EXECUTE["+i+"]: "+key);*/
  103.                 try{
  104.                     pstmt.execute();
  105.                 }catch(Exception e){
  106.                     /**System.out.println("ERRORE: "+key);*/
  107.                     throw new UtilsException("Utilities.executePreparedStatement error: Riscontrato errore durante l'esecuzione della PreparedStatement ["+key+"]: "+e,e);
  108.                 }
  109.                 try{
  110.                     pstmt.close();
  111.                 }catch(Exception e){
  112.                     /**System.out.println("ERRORE: "+key);*/
  113.                     throw new UtilsException("Utilities.executePreparedStatement error: Riscontrato errore durante la chiusura della PreparedStatement ["+key+"]: "+e,e);
  114.                 }
  115.                 tablePstmt.remove(key);
  116.             }
  117.         }
  118.     }

  120.     /**
  121.      * Aggiunge prepared Statement
  122.      * 
  123.      * @param pstmtSorgente
  124.      * @param pstmtDestinazione
  125.      * @param log
  126.      */
  127.     public static void addPreparedStatement(Map<String,PreparedStatement> pstmtSorgente, 
  128.             Map<String,PreparedStatement> pstmtDestinazione,Logger log) throws UtilsException{ 
  129.         if(log!=null) {
  130.             // nop
  131.         }
  132.         if(pstmtSorgente!=null && !pstmtSorgente.isEmpty()){
  133.             for (String key : pstmtSorgente.keySet()) {
  134.                 if(!pstmtDestinazione.containsKey(key)){
  135.                     pstmtDestinazione.put(key,pstmtSorgente.get(key));
  136.                 }else{
  137.                     /**log.debug("Prepared Statement ["+key+"] gia' presente");*/
  138.                     try{
  139.                         PreparedStatement pstmt = pstmtSorgente.get(key);
  140.                         pstmt.close();
  141.                     }catch(Exception e){
  142.                         throw new UtilsException("Utilities.closePreparedStatementGiaPresente error: Riscontrato errore durante la chiusura della PreparedStatement ["+key+"]: "+e,e);
  143.                     }
  144.                 }
  145.             }
  146.         }
  147.     }
  148.     
  149.     
  150.     
  151.     
  152.     public static void setSQLStringValue(PreparedStatement pstmt,int index,String value) throws SQLException{
  153.         if(value!=null && (!"".equals(value)))
  154.             pstmt.setString(index,value);
  155.         else
  156.             pstmt.setString(index,null);
  157.     }
  158.     
  159.     
  160.     private static final int SQL_SERVER_TRANSACTION_SNAPSHOT = 4096;
  161.     
  162.     public static boolean isTransactionIsolationNone(int transactionIsolationLevel){
  163.         return transactionIsolationLevel == java.sql.Connection.TRANSACTION_NONE;
  164.     }
  165.     public static boolean isTransactionIsolationReadUncommitted(int transactionIsolationLevel){
  166.         return transactionIsolationLevel == java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;
  167.     }
  168.     public static boolean isTransactionIsolationReadCommitted(int transactionIsolationLevel){
  169.         return transactionIsolationLevel == java.sql.Connection.TRANSACTION_READ_COMMITTED;
  170.     }
  171.     public static boolean isTransactionIsolationRepeatableRead(int transactionIsolationLevel){
  172.         return transactionIsolationLevel == java.sql.Connection.TRANSACTION_REPEATABLE_READ;
  173.     }
  174.     public static boolean isTransactionIsolationSerializable(int transactionIsolationLevel){
  175.         return transactionIsolationLevel == java.sql.Connection.TRANSACTION_SERIALIZABLE;
  176.     }
  177.     public static boolean isTransactionIsolationSqlServerSnapshot(int transactionIsolationLevel){
  178.         return transactionIsolationLevel == JDBCUtilities.SQL_SERVER_TRANSACTION_SNAPSHOT;
  179.     }
  180.     public static boolean isTransactionIsolationSerializable(int transactionIsolationLevel,TipiDatabase tipoDatabase){
  181.         if(tipoDatabase!=null && TipiDatabase.SQLSERVER.equals(tipoDatabase)){ 
  182.             return JDBCUtilities.isTransactionIsolationSqlServerSnapshot(transactionIsolationLevel);
  183.         }
  184.         else {
  185.             return JDBCUtilities.isTransactionIsolationSerializable(transactionIsolationLevel);
  186.         }
  187.     }
  188.     
  189.     public static void setTransactionIsolationSerializable(String tipoDatabase,Connection connection) throws SQLException{
  190.         JDBCUtilities.setTransactionIsolationSerializable(TipiDatabase.toEnumConstant(tipoDatabase), connection);
  191.     }
  192.     public static void setTransactionIsolationSerializable(TipiDatabase tipoDatabase,Connection connection) throws SQLException{
  193.         if(tipoDatabase!=null && TipiDatabase.SQLSERVER.equals(tipoDatabase)){ 
  194.             connection.setTransactionIsolation(JDBCUtilities.SQL_SERVER_TRANSACTION_SNAPSHOT); /**4096 corresponds to SQLServerConnection.TRANSACTION_SNAPSHOT }*/
  195.         }
  196.         else{ 
  197.             connection.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE); 
  198.         } 
  199.     }
  200.     
  201.     
  202.     
  203.     
  204.     
  205.     public static void addInformazioniDatabaseFromMetaData(Connection c, StringBuilder bf) throws SQLException{
  206.         
  207.         DatabaseMetaData dbMetaDati = c.getMetaData();
  208.         if(dbMetaDati!=null){

  210.             if(bf.length()>0){
  211.                 bf.append("\n");
  212.             }

  214.             try {
  215.                 String productName = dbMetaDati.getDatabaseProductName();
  216.                 bf.append("DatabaseProductName: "+productName);
  217.                 bf.append("\n");
  218.             } catch (SQLException e) {
  219.                 // ignore
  220.             }

  222.             try {
  223.                 String productVersion = dbMetaDati.getDatabaseProductVersion();
  224.                 bf.append("DatabaseProductVersion: "+productVersion);
  225.                 bf.append("\n");
  226.             } catch (SQLException e) {
  227.                 // ignore
  228.             }

  230.             try {
  231.                 int v = dbMetaDati.getDatabaseMajorVersion();
  232.                 bf.append("DatabaseMajorVersion: "+v);
  233.                 bf.append("\n");
  234.             } catch (SQLException e) {
  235.                 // ignore
  236.             }

  238.             try {
  239.                 int v = dbMetaDati.getDatabaseMinorVersion();
  240.                 bf.append("DatabaseMinorVersion: "+v);
  241.                 bf.append("\n");
  242.             } catch (SQLException e) {
  243.                 // ignore
  244.             }

  246.             addInformazioniDatabaseFromMetaDataDriver(dbMetaDati, bf);

  248.             try {
  249.                 String username = dbMetaDati.getUserName();
  250.                 bf.append("Username: "+username);
  251.                 bf.append("\n");
  252.             } catch (SQLException e) {
  253.                 // ignore
  254.             }

  256.             addInformazioniDatabaseFromMetaDataCatalog(dbMetaDati, bf);

  258.         }

  260.     }
  261.     private static void addInformazioniDatabaseFromMetaDataDriver(DatabaseMetaData dbMetaDati, StringBuilder bf) throws SQLException{
  262.         try {
  263.             String driverName = dbMetaDati.getDriverName();
  264.             bf.append("DriverName: "+driverName);
  265.             bf.append("\n");
  266.         } catch (SQLException e) {
  267.             // ignore
  268.         }

  270.         try {
  271.             String productVersion = dbMetaDati.getDriverVersion();
  272.             bf.append("DriverVersion: "+productVersion);
  273.             bf.append("\n");
  274.         } catch (SQLException e) {
  275.             // ignore
  276.         }

  278.         int v = dbMetaDati.getDriverMajorVersion();
  279.         bf.append("DriverMajorVersion: "+v);
  280.         bf.append("\n");
  281.         
  282.         v = dbMetaDati.getDriverMinorVersion();
  283.         bf.append("DriverMinorVersion: "+v);
  284.         bf.append("\n");
  285.         
  286.         try {
  287.             v = dbMetaDati.getJDBCMajorVersion();
  288.             bf.append("JDBCMajorVersion: "+v);
  289.             bf.append("\n");
  290.         } catch (SQLException e) {
  291.             // ignore
  292.         }

  294.         try {
  295.             v = dbMetaDati.getJDBCMinorVersion();
  296.             bf.append("JDBCMinorVersion: "+v);
  297.             bf.append("\n");
  298.         } catch (SQLException e) {
  299.             // ignore
  300.         }
  301.     }
  302.     private static void addInformazioniDatabaseFromMetaDataCatalog(DatabaseMetaData dbMetaDati, StringBuilder bf) throws SQLException{
  303.         try {
  304.             ResultSet catalogs = dbMetaDati.getCatalogs();
  305.             int size = 0;
  306.             while (catalogs.next()) {
  307.                 size++;
  308.             }
  309.             
  310.             catalogs = dbMetaDati.getCatalogs();
  311.             int index = 0;
  312.             while (catalogs.next()) {
  313.                 if(size==1){
  314.                     bf.append("Catalog: " + catalogs.getString(1) );
  315.                 }
  316.                 else{
  317.                     bf.append("Catalogs["+index+"]: " + catalogs.getString(1) );
  318.                 }
  319.                 bf.append("\n");
  320.                 index++;
  321.             }
  322.             catalogs.close();
  323.         } catch (SQLException e) {
  324.             // ignore
  325.         }
  326.     }
  327.     
  328.     public static void closeResources(ResultSet rs, PreparedStatement stm) {
  329.         try{
  330.             if(rs!=null) 
  331.                 rs.close();
  332.         }catch (Exception e) {
  333.             //ignore
  334.         }
  335.         try{
  336.             if(stm!=null) 
  337.                 stm.close();
  338.         }catch (Exception e) {
  339.             //ignore
  340.         }
  341.     }
  342.     public static void closeResources(ResultSet rs, Statement stm) {
  343.         try{
  344.             if(rs!=null) 
  345.                 rs.close();
  346.         }catch (Exception e) {
  347.             //ignore
  348.         }
  349.         try{
  350.             if(stm!=null) 
  351.                 stm.close();
  352.         }catch (Exception e) {
  353.             //ignore
  354.         }
  355.     }
  356.     public static void closeResources(PreparedStatement stm) {
  357.         try{
  358.             if(stm!=null) 
  359.                 stm.close();
  360.         }catch (Exception e) {
  361.             //ignore
  362.         }
  363.     }
  364.     public static void closeResources(Statement stm) {
  365.         try{
  366.             if(stm!=null) 
  367.                 stm.close();
  368.         }catch (Exception e) {
  369.             //ignore
  370.         }
  371.     }
  372.     
  373.     
  374.     public static void closeConnection(Logger log, Connection connectionDB, boolean checkAutocommit, boolean checkIsClosed) throws SQLException {
  375.         if(connectionDB!=null) {
  376.             if(checkAutocommit) {
  377.                 checkAutocommit(log, connectionDB);
  378.             }
  379.             if(checkIsClosed) {
  380.                 checkIsClosed(log, connectionDB);
  381.             }
  382.         }
  383.     }
  384.     private static void checkAutocommit(Logger log, Connection connectionDB) throws SQLException {
  385.         if(!connectionDB.getAutoCommit()) {
  386.             String msg = "Connection detected in transaction mode";
  387.             if(log==null) {
  388.                 log = LoggerWrapperFactory.getLogger(JDBCUtilities.class);
  389.             }
  390.             log.error(msg,new UtilsException(msg)); // aggiungo eccezione per registrare lo stack trace della chiamata e vedere dove viene chiamato il metodo
  391.             connectionDB.setAutoCommit(true);
  392.         }
  393.         else {
  394.             // nop
  395.         }
  396.     }
  397.     private static void checkIsClosed(Logger log, Connection connectionDB) throws SQLException {
  398.         if(connectionDB.isClosed()) {
  399.             String msg = "Connection already closed detected";
  400.             if(log==null) {
  401.                 log = LoggerWrapperFactory.getLogger(JDBCUtilities.class);
  402.             }
  403.             log.error(msg,new UtilsException(msg)); // aggiungo eccezione per registrare lo stack trace della chiamata e vedere dove viene chiamato il metodo
  404.         }
  405.         else {
  406.             connectionDB.close();
  407.         }
  408.     }
  409. }
Created with JaCoCo 0.8.8.202204050719