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

  21. package org.openspcoop2.core.commons;

  23. import java.io.BufferedReader;
  24. import java.io.ByteArrayOutputStream;
  25. import java.io.File;
  26. import java.io.FileInputStream;
  27. import java.io.FileReader;
  28. import java.util.Arrays;
  29. import java.util.Properties;

  31. import org.openspcoop2.utils.TipiDatabase;
  32. import org.openspcoop2.utils.resources.FileSystemUtilities;

  34. /**
  35.  * SQLScriptBuilder
  36.  *
  37.  * @author Poli Andrea (apoli@link.it)
  38.  * @author $Author$
  39.  * @version $Rev$, $Date$
  40.  */
  41. public class SQLScriptBuilder {

  43.     public static void main(String[] args) throws Exception {
  44.         // Metodo utilizzato dal setup antinstaller
  45.         
  46.         String sqlSourceDir = (String) args[0];
  47.         
  48.         String sqlDestDir = (String) args[1];
  49.         
  50.         String sqlScriptName = (String) args[2];
  51.         
  52.         String modalitaInstallazione = (String) args[3];
  53.         
  54.         boolean splitDDL_DML = true;
  55.         
  56.         String versionePrecedente = null;
  57.         String versioneAttuale = null;
  58.         String tipoDatabase = null;
  59.         String configurazioneUpgrade = null;
  60.         boolean configurazioneUpgrade_runtime = true;
  61.         boolean configurazioneUpgrade_config = true;
  62.         boolean configurazioneUpgrade_tracce = true;
  63.         boolean configurazioneUpgrade_statistiche = true;
  64.         boolean configurazioneUpgrade_monitoraggio = true;
  65.         if(args.length>4){
  66.             versionePrecedente = (String) args[4];
  67.             versioneAttuale = (String) args[5];
  68.             tipoDatabase = (String) args[6];
  69.             if("aggiornamento".equals(modalitaInstallazione) && args.length>7){
  70.                 configurazioneUpgrade = (String) args[7];
  71.                 File f = new File(configurazioneUpgrade);
  72.                 if(f.exists()) {
  73.                     try(FileInputStream fin = new FileInputStream(f)){
  74.                         Properties p = new Properties();
  75.                         p.load(fin);
  76.                         configurazioneUpgrade_runtime = readBooleanProperty(p, "upgrade.runtime");
  77.                         configurazioneUpgrade_config = readBooleanProperty(p, "upgrade.configurazione");
  78.                         configurazioneUpgrade_tracce = readBooleanProperty(p, "upgrade.tracciamento");
  79.                         configurazioneUpgrade_statistiche = readBooleanProperty(p, "upgrade.statistiche");
  80.                         configurazioneUpgrade_monitoraggio = readBooleanProperty(p, "upgrade.monitoraggio");
  81.                     }
  82.                 }
  83.             }
  84.         }
  85.         
  86.         // NOTA: Non far stampare niente, viene usato come meccanismo di check per vedere se l'esecuzione e' andata a buon fine
  87.         //System.out.println("Modalita ["+modalitaInstallazione+"]");
  88.         
  89.         if("nuova".equals(modalitaInstallazione)){
  90.             buildSql_NuovaInstallazione(new File(sqlSourceDir),new File(sqlDestDir),sqlScriptName,splitDDL_DML);
  91.         }
  92.         else if("aggiornamento".equals(modalitaInstallazione)){
  93.             
  94.             //System.out.println("versionePrecedente ["+versionePrecedente+"]");
  95.             //System.out.println("versioneAttuale ["+versioneAttuale+"]");
  96.             //System.out.println("tipoDatabase ["+tipoDatabase+"]");
  97.             
  98.             buildSql_Aggiornamento(new File(sqlSourceDir),new File(sqlDestDir),sqlScriptName,versionePrecedente,
  99.                     versioneAttuale, tipoDatabase,
  100.                     configurazioneUpgrade_runtime,
  101.                     configurazioneUpgrade_config,
  102.                     configurazioneUpgrade_tracce,
  103.                     configurazioneUpgrade_statistiche,
  104.                     configurazioneUpgrade_monitoraggio);
  105.         }
  106.         else{
  107.             throw new Exception("Modalità installazione ["+modalitaInstallazione+"] sconosciuta");
  108.         }
  109.         
  110.     }
  111.     
  112.     private static boolean readBooleanProperty(Properties p, String name) throws Exception {
  113.         String tmp = p.getProperty(name);
  114.         if(tmp==null) {
  115.             throw new Exception("Configurazione Upgrade non corretta, proprietà ["+name+"] non presente");
  116.         }
  117.         tmp = tmp.trim();
  118.         try {
  119.             return Boolean.valueOf(tmp);
  120.         }catch(Exception e) {
  121.             throw new Exception("Configurazione Upgrade non corretta, proprietà ["+name+"] non corretta: "+e.getMessage(),e);
  122.         }
  123.     }
  124.     
  125.     private static void buildSql_NuovaInstallazione(File sqlSourceDir, File sqlDestDir, String sqlScriptName,
  126.             boolean splitDDL_DML) throws Exception {
  127.         
  128.         if(sqlSourceDir.exists()==false){
  129.             throw new Exception("Source dir ["+sqlSourceDir.getAbsolutePath()+"] not exists");
  130.         }
  131.         if(sqlSourceDir.canRead()==false){
  132.             throw new Exception("Source dir ["+sqlSourceDir.getAbsolutePath()+"] cannot read");
  133.         }
  134.         
  135.         if(sqlDestDir.exists()==false){
  136.             throw new Exception("Dest dir ["+sqlDestDir.getAbsolutePath()+"] not exists");
  137.         }
  138.         if(sqlDestDir.canWrite()==false){
  139.             throw new Exception("Dest dir ["+sqlDestDir.getAbsolutePath()+"] cannot write");
  140.         }
  141.         
  142.         int prefix = 0;
  143.         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  144.         
  145.         // BASE
  146.         File [] f = sqlSourceDir.listFiles();
  147.         if(f!=null) {
  148.             for (int i = 0; i < f.length; i++) {
  149.                 if(f[i].isFile()) {
  150.                     _createSql(sqlSourceDir, f[i].getName(), 
  151.                             sqlDestDir, sqlScriptName, prefix, bout,
  152.                             splitDDL_DML);
  153.                 }
  154.             }
  155.         }
  156.         
  157.         File dest = new File(sqlDestDir, sqlScriptName);
  158.         
  159.         bout.flush();
  160.         bout.close();
  161.         FileSystemUtilities.writeFile(dest, bout.toByteArray());
  162.         
  163.         if(splitDDL_DML){
  164.             
  165.             //System.out.println("Split init ...");
  166.             
  167.             File destInit = new File(sqlDestDir, dest.getName().replace(".sql", "_init.sql"));
  168.             splitFileForDDLtoDML(dest, dest, destInit);
  169.         }
  170.     
  171.     }
  172.     
  173.     private static void buildSql_Aggiornamento(File sqlSourceDir, File sqlDestDir, String sqlScriptName,
  174.             String precedenteVersione, String versioneAttuale, String tipoDatabase,
  175.             boolean configurazioneUpgrade_runtime,
  176.             boolean configurazioneUpgrade_config,
  177.             boolean configurazioneUpgrade_tracce,
  178.             boolean configurazioneUpgrade_statistiche,
  179.             boolean configurazioneUpgrade_monitoraggio) throws Exception {

  181.         
  182.         if(sqlSourceDir.exists()==false){
  183.             throw new Exception("Source dir ["+sqlSourceDir.getAbsolutePath()+"] not exists");
  184.         }
  185.         if(sqlSourceDir.canRead()==false){
  186.             throw new Exception("Source dir ["+sqlSourceDir.getAbsolutePath()+"] cannot read");
  187.         }

  189.         if(sqlDestDir.exists()==false){
  190.             throw new Exception("Dest dir ["+sqlDestDir.getAbsolutePath()+"] not exists");
  191.         }
  192.         if(sqlDestDir.canWrite()==false){
  193.             throw new Exception("Dest dir ["+sqlDestDir.getAbsolutePath()+"] cannot write");
  194.         }
  195.         
  196.         
  197.         
  198.         if(precedenteVersione==null){
  199.             throw new Exception("Precedente versione non fornita");
  200.         }
  201.         if(precedenteVersione.contains(".")==false){
  202.             throw new Exception("Precedente versione in un formato non corretto ["+precedenteVersione+"] ('.' not found)");
  203.         }
  204.         int indexOfFirstPoint = precedenteVersione.indexOf(".");
  205.         if(indexOfFirstPoint<=0){
  206.             throw new Exception("Precedente versione in un formato non corretto ["+precedenteVersione+"] ('.' not found with index)");
  207.         }
  208.         String productVersionString = precedenteVersione.substring(0, indexOfFirstPoint);
  209.         int productVersion = -1;
  210.         try{
  211.             productVersion = Integer.parseInt(productVersionString);
  212.         }catch(Exception e){
  213.             throw new Exception("Precedente versione in un formato non corretto ["+precedenteVersione+"] (productVersion:"+productVersionString+"): "+e.getMessage(),e);
  214.         }
  215.         int indexOfSecondPoint = precedenteVersione.indexOf(".",indexOfFirstPoint+1);
  216.         if(indexOfSecondPoint<=0 || indexOfSecondPoint<=indexOfFirstPoint){
  217.             throw new Exception("Precedente versione in un formato non corretto ["+precedenteVersione+"] (second '.' not found)");
  218.         }
  219.         String majorVersionString = precedenteVersione.substring(indexOfFirstPoint+1, indexOfSecondPoint);
  220.         int majorVersion = -1;
  221.         try{
  222.             majorVersion = Integer.parseInt(majorVersionString);
  223.         }catch(Exception e){
  224.             throw new Exception("Precedente versione in un formato non corretto ["+precedenteVersione+"] (majorVersion:"+majorVersionString+"): "+e.getMessage(),e);
  225.         }
  226.         if(precedenteVersione.length()<=indexOfSecondPoint){
  227.             throw new Exception("Precedente versione in un formato non corretto ["+precedenteVersione+"] (length)");
  228.         }
  229.         String minorVersionString = precedenteVersione.substring(indexOfSecondPoint+1,precedenteVersione.length());
  230.         int minorVersion = -1;
  231.         try{
  232.             minorVersion = Integer.parseInt(minorVersionString);
  233.         }catch(Exception e){
  234.             //throw new Exception("Precedente versione in un formato non corretto ["+precedenteVersione+"] (minorVersion:"+minorVersionString+"): "+e.getMessage(),e);
  235.             // Potrebbe essere una BUILD VERSION
  236.             if(minorVersionString.contains("_")){
  237.                 String newMinor = minorVersionString.split("_")[0];
  238.                 try{
  239.                     minorVersion = Integer.parseInt(newMinor);
  240.                 }catch(Exception eInternal){
  241.                     throw new Exception("Precedente versione in un formato non corretto ["+precedenteVersione+"] (minorVersion:"+minorVersionString+" minorVersionBuildNumber:"+newMinor+"): "+eInternal.getMessage(),eInternal);
  242.                 }
  243.             }
  244.             else{
  245.                 throw new Exception("Precedente versione in un formato non corretto ["+precedenteVersione+"] (minorVersion:"+minorVersionString+"): "+e.getMessage(),e);
  246.             }
  247.             
  248.         }
  249.         //System.out.println(productVersion+"."+majorVersion+"."+minorVersion);
  250.         
  251.         
  252.         int tmpMajorVersion = majorVersion;
  253.         int tmpMinorVersion = minorVersion;
  254.         
  255.         if(tipoDatabase==null){
  256.             throw new Exception("TipoDatabase non fornito");
  257.         }
  258.         TipiDatabase tipiDatabase = TipiDatabase.toEnumConstant(tipoDatabase);
  259.         if(TipiDatabase.DEFAULT.equals(tipiDatabase)) {
  260.             throw new Exception("TipoDatabase fornito ["+tipoDatabase+"] non valido");
  261.         }
  262.         
  263.         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  264.         File infoVersion = null;
  265.         
  266.         while(true){
  267.             
  268.             String actualVersion = productVersion+"."+tmpMajorVersion+"."+tmpMinorVersion;
  269.             String nextVersion = productVersion+"."+tmpMajorVersion+"."+(tmpMinorVersion+1);
  270.             File version = new File(sqlSourceDir,"upgrade_"+actualVersion+"_to_"+nextVersion);
  271.             //System.out.println("CHECK ["+version.getAbsolutePath()+"] ["+version.exists()+"]");
  272.             if(version.exists()){
  273.                 if(version.canRead()==false){
  274.                     throw new Exception("Source version dir ["+version.getAbsolutePath()+"] cannot read");
  275.                 }
  276.                 
  277.                 File tmp = _createSql_Aggiornamento(version, sqlDestDir, bout, nextVersion, tipoDatabase,
  278.                         configurazioneUpgrade_runtime,
  279.                         configurazioneUpgrade_config,
  280.                         configurazioneUpgrade_tracce,
  281.                         configurazioneUpgrade_statistiche,
  282.                         configurazioneUpgrade_monitoraggio);
  283.                 if(tmp!=null) {
  284.                     infoVersion = tmp;
  285.                 }
  286.                 
  287.                 tmpMinorVersion++;
  288.             }
  289.             else{
  290.                 // check upgrade to major version +1
  291.                 actualVersion = productVersion+"."+tmpMajorVersion+".x";
  292.                 nextVersion = productVersion+"."+(tmpMajorVersion+1)+".0";
  293.                 version = new File(sqlSourceDir,"upgrade_"+actualVersion+"_to_"+nextVersion);
  294.                 //System.out.println("CHECK UPGRADE ["+version.getAbsolutePath()+"] ["+version.exists()+"]");
  295.                 if(version.exists()){
  296.                     if(version.canRead()==false){
  297.                         throw new Exception("Source version dir ["+version.getAbsolutePath()+"] cannot read");
  298.                     }
  299.                     
  300.                     File tmp = _createSql_Aggiornamento(version, sqlDestDir, bout, nextVersion, tipoDatabase,
  301.                             configurazioneUpgrade_runtime,
  302.                             configurazioneUpgrade_config,
  303.                             configurazioneUpgrade_tracce,
  304.                             configurazioneUpgrade_statistiche,
  305.                             configurazioneUpgrade_monitoraggio);
  306.                     if(tmp!=null) {
  307.                         infoVersion = tmp;
  308.                     }
  309.                     
  310.                     tmpMajorVersion++;
  311.                     tmpMinorVersion=0;
  312.                 }
  313.                 else{
  314.                     break;
  315.                 }
  316.             }
  317.             
  318.         }
  319.         
  320.         if(infoVersion!=null) {
  321.             byte[] content = FileSystemUtilities.readBytesFromFile(infoVersion);
  322.             bout.write("\n\n".getBytes());
  323.             bout.write(content);
  324.         }
  325.         
  326.         bout.flush();
  327.         bout.close();
  328.         
  329.         String destFileScriptSql = sqlScriptName.replace(".sql", "_upgrade_"+versioneAttuale+".sql");
  330.         
  331.         FileSystemUtilities.writeFile(new File(sqlDestDir, destFileScriptSql), bout.toByteArray());
  332.         
  333.     }
  334.     
  335.     private static File _createSql_Aggiornamento(File sqlVersionSourceDir, File sqlDestDir, ByteArrayOutputStream bout , String nextVersion, String tipoDatabase,
  336.             boolean configurazioneUpgrade_runtime,
  337.             boolean configurazioneUpgrade_config,
  338.             boolean configurazioneUpgrade_tracce,
  339.             boolean configurazioneUpgrade_statistiche,
  340.             boolean configurazioneUpgrade_monitoraggio) throws Exception {
  341.                         
  342.         File sqlVersionSourceDirDatabase = new File(sqlVersionSourceDir, tipoDatabase);
  343.         
  344.         File[] files = sqlVersionSourceDirDatabase.listFiles();
  345.         if(files!=null && files.length>0) {
  346.             
  347.             boolean writeUpgrade = false;
  348.                         
  349.             Arrays.sort(files); // sono ordinati per data
  350.             for(File upgradeFile : files) {
  351.                 
  352.                 if(upgradeFile.getName().contains("-runtimePdD-")) {
  353.                     // runtime
  354.                     if(!configurazioneUpgrade_runtime) {
  355.                         continue;
  356.                     }
  357.                 }
  358.                 else if(upgradeFile.getName().contains("-archiviComunicazioni-")) {
  359.                     // tracce
  360.                     if(!configurazioneUpgrade_tracce) {
  361.                         continue;
  362.                     }
  363.                 }
  364.                 else if(upgradeFile.getName().contains("-informazioniStatistiche-")) {
  365.                     // statistiche
  366.                     if(!configurazioneUpgrade_statistiche) {
  367.                         continue;
  368.                     }
  369.                 }
  370.                 else if(upgradeFile.getName().contains("-monitoraggio-")) {
  371.                     // monitoraggio
  372.                     if(!configurazioneUpgrade_monitoraggio) {
  373.                         continue;
  374.                     }
  375.                 }
  376.                 else {
  377.                     // configurazione (configurazionePdD, registroServizi)
  378.                     if(!configurazioneUpgrade_config) {
  379.                         continue;
  380.                     }
  381.                 }
  382.                 
  383.                 if(writeUpgrade==false) {
  384.                     if(bout!=null){
  385.                         if(bout.size()>0){
  386.                             bout.write("\n\n".getBytes());
  387.                         }
  388.                         bout.write(("-- Upgrade to "+nextVersion).getBytes());
  389.                     }
  390.                     writeUpgrade = true;
  391.                 }
  392.                 
  393.                 _createSqlAggiornamento(upgradeFile, bout); 
  394.             }
  395.             
  396.         }
  397.         
  398.         File sqlVersionSourceDirInfoVersioneUpgrade = new File(sqlVersionSourceDir, "info-patch.sql");
  399.         if(sqlVersionSourceDirInfoVersioneUpgrade.exists()) {
  400.             return sqlVersionSourceDirInfoVersioneUpgrade;
  401.         }
  402.         
  403.         return null;
  404.     }
  405.     
  406.     
  407.     private static void _createSql(File sqlSourceDir,String sourceFile,File sqlDestDir, String destFile,
  408.             int prefix,ByteArrayOutputStream bout,
  409.             boolean splitDDL_DML) throws Exception{
  410.     
  411.         File src = new File(sqlSourceDir, sourceFile);
  412.         if(bout!=null){
  413.             byte[] b = FileSystemUtilities.readBytesFromFile(src);
  414.             if(bout.size()>0){
  415.                 bout.write("\n\n".getBytes());
  416.             }
  417.             bout.write(b);
  418.         }
  419.         else{
  420.             File dest = new File(sqlDestDir, parsePrefix(prefix)+destFile);
  421.             FileSystemUtilities.copy(src, dest);
  422.             if(splitDDL_DML){
  423.                 File destInit = new File(sqlDestDir, dest.getName().replace(".sql", "_init.sql"));
  424.                 splitFileForDDLtoDML(dest, dest, destInit);
  425.             }
  426.         }
  427.     }
  428.     
  429.     private static void _createSqlAggiornamento(File upgradeFile,ByteArrayOutputStream bout) throws Exception{
  430.         if(bout==null) {
  431.             throw new Exception("Param bout is null");
  432.         }
  433.         byte[] b = FileSystemUtilities.readBytesFromFile(upgradeFile);
  434.         if(bout.size()>0){
  435.             bout.write("\n\n".getBytes());
  436.         }
  437.         bout.write(b);
  438.     }
  439.     
  440.     private static String parsePrefix(int prefix){
  441.         if(prefix<10){
  442.             return "0"+prefix+"_";
  443.         }
  444.         else{
  445.             return prefix+"_";
  446.         }
  447.     }
  448.     
  449.     private static void splitFileForDDLtoDML(File sqlFile,File sqlFileDest,File sqlFileInitDest) throws Exception{
  450.         
  451.         boolean dmlOpen = false;
  452.         
  453.         ByteArrayOutputStream boutDDL = new ByteArrayOutputStream();
  454.         ByteArrayOutputStream boutDML = new ByteArrayOutputStream();
  455.         
  456.         BufferedReader br = null;
  457.         try {
  458.             br = new BufferedReader(new FileReader(sqlFile));
  459.             String line;
  460.             while ((line = br.readLine()) != null) {
  461.                // process the line.
  462.                 
  463.                 if(dmlOpen){
  464.                     boutDML.write(line.getBytes());
  465.                     boutDML.write("\n".getBytes());
  466.                     if(line.contains(";")){
  467.                         dmlOpen = false; // finish
  468.                     }
  469.                 }
  470.                 else{
  471.                     if(isDML(line)){
  472.                         dmlOpen = true; // start
  473.                         boutDML.write(line.getBytes());
  474.                         boutDML.write("\n".getBytes());
  475.                         if(line.contains(";")){
  476.                             dmlOpen = false; // finish (in una unica riga)
  477.                         }
  478.                     }
  479.                     else{
  480.                         boutDDL.write(line.getBytes());
  481.                         boutDDL.write("\n".getBytes());
  482.                     }
  483.                 }
  484.                 
  485.             }
  486.         }finally {
  487.             try {
  488.                 if(br!=null)
  489.                     br.close();
  490.             }catch(Throwable t) {
  491.                 // ignore
  492.             }
  493.         }
  494.         
  495.         //System.out.println("DDL["+boutDDL.size()+"] DML["+boutDML.size()+"]");
  496.         
  497.         if(boutDDL.size()>0){
  498.             FileSystemUtilities.writeFile(sqlFileDest, boutDDL.toByteArray());
  499.         }
  500.         if(boutDML.size()>0){
  501.             FileSystemUtilities.writeFile(sqlFileInitDest, boutDML.toByteArray());
  502.         }
  503.         
  504.     }
  505.     private static boolean isDML(String line){
  506.         
  507.         String tmp = new String(line);
  508.         tmp = tmp.trim().toLowerCase();
  509.         
  510.         if(tmp.startsWith("insert ")){
  511.             
  512.             // check hsql, es: INSERT INTO db_info_init_seq VALUES (NEXT VALUE FOR seq_db_info);
  513.             if(tmp.contains("_init_seq ") && tmp.contains("next value ") ){
  514.                 return false;

  516.             }
  517.             
  518.             // insert on tracce_ext_protocol_info
  519.             if(tmp.contains("insert on ")){
  520.                 return false;
  521.             }
  522.             
  523.             return true;
  524.         } 
  525.         else if(tmp.startsWith("update ")){
  526.             
  527.             return true;
  528.             
  529.         }
  530.         else if(tmp.startsWith("delete ")){
  531.             
  532.             // ON DELETE CASCADE
  533.             if(tmp.contains("on delete cascade")){
  534.                 return false;
  535.             }
  536.             
  537.             return true;
  538.             
  539.         }
  540.         return false;
  541.         
  542.     }
  543.     
  544. }
Created with JaCoCo 0.8.8.202204050719